From a67c3d04ead90c7ab5b8ec1e9eab25f4b212d3bf Mon Sep 17 00:00:00 2001 From: github-actions <41898282+github-actions[bot]@users.noreply.github.com> Date: Sun, 14 Apr 2024 12:33:33 +0000 Subject: [PATCH] CI: Update docs for refs/heads/main (9311046bc894263b973ee51d2f9d7fdb2eb6897a) --- docs/geneticalgorithm2/crossovers.html | 878 +++++++++--------- .../data_types/algorithm_params.html | 462 ++++----- docs/geneticalgorithm2/mutations.html | 408 ++++---- docs/geneticalgorithm2/selections.html | 774 +++++++-------- docs/search.js | 2 +- 5 files changed, 1285 insertions(+), 1239 deletions(-) diff --git a/docs/geneticalgorithm2/crossovers.html b/docs/geneticalgorithm2/crossovers.html index 22e4e56..76897df 100644 --- a/docs/geneticalgorithm2/crossovers.html +++ b/docs/geneticalgorithm2/crossovers.html @@ -111,166 +111,170 @@

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

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

Crossover functions static class

+ +

Crossover creates 2 children from 2 parents someway, usually mixing the parents

@@ -498,18 +508,18 @@

- 
23    @staticmethod
-24    def crossovers_dict() -> Dict[str, CrossoverFunc]:
-25        return {
-26            n: getattr(Crossover, n)()
-27            for n in (
-28                'one_point',
-29                'two_point',
-30                'uniform',
-31                'segment',
-32                'shuffle',
-33            )
-34        }
+            
27    @staticmethod
+28    def crossovers_dict() -> Dict[str, CrossoverFunc]:
+29        return {
+30            n: getattr(Crossover, n)()
+31            for n in (
+32                'one_point',
+33                'two_point',
+34                'uniform',
+35                'segment',
+36                'shuffle',
+37            )
+38        }
 

 
 
@@ -528,19 +538,19 @@
- 
36    @staticmethod
-37    def one_point() -> CrossoverFunc:
-38        
-39        def func(x: array1D, y: array1D):
-40            ofs1, ofs2 = get_copies(x, y)
-41        
-42            ran = np.random.randint(0, x.size)
-43            
-44            ofs1[:ran] = y[:ran]
-45            ofs2[:ran] = x[:ran]
-46            
-47            return ofs1, ofs2
-48        return func
+            
40    @staticmethod
+41    def one_point() -> CrossoverFunc:
+42        
+43        def func(x: array1D, y: array1D):
+44            ofs1, ofs2 = get_copies(x, y)
+45        
+46            ran = np.random.randint(0, x.size)
+47            
+48            ofs1[:ran] = y[:ran]
+49            ofs2[:ran] = x[:ran]
+50            
+51            return ofs1, ofs2
+52        return func
 

 
 
@@ -559,20 +569,20 @@
- 
50    @staticmethod
-51    def two_point() -> CrossoverFunc:
-52        
-53        def func(x: array1D, y: array1D):
-54            ofs1, ofs2 = get_copies(x, y)
-55        
-56            ran1 = np.random.randint(0, x.size)
-57            ran2 = np.random.randint(ran1, x.size)
-58            
-59            ofs1[ran1:ran2] = y[ran1:ran2]
-60            ofs2[ran1:ran2] = x[ran1:ran2]
-61
-62            return ofs1, ofs2
-63        return func
+            
54    @staticmethod
+55    def two_point() -> CrossoverFunc:
+56        
+57        def func(x: array1D, y: array1D):
+58            ofs1, ofs2 = get_copies(x, y)
+59        
+60            ran1 = np.random.randint(0, x.size)
+61            ran2 = np.random.randint(ran1, x.size)
+62            
+63            ofs1[ran1:ran2] = y[ran1:ran2]
+64            ofs2[ran1:ran2] = x[ran1:ran2]
+65
+66            return ofs1, ofs2
+67        return func
 

 
 
@@ -591,19 +601,19 @@
- 
65    @staticmethod
-66    def uniform() -> CrossoverFunc:
-67        
-68        def func(x: array1D, y: array1D):
-69            ofs1, ofs2 = get_copies(x, y)
-70        
-71            ran = np.random.random(x.size) < 0.5
-72            ofs1[ran] = y[ran]
-73            ofs2[ran] = x[ran]
-74              
-75            return ofs1, ofs2
-76        
-77        return func
+            
69    @staticmethod
+70    def uniform() -> CrossoverFunc:
+71        
+72        def func(x: array1D, y: array1D):
+73            ofs1, ofs2 = get_copies(x, y)
+74        
+75            ran = np.random.random(x.size) < 0.5
+76            ofs1[ran] = y[ran]
+77            ofs2[ran] = x[ran]
+78              
+79            return ofs1, ofs2
+80        
+81        return func
 

 
 
@@ -622,22 +632,22 @@
- 
79    @staticmethod
-80    def segment(prob: int = 0.6) -> CrossoverFunc:
-81        
-82        def func(x: array1D, y: array1D):
-83            
-84            ofs1, ofs2 = get_copies(x, y)
-85            
-86            p = np.random.random(x.size) < prob
+            
83    @staticmethod
+84    def segment(prob: int = 0.6) -> CrossoverFunc:
+85        
+86        def func(x: array1D, y: array1D):
 87            
-88            for i, val in enumerate(p):
-89                if val:
-90                    ofs1[i], ofs2[i] = ofs2[i], ofs1[i]
+88            ofs1, ofs2 = get_copies(x, y)
+89            
+90            p = np.random.random(x.size) < prob
 91            
-92            return ofs1, ofs2
-93        
-94        return func
+92            for i, val in enumerate(p):
+93                if val:
+94                    ofs1[i], ofs2[i] = ofs2[i], ofs1[i]
+95            
+96            return ofs1, ofs2
+97        
+98        return func
 

 
 
@@ -656,25 +666,25 @@
- 
 96    @staticmethod
- 97    def shuffle() -> CrossoverFunc:
- 98        
- 99        def func(x: array1D, y: array1D):
-100            
-101            ofs1, ofs2 = get_copies(x, y)
-102            
-103            index = np.random.choice(np.arange(0, x.size), x.size, replace=False)
+            
100    @staticmethod
+101    def shuffle() -> CrossoverFunc:
+102        
+103        def func(x: array1D, y: array1D):
 104            
-105            ran = np.random.randint(0, x.size)
+105            ofs1, ofs2 = get_copies(x, y)
 106            
-107            for i in range(ran):
-108                ind = index[i]
-109                ofs1[ind] = y[ind]
-110                ofs2[ind] = x[ind]
-111            
-112            return ofs1, ofs2
-113            
-114        return func
+107            index = np.random.choice(np.arange(0, x.size), x.size, replace=False)
+108            
+109            ran = np.random.randint(0, x.size)
+110            
+111            for i in range(ran):
+112                ind = index[i]
+113                ofs1[ind] = y[ind]
+114                ofs2[ind] = x[ind]
+115            
+116            return ofs1, ofs2
+117            
+118        return func
 

 
 
@@ -693,34 +703,34 @@
- 
116    @staticmethod
-117    def uniform_window(window: int = 7) -> CrossoverFunc:
-118
-119        base_uniform = Crossover.uniform()
-120
-121        def func(x: np.ndarray, y: np.ndarray):
+            
120    @staticmethod
+121    def uniform_window(window: int = 7) -> CrossoverFunc:
 122
-123            if x.size % window != 0:
-124                raise ValueError(f"dimension {x.size} cannot be divided by window {window}")
-125            
-126            items = int(x.size/window)
-127
-128            zip_x, zip_y = base_uniform(np.zeros(items), np.ones(items))
+123        base_uniform = Crossover.uniform()
+124
+125        def func(x: np.ndarray, y: np.ndarray):
+126
+127            if x.size % window != 0:
+128                raise ValueError(f"dimension {x.size} cannot be divided by window {window}")
 129            
-130            ofs1 = np.empty(x.size)
-131            ofs2 = np.empty(x.size)
-132            for i in range(items):
-133                sls = slice(i*window, (i+1)*window, 1)
-134                if zip_x[i] == 0:
-135                    ofs1[sls] = x[sls]
-136                    ofs2[sls] = y[sls]
-137                else:
-138                    ofs2[sls] = x[sls]
-139                    ofs1[sls] = y[sls]                    
-140
-141            return ofs1, ofs2
-142
-143        return func
+130            items = int(x.size/window)
+131
+132            zip_x, zip_y = base_uniform(np.zeros(items), np.ones(items))
+133            
+134            ofs1 = np.empty(x.size)
+135            ofs2 = np.empty(x.size)
+136            for i in range(items):
+137                sls = slice(i*window, (i+1)*window, 1)
+138                if zip_x[i] == 0:
+139                    ofs1[sls] = x[sls]
+140                    ofs2[sls] = y[sls]
+141                else:
+142                    ofs2[sls] = x[sls]
+143                    ofs1[sls] = y[sls]                    
+144
+145            return ofs1, ofs2
+146
+147        return func
 

 
 
@@ -739,15 +749,15 @@
- 
151    @staticmethod
-152    def arithmetic() -> CrossoverFunc:
-153        
-154        def func(x: array1D, y: array1D):
-155            b = random.random()
-156            a = 1-b
-157            return a*x + b*y, a*y + b*x
-158        
-159        return func
+            
155    @staticmethod
+156    def arithmetic() -> CrossoverFunc:
+157        
+158        def func(x: array1D, y: array1D):
+159            b = random.random()
+160            a = 1-b
+161            return a*x + b*y, a*y + b*x
+162        
+163        return func
 

 
 
@@ -766,25 +776,25 @@
- 
161    @staticmethod
-162    def mixed(alpha: float = 0.5) -> CrossoverFunc:
-163        
-164        def func(x: array1D, y: array1D):
-165            
-166            a = np.empty(x.size)
-167            b = np.empty(y.size)
-168            
-169            x_min = np.minimum(x, y)
-170            x_max = np.maximum(x, y)
-171            delta = alpha*(x_max-x_min)
+            
165    @staticmethod
+166    def mixed(alpha: float = 0.5) -> CrossoverFunc:
+167        
+168        def func(x: array1D, y: array1D):
+169            
+170            a = np.empty(x.size)
+171            b = np.empty(y.size)
 172            
-173            for i in range(x.size):
-174                a[i] = np.random.uniform(x_min[i] - delta[i], x_max[i] + delta[i])
-175                b[i] = np.random.uniform(x_min[i] + delta[i], x_max[i] - delta[i])
+173            x_min = np.minimum(x, y)
+174            x_max = np.maximum(x, y)
+175            delta = alpha*(x_max-x_min)
 176            
-177            return a, b
-178        
-179        return func
+177            for i in range(x.size):
+178                a[i] = np.random.uniform(x_min[i] - delta[i], x_max[i] + delta[i])
+179                b[i] = np.random.uniform(x_min[i] + delta[i], x_max[i] - delta[i])
+180            
+181            return a, b
+182        
+183        return func
 

 
 
diff --git a/docs/geneticalgorithm2/data_types/algorithm_params.html b/docs/geneticalgorithm2/data_types/algorithm_params.html
index 2c299b8..4c45a2d 100644
--- a/docs/geneticalgorithm2/data_types/algorithm_params.html
+++ b/docs/geneticalgorithm2/data_types/algorithm_params.html
@@ -174,90 +174,97 @@ 

  61
  62    mutation_probability: float = 0.1
  63    mutation_discrete_probability: Optional[float] = None
- 64
- 65    #  deprecated
- 66    crossover_probability: Optional[float] = None
- 67
- 68    elit_ratio: float = 0.04
- 69    """
- 70    determines the number of elites in the population. 
- 71    
- 72    For example, when population size is 100 and `elit_ratio` is 0.01 
- 73        then there is 4 elite units in the population. 
- 74    If this parameter is set to be zero then `GeneticAlgorithm2` implements 
- 75        a standard genetic algorithm instead of elitist GA
- 76    """
- 77    parents_portion: float = 0.3
- 78    """
- 79    the portion of population filled by the members of the previous generation (aka parents)
- 80    """
- 81
- 82    crossover_type: Union[str, CrossoverFunc] = 'uniform'
- 83    mutation_type: Union[str, MutationFloatFunc] = 'uniform_by_center'
- 84    """mutation type for real variable"""
- 85    mutation_discrete_type: Union[str, MutationIntFunc] = 'uniform_discrete'
- 86    """mutation type for discrete variables"""
- 87    selection_type: Union[str, SelectionFunc] = 'roulette'
+ 64    """
+ 65    works like `mutation_probability` but for discrete variables. 
+ 66    
+ 67    If `None`, will be assigned to `mutation_probability` value; 
+ 68        so just don't specify this parameter 
+ 69        if u don't need special mutation behavior for discrete variables
+ 70    """
+ 71
+ 72    #  deprecated
+ 73    crossover_probability: Optional[float] = None
+ 74
+ 75    elit_ratio: float = 0.04
+ 76    """
+ 77    determines the number of elites in the population. 
+ 78    
+ 79    For example, when population size is 100 and `elit_ratio` is 0.01 
+ 80        then there is 4 elite units in the population. 
+ 81    If this parameter is set to be zero then `GeneticAlgorithm2` implements 
+ 82        a standard genetic algorithm instead of elitist GA
+ 83    """
+ 84    parents_portion: float = 0.3
+ 85    """
+ 86    the portion of population filled by the members of the previous generation (aka parents)
+ 87    """
  88
- 89    def validate(self) -> None:
- 90
- 91        assert int(self.population_size) > 0, f"population size must be integer and >0, not {self.population_size}"
- 92        assert (can_be_prob(self.parents_portion)), "parents_portion must be in range [0,1]"
- 93        assert (can_be_prob(self.mutation_probability)), "mutation_probability must be in range [0,1]"
- 94        assert (can_be_prob(self.elit_ratio)), "elit_ratio must be in range [0,1]"
+ 89    crossover_type: Union[str, CrossoverFunc] = 'uniform'
+ 90    mutation_type: Union[str, MutationFloatFunc] = 'uniform_by_center'
+ 91    """mutation type for real variable"""
+ 92    mutation_discrete_type: Union[str, MutationIntFunc] = 'uniform_discrete'
+ 93    """mutation type for discrete variables"""
+ 94    selection_type: Union[str, SelectionFunc] = 'roulette'
  95
- 96        if self.max_iteration_without_improv is not None and self.max_iteration_without_improv < 1:
- 97            warnings.warn(
- 98                f"max_iteration_without_improv is {self.max_iteration_without_improv} but must be None or int > 0"
- 99            )
-100            self.max_iteration_without_improv = None
-101
-102    def get_CMS_funcs(self) -> Tuple[
-103        CrossoverFunc,
-104        MutationFloatFunc,
-105        MutationIntFunc,
-106        SelectionFunc
-107    ]:
-108        """
-109        Returns:
-110            gotten (crossover, mutation, discrete mutation, selection) as necessary functions
-111        """
-112
-113        result: List[Callable] = []
-114        for name, value, dct in (
-115            ('crossover', self.crossover_type, Crossover.crossovers_dict()),
-116            ('mutation', self.mutation_type, Mutations.mutations_dict()),
-117            ('mutation_discrete', self.mutation_discrete_type, Mutations.mutations_discrete_dict()),
-118            ('selection', self.selection_type, Selection.selections_dict())
-119        ):
-120            if isinstance(value, str):
-121                if value not in dct:
-122                    raise ValueError(
-123                        f"unknown name of {name}: '{value}', must be from {tuple(dct.keys())} or a custom function"
-124                    )
-125                result.append(dct[value])
-126            else:
-127                assert callable(value), f"{name} must be string or callable"
-128                result.append(value)
-129
-130        return tuple(result)
-131
-132    def update(self, dct: Dict[str, Any]):
-133        for name, value in dct.items():
-134            if name not in _algorithm_params_slots:
-135                raise AttributeError(
-136                    f"name '{name}' does not exists in AlgorithmParams fields: "
-137                    f"{', '.join(sorted(_algorithm_params_slots))}"
-138                )
-139        for name, value in dct.items():  # perform update in separate loop only if all is valid
-140            setattr(self, name, value)
-141
-142    @staticmethod
-143    def from_dict(dct: Dict[str, Any]):
-144
-145        result = AlgorithmParams()
-146        result.update(dct)
-147        return result
+ 96    def validate(self) -> None:
+ 97
+ 98        assert int(self.population_size) > 0, f"population size must be integer and >0, not {self.population_size}"
+ 99        assert (can_be_prob(self.parents_portion)), "parents_portion must be in range [0,1]"
+100        assert (can_be_prob(self.mutation_probability)), "mutation_probability must be in range [0,1]"
+101        assert (can_be_prob(self.elit_ratio)), "elit_ratio must be in range [0,1]"
+102
+103        if self.max_iteration_without_improv is not None and self.max_iteration_without_improv < 1:
+104            warnings.warn(
+105                f"max_iteration_without_improv is {self.max_iteration_without_improv} but must be None or int > 0"
+106            )
+107            self.max_iteration_without_improv = None
+108
+109    def get_CMS_funcs(self) -> Tuple[
+110        CrossoverFunc,
+111        MutationFloatFunc,
+112        MutationIntFunc,
+113        SelectionFunc
+114    ]:
+115        """
+116        Returns:
+117            gotten (crossover, mutation, discrete mutation, selection) as necessary functions
+118        """
+119
+120        result: List[Callable] = []
+121        for name, value, dct in (
+122            ('crossover', self.crossover_type, Crossover.crossovers_dict()),
+123            ('mutation', self.mutation_type, Mutations.mutations_dict()),
+124            ('mutation_discrete', self.mutation_discrete_type, Mutations.mutations_discrete_dict()),
+125            ('selection', self.selection_type, Selection.selections_dict())
+126        ):
+127            if isinstance(value, str):
+128                if value not in dct:
+129                    raise ValueError(
+130                        f"unknown name of {name}: '{value}', must be from {tuple(dct.keys())} or a custom function"
+131                    )
+132                result.append(dct[value])
+133            else:
+134                assert callable(value), f"{name} must be string or callable"
+135                result.append(value)
+136
+137        return tuple(result)
+138
+139    def update(self, dct: Dict[str, Any]):
+140        for name, value in dct.items():
+141            if name not in _algorithm_params_slots:
+142                raise AttributeError(
+143                    f"name '{name}' does not exists in AlgorithmParams fields: "
+144                    f"{', '.join(sorted(_algorithm_params_slots))}"
+145                )
+146        for name, value in dct.items():  # perform update in separate loop only if all is valid
+147            setattr(self, name, value)
+148
+149    @staticmethod
+150    def from_dict(dct: Dict[str, Any]):
+151
+152        result = AlgorithmParams()
+153        result.update(dct)
+154        return result
@@ -305,90 +312,97 @@

63 64 mutation_probability: float = 0.1 65 mutation_discrete_probability: Optional[float] = None - 66 - 67 # deprecated - 68 crossover_probability: Optional[float] = None - 69 - 70 elit_ratio: float = 0.04 - 71 """ - 72 determines the number of elites in the population. - 73 - 74 For example, when population size is 100 and `elit_ratio` is 0.01 - 75 then there is 4 elite units in the population. - 76 If this parameter is set to be zero then `GeneticAlgorithm2` implements - 77 a standard genetic algorithm instead of elitist GA - 78 """ - 79 parents_portion: float = 0.3 - 80 """ - 81 the portion of population filled by the members of the previous generation (aka parents) - 82 """ - 83 - 84 crossover_type: Union[str, CrossoverFunc] = 'uniform' - 85 mutation_type: Union[str, MutationFloatFunc] = 'uniform_by_center' - 86 """mutation type for real variable""" - 87 mutation_discrete_type: Union[str, MutationIntFunc] = 'uniform_discrete' - 88 """mutation type for discrete variables""" - 89 selection_type: Union[str, SelectionFunc] = 'roulette' + 66 """ + 67 works like `mutation_probability` but for discrete variables. + 68 + 69 If `None`, will be assigned to `mutation_probability` value; + 70 so just don't specify this parameter + 71 if u don't need special mutation behavior for discrete variables + 72 """ + 73 + 74 # deprecated + 75 crossover_probability: Optional[float] = None + 76 + 77 elit_ratio: float = 0.04 + 78 """ + 79 determines the number of elites in the population. + 80 + 81 For example, when population size is 100 and `elit_ratio` is 0.01 + 82 then there is 4 elite units in the population. + 83 If this parameter is set to be zero then `GeneticAlgorithm2` implements + 84 a standard genetic algorithm instead of elitist GA + 85 """ + 86 parents_portion: float = 0.3 + 87 """ + 88 the portion of population filled by the members of the previous generation (aka parents) + 89 """ 90 - 91 def validate(self) -> None: - 92 - 93 assert int(self.population_size) > 0, f"population size must be integer and >0, not {self.population_size}" - 94 assert (can_be_prob(self.parents_portion)), "parents_portion must be in range [0,1]" - 95 assert (can_be_prob(self.mutation_probability)), "mutation_probability must be in range [0,1]" - 96 assert (can_be_prob(self.elit_ratio)), "elit_ratio must be in range [0,1]" + 91 crossover_type: Union[str, CrossoverFunc] = 'uniform' + 92 mutation_type: Union[str, MutationFloatFunc] = 'uniform_by_center' + 93 """mutation type for real variable""" + 94 mutation_discrete_type: Union[str, MutationIntFunc] = 'uniform_discrete' + 95 """mutation type for discrete variables""" + 96 selection_type: Union[str, SelectionFunc] = 'roulette' 97 - 98 if self.max_iteration_without_improv is not None and self.max_iteration_without_improv < 1: - 99 warnings.warn( -100 f"max_iteration_without_improv is {self.max_iteration_without_improv} but must be None or int > 0" -101 ) -102 self.max_iteration_without_improv = None -103 -104 def get_CMS_funcs(self) -> Tuple[ -105 CrossoverFunc, -106 MutationFloatFunc, -107 MutationIntFunc, -108 SelectionFunc -109 ]: -110 """ -111 Returns: -112 gotten (crossover, mutation, discrete mutation, selection) as necessary functions -113 """ -114 -115 result: List[Callable] = [] -116 for name, value, dct in ( -117 ('crossover', self.crossover_type, Crossover.crossovers_dict()), -118 ('mutation', self.mutation_type, Mutations.mutations_dict()), -119 ('mutation_discrete', self.mutation_discrete_type, Mutations.mutations_discrete_dict()), -120 ('selection', self.selection_type, Selection.selections_dict()) -121 ): -122 if isinstance(value, str): -123 if value not in dct: -124 raise ValueError( -125 f"unknown name of {name}: '{value}', must be from {tuple(dct.keys())} or a custom function" -126 ) -127 result.append(dct[value]) -128 else: -129 assert callable(value), f"{name} must be string or callable" -130 result.append(value) -131 -132 return tuple(result) -133 -134 def update(self, dct: Dict[str, Any]): -135 for name, value in dct.items(): -136 if name not in _algorithm_params_slots: -137 raise AttributeError( -138 f"name '{name}' does not exists in AlgorithmParams fields: " -139 f"{', '.join(sorted(_algorithm_params_slots))}" -140 ) -141 for name, value in dct.items(): # perform update in separate loop only if all is valid -142 setattr(self, name, value) -143 -144 @staticmethod -145 def from_dict(dct: Dict[str, Any]): -146 -147 result = AlgorithmParams() -148 result.update(dct) -149 return result + 98 def validate(self) -> None: + 99 +100 assert int(self.population_size) > 0, f"population size must be integer and >0, not {self.population_size}" +101 assert (can_be_prob(self.parents_portion)), "parents_portion must be in range [0,1]" +102 assert (can_be_prob(self.mutation_probability)), "mutation_probability must be in range [0,1]" +103 assert (can_be_prob(self.elit_ratio)), "elit_ratio must be in range [0,1]" +104 +105 if self.max_iteration_without_improv is not None and self.max_iteration_without_improv < 1: +106 warnings.warn( +107 f"max_iteration_without_improv is {self.max_iteration_without_improv} but must be None or int > 0" +108 ) +109 self.max_iteration_without_improv = None +110 +111 def get_CMS_funcs(self) -> Tuple[ +112 CrossoverFunc, +113 MutationFloatFunc, +114 MutationIntFunc, +115 SelectionFunc +116 ]: +117 """ +118 Returns: +119 gotten (crossover, mutation, discrete mutation, selection) as necessary functions +120 """ +121 +122 result: List[Callable] = [] +123 for name, value, dct in ( +124 ('crossover', self.crossover_type, Crossover.crossovers_dict()), +125 ('mutation', self.mutation_type, Mutations.mutations_dict()), +126 ('mutation_discrete', self.mutation_discrete_type, Mutations.mutations_discrete_dict()), +127 ('selection', self.selection_type, Selection.selections_dict()) +128 ): +129 if isinstance(value, str): +130 if value not in dct: +131 raise ValueError( +132 f"unknown name of {name}: '{value}', must be from {tuple(dct.keys())} or a custom function" +133 ) +134 result.append(dct[value]) +135 else: +136 assert callable(value), f"{name} must be string or callable" +137 result.append(value) +138 +139 return tuple(result) +140 +141 def update(self, dct: Dict[str, Any]): +142 for name, value in dct.items(): +143 if name not in _algorithm_params_slots: +144 raise AttributeError( +145 f"name '{name}' does not exists in AlgorithmParams fields: " +146 f"{', '.join(sorted(_algorithm_params_slots))}" +147 ) +148 for name, value in dct.items(): # perform update in separate loop only if all is valid +149 setattr(self, name, value) +150 +151 @staticmethod +152 def from_dict(dct: Dict[str, Any]): +153 +154 result = AlgorithmParams() +155 result.update(dct) +156 return result @@ -483,7 +497,13 @@

- +

works like mutation_probability but for discrete variables.

+ +

If None, will be assigned to mutation_probability value; + so just don't specify this parameter + if u don't need special mutation behavior for discrete variables

+
+
@@ -594,18 +614,18 @@

- 
 91    def validate(self) -> None:
- 92
- 93        assert int(self.population_size) > 0, f"population size must be integer and >0, not {self.population_size}"
- 94        assert (can_be_prob(self.parents_portion)), "parents_portion must be in range [0,1]"
- 95        assert (can_be_prob(self.mutation_probability)), "mutation_probability must be in range [0,1]"
- 96        assert (can_be_prob(self.elit_ratio)), "elit_ratio must be in range [0,1]"
- 97
- 98        if self.max_iteration_without_improv is not None and self.max_iteration_without_improv < 1:
- 99            warnings.warn(
-100                f"max_iteration_without_improv is {self.max_iteration_without_improv} but must be None or int > 0"
-101            )
-102            self.max_iteration_without_improv = None
+            
 98    def validate(self) -> None:
+ 99
+100        assert int(self.population_size) > 0, f"population size must be integer and >0, not {self.population_size}"
+101        assert (can_be_prob(self.parents_portion)), "parents_portion must be in range [0,1]"
+102        assert (can_be_prob(self.mutation_probability)), "mutation_probability must be in range [0,1]"
+103        assert (can_be_prob(self.elit_ratio)), "elit_ratio must be in range [0,1]"
+104
+105        if self.max_iteration_without_improv is not None and self.max_iteration_without_improv < 1:
+106            warnings.warn(
+107                f"max_iteration_without_improv is {self.max_iteration_without_improv} but must be None or int > 0"
+108            )
+109            self.max_iteration_without_improv = None
 

 
 
@@ -623,35 +643,35 @@
- 
104    def get_CMS_funcs(self) -> Tuple[
-105        CrossoverFunc,
-106        MutationFloatFunc,
-107        MutationIntFunc,
-108        SelectionFunc
-109    ]:
-110        """
-111        Returns:
-112            gotten (crossover, mutation, discrete mutation, selection) as necessary functions
-113        """
-114
-115        result: List[Callable] = []
-116        for name, value, dct in (
-117            ('crossover', self.crossover_type, Crossover.crossovers_dict()),
-118            ('mutation', self.mutation_type, Mutations.mutations_dict()),
-119            ('mutation_discrete', self.mutation_discrete_type, Mutations.mutations_discrete_dict()),
-120            ('selection', self.selection_type, Selection.selections_dict())
-121        ):
-122            if isinstance(value, str):
-123                if value not in dct:
-124                    raise ValueError(
-125                        f"unknown name of {name}: '{value}', must be from {tuple(dct.keys())} or a custom function"
-126                    )
-127                result.append(dct[value])
-128            else:
-129                assert callable(value), f"{name} must be string or callable"
-130                result.append(value)
-131
-132        return tuple(result)
+            
111    def get_CMS_funcs(self) -> Tuple[
+112        CrossoverFunc,
+113        MutationFloatFunc,
+114        MutationIntFunc,
+115        SelectionFunc
+116    ]:
+117        """
+118        Returns:
+119            gotten (crossover, mutation, discrete mutation, selection) as necessary functions
+120        """
+121
+122        result: List[Callable] = []
+123        for name, value, dct in (
+124            ('crossover', self.crossover_type, Crossover.crossovers_dict()),
+125            ('mutation', self.mutation_type, Mutations.mutations_dict()),
+126            ('mutation_discrete', self.mutation_discrete_type, Mutations.mutations_discrete_dict()),
+127            ('selection', self.selection_type, Selection.selections_dict())
+128        ):
+129            if isinstance(value, str):
+130                if value not in dct:
+131                    raise ValueError(
+132                        f"unknown name of {name}: '{value}', must be from {tuple(dct.keys())} or a custom function"
+133                    )
+134                result.append(dct[value])
+135            else:
+136                assert callable(value), f"{name} must be string or callable"
+137                result.append(value)
+138
+139        return tuple(result)
 

 
 
@@ -675,15 +695,15 @@
- 
134    def update(self, dct: Dict[str, Any]):
-135        for name, value in dct.items():
-136            if name not in _algorithm_params_slots:
-137                raise AttributeError(
-138                    f"name '{name}' does not exists in AlgorithmParams fields: "
-139                    f"{', '.join(sorted(_algorithm_params_slots))}"
-140                )
-141        for name, value in dct.items():  # perform update in separate loop only if all is valid
-142            setattr(self, name, value)
+            
141    def update(self, dct: Dict[str, Any]):
+142        for name, value in dct.items():
+143            if name not in _algorithm_params_slots:
+144                raise AttributeError(
+145                    f"name '{name}' does not exists in AlgorithmParams fields: "
+146                    f"{', '.join(sorted(_algorithm_params_slots))}"
+147                )
+148        for name, value in dct.items():  # perform update in separate loop only if all is valid
+149            setattr(self, name, value)
 

 
 
@@ -702,12 +722,12 @@
- 
144    @staticmethod
-145    def from_dict(dct: Dict[str, Any]):
-146
-147        result = AlgorithmParams()
-148        result.update(dct)
-149        return result
+            
151    @staticmethod
+152    def from_dict(dct: Dict[str, Any]):
+153
+154        result = AlgorithmParams()
+155        result.update(dct)
+156        return result
 

 
 
diff --git a/docs/geneticalgorithm2/mutations.html b/docs/geneticalgorithm2/mutations.html
index 20ee509..c5433b9 100644
--- a/docs/geneticalgorithm2/mutations.html
+++ b/docs/geneticalgorithm2/mutations.html
@@ -111,75 +111,79 @@ 

 19
 20
 21class Mutations:
-22    """Mutations functions static class"""
-23
-24    @staticmethod
-25    def mutations_dict() -> Dict[str, MutationFloatFunc]:
-26        return {
-27            n: getattr(Mutations, n)()
-28            for n in (
-29                'uniform_by_x',
-30                'uniform_by_center',
-31                'gauss_by_center',
-32                'gauss_by_x',
-33            )
-34        }
-35
-36    @staticmethod
-37    def mutations_discrete_dict() -> Dict[str, MutationIntFunc]:
-38        return {
-39            'uniform_discrete': Mutations.uniform_discrete()
-40        }
-41
-42    @staticmethod
-43    def uniform_by_x() -> MutationFloatFunc:
-44        
-45        def func(x: float, left: float, right: float):
-46            alp: float = fast_min(x - left, right - x)
-47            return random.uniform(x - alp, x + alp)
-48        return func
-49
-50    @staticmethod
-51    def uniform_by_center() -> MutationFloatFunc:
-52        
-53        def func(x: float, left: float, right: float):
-54            return random.uniform(left, right)
-55        
-56        return func
-57
-58    @staticmethod
-59    def gauss_by_x(sd: float = 0.3) -> MutationFloatFunc:
-60        """
-61        gauss mutation with x as center and sd*length_of_zone as std
-62        """
-63        def func(x: float, left: float, right: float):
-64            std: float = sd * (right - left)
-65            return fast_max(
-66                left, 
-67                fast_min(right, np.random.normal(loc=x, scale=std))
-68            )
-69        
-70        return func
-71
-72    @staticmethod
-73    def gauss_by_center(sd: float = 0.3) -> MutationFloatFunc:
-74        """
-75        gauss mutation with (left+right)/2 as center and sd*length_of_zone as std
-76        """
-77        def func(x: float, left: float, right: float):
-78            std: float = sd * (right - left)
-79            return fast_max(
-80                left, 
-81                fast_min(right, np.random.normal(loc=(left + right) * 0.5, scale=std))
-82            )
-83        
-84        return func
-85
-86    @staticmethod
-87    def uniform_discrete() -> MutationIntFunc:
-88        def func(x: int, left: int, right: int) -> int:
-89            return random.randint(left, right)
-90        return func
+22    """
+23    Mutations functions static class
+24    
+25    Mutation changes the sample randomly providing the evolution component to optimization
+26    """
+27
+28    @staticmethod
+29    def mutations_dict() -> Dict[str, MutationFloatFunc]:
+30        return {
+31            n: getattr(Mutations, n)()
+32            for n in (
+33                'uniform_by_x',
+34                'uniform_by_center',
+35                'gauss_by_center',
+36                'gauss_by_x',
+37            )
+38        }
+39
+40    @staticmethod
+41    def mutations_discrete_dict() -> Dict[str, MutationIntFunc]:
+42        return {
+43            'uniform_discrete': Mutations.uniform_discrete()
+44        }
+45
+46    @staticmethod
+47    def uniform_by_x() -> MutationFloatFunc:
+48        
+49        def func(x: float, left: float, right: float):
+50            alp: float = fast_min(x - left, right - x)
+51            return random.uniform(x - alp, x + alp)
+52        return func
+53
+54    @staticmethod
+55    def uniform_by_center() -> MutationFloatFunc:
+56        
+57        def func(x: float, left: float, right: float):
+58            return random.uniform(left, right)
+59        
+60        return func
+61
+62    @staticmethod
+63    def gauss_by_x(sd: float = 0.3) -> MutationFloatFunc:
+64        """
+65        gauss mutation with x as center and sd*length_of_zone as std
+66        """
+67        def func(x: float, left: float, right: float):
+68            std: float = sd * (right - left)
+69            return fast_max(
+70                left, 
+71                fast_min(right, np.random.normal(loc=x, scale=std))
+72            )
+73        
+74        return func
+75
+76    @staticmethod
+77    def gauss_by_center(sd: float = 0.3) -> MutationFloatFunc:
+78        """
+79        gauss mutation with (left+right)/2 as center and sd*length_of_zone as std
+80        """
+81        def func(x: float, left: float, right: float):
+82            std: float = sd * (right - left)
+83            return fast_max(
+84                left, 
+85                fast_min(right, np.random.normal(loc=(left + right) * 0.5, scale=std))
+86            )
+87        
+88        return func
+89
+90    @staticmethod
+91    def uniform_discrete() -> MutationIntFunc:
+92        def func(x: int, left: int, right: int) -> int:
+93            return random.randint(left, right)
+94        return func
@@ -236,79 +240,85 @@ 

23class Mutations:
-24    """Mutations functions static class"""
-25
-26    @staticmethod
-27    def mutations_dict() -> Dict[str, MutationFloatFunc]:
-28        return {
-29            n: getattr(Mutations, n)()
-30            for n in (
-31                'uniform_by_x',
-32                'uniform_by_center',
-33                'gauss_by_center',
-34                'gauss_by_x',
-35            )
-36        }
-37
-38    @staticmethod
-39    def mutations_discrete_dict() -> Dict[str, MutationIntFunc]:
-40        return {
-41            'uniform_discrete': Mutations.uniform_discrete()
-42        }
-43
-44    @staticmethod
-45    def uniform_by_x() -> MutationFloatFunc:
-46        
-47        def func(x: float, left: float, right: float):
-48            alp: float = fast_min(x - left, right - x)
-49            return random.uniform(x - alp, x + alp)
-50        return func
-51
-52    @staticmethod
-53    def uniform_by_center() -> MutationFloatFunc:
-54        
-55        def func(x: float, left: float, right: float):
-56            return random.uniform(left, right)
-57        
-58        return func
-59
-60    @staticmethod
-61    def gauss_by_x(sd: float = 0.3) -> MutationFloatFunc:
-62        """
-63        gauss mutation with x as center and sd*length_of_zone as std
-64        """
-65        def func(x: float, left: float, right: float):
-66            std: float = sd * (right - left)
-67            return fast_max(
-68                left, 
-69                fast_min(right, np.random.normal(loc=x, scale=std))
-70            )
-71        
-72        return func
-73
-74    @staticmethod
-75    def gauss_by_center(sd: float = 0.3) -> MutationFloatFunc:
-76        """
-77        gauss mutation with (left+right)/2 as center and sd*length_of_zone as std
-78        """
-79        def func(x: float, left: float, right: float):
-80            std: float = sd * (right - left)
-81            return fast_max(
-82                left, 
-83                fast_min(right, np.random.normal(loc=(left + right) * 0.5, scale=std))
-84            )
-85        
-86        return func
-87
-88    @staticmethod
-89    def uniform_discrete() -> MutationIntFunc:
-90        def func(x: int, left: int, right: int) -> int:
-91            return random.randint(left, right)
-92        return func
+24    """
+25    Mutations functions static class
+26    
+27    Mutation changes the sample randomly providing the evolution component to optimization
+28    """
+29
+30    @staticmethod
+31    def mutations_dict() -> Dict[str, MutationFloatFunc]:
+32        return {
+33            n: getattr(Mutations, n)()
+34            for n in (
+35                'uniform_by_x',
+36                'uniform_by_center',
+37                'gauss_by_center',
+38                'gauss_by_x',
+39            )
+40        }
+41
+42    @staticmethod
+43    def mutations_discrete_dict() -> Dict[str, MutationIntFunc]:
+44        return {
+45            'uniform_discrete': Mutations.uniform_discrete()
+46        }
+47
+48    @staticmethod
+49    def uniform_by_x() -> MutationFloatFunc:
+50        
+51        def func(x: float, left: float, right: float):
+52            alp: float = fast_min(x - left, right - x)
+53            return random.uniform(x - alp, x + alp)
+54        return func
+55
+56    @staticmethod
+57    def uniform_by_center() -> MutationFloatFunc:
+58        
+59        def func(x: float, left: float, right: float):
+60            return random.uniform(left, right)
+61        
+62        return func
+63
+64    @staticmethod
+65    def gauss_by_x(sd: float = 0.3) -> MutationFloatFunc:
+66        """
+67        gauss mutation with x as center and sd*length_of_zone as std
+68        """
+69        def func(x: float, left: float, right: float):
+70            std: float = sd * (right - left)
+71            return fast_max(
+72                left, 
+73                fast_min(right, np.random.normal(loc=x, scale=std))
+74            )
+75        
+76        return func
+77
+78    @staticmethod
+79    def gauss_by_center(sd: float = 0.3) -> MutationFloatFunc:
+80        """
+81        gauss mutation with (left+right)/2 as center and sd*length_of_zone as std
+82        """
+83        def func(x: float, left: float, right: float):
+84            std: float = sd * (right - left)
+85            return fast_max(
+86                left, 
+87                fast_min(right, np.random.normal(loc=(left + right) * 0.5, scale=std))
+88            )
+89        
+90        return func
+91
+92    @staticmethod
+93    def uniform_discrete() -> MutationIntFunc:
+94        def func(x: int, left: int, right: int) -> int:
+95            return random.randint(left, right)
+96        return func

Mutations functions static class

+ +

Mutation changes the sample randomly providing the evolution component to optimization

@@ -324,17 +334,17 @@

- 
26    @staticmethod
-27    def mutations_dict() -> Dict[str, MutationFloatFunc]:
-28        return {
-29            n: getattr(Mutations, n)()
-30            for n in (
-31                'uniform_by_x',
-32                'uniform_by_center',
-33                'gauss_by_center',
-34                'gauss_by_x',
-35            )
-36        }
+            
30    @staticmethod
+31    def mutations_dict() -> Dict[str, MutationFloatFunc]:
+32        return {
+33            n: getattr(Mutations, n)()
+34            for n in (
+35                'uniform_by_x',
+36                'uniform_by_center',
+37                'gauss_by_center',
+38                'gauss_by_x',
+39            )
+40        }
 

 
 
@@ -353,11 +363,11 @@
- 
38    @staticmethod
-39    def mutations_discrete_dict() -> Dict[str, MutationIntFunc]:
-40        return {
-41            'uniform_discrete': Mutations.uniform_discrete()
-42        }
+            
42    @staticmethod
+43    def mutations_discrete_dict() -> Dict[str, MutationIntFunc]:
+44        return {
+45            'uniform_discrete': Mutations.uniform_discrete()
+46        }
 

 
 
@@ -376,13 +386,13 @@
- 
44    @staticmethod
-45    def uniform_by_x() -> MutationFloatFunc:
-46        
-47        def func(x: float, left: float, right: float):
-48            alp: float = fast_min(x - left, right - x)
-49            return random.uniform(x - alp, x + alp)
-50        return func
+            
48    @staticmethod
+49    def uniform_by_x() -> MutationFloatFunc:
+50        
+51        def func(x: float, left: float, right: float):
+52            alp: float = fast_min(x - left, right - x)
+53            return random.uniform(x - alp, x + alp)
+54        return func
 

 
 
@@ -401,13 +411,13 @@
- 
52    @staticmethod
-53    def uniform_by_center() -> MutationFloatFunc:
-54        
-55        def func(x: float, left: float, right: float):
-56            return random.uniform(left, right)
-57        
-58        return func
+            
56    @staticmethod
+57    def uniform_by_center() -> MutationFloatFunc:
+58        
+59        def func(x: float, left: float, right: float):
+60            return random.uniform(left, right)
+61        
+62        return func
 

 
 
@@ -426,19 +436,19 @@
- 
60    @staticmethod
-61    def gauss_by_x(sd: float = 0.3) -> MutationFloatFunc:
-62        """
-63        gauss mutation with x as center and sd*length_of_zone as std
-64        """
-65        def func(x: float, left: float, right: float):
-66            std: float = sd * (right - left)
-67            return fast_max(
-68                left, 
-69                fast_min(right, np.random.normal(loc=x, scale=std))
-70            )
-71        
-72        return func
+            
64    @staticmethod
+65    def gauss_by_x(sd: float = 0.3) -> MutationFloatFunc:
+66        """
+67        gauss mutation with x as center and sd*length_of_zone as std
+68        """
+69        def func(x: float, left: float, right: float):
+70            std: float = sd * (right - left)
+71            return fast_max(
+72                left, 
+73                fast_min(right, np.random.normal(loc=x, scale=std))
+74            )
+75        
+76        return func
 

 
 
@@ -459,19 +469,19 @@
- 
74    @staticmethod
-75    def gauss_by_center(sd: float = 0.3) -> MutationFloatFunc:
-76        """
-77        gauss mutation with (left+right)/2 as center and sd*length_of_zone as std
-78        """
-79        def func(x: float, left: float, right: float):
-80            std: float = sd * (right - left)
-81            return fast_max(
-82                left, 
-83                fast_min(right, np.random.normal(loc=(left + right) * 0.5, scale=std))
-84            )
-85        
-86        return func
+            
78    @staticmethod
+79    def gauss_by_center(sd: float = 0.3) -> MutationFloatFunc:
+80        """
+81        gauss mutation with (left+right)/2 as center and sd*length_of_zone as std
+82        """
+83        def func(x: float, left: float, right: float):
+84            std: float = sd * (right - left)
+85            return fast_max(
+86                left, 
+87                fast_min(right, np.random.normal(loc=(left + right) * 0.5, scale=std))
+88            )
+89        
+90        return func
 

 
 
@@ -492,11 +502,11 @@
- 
88    @staticmethod
-89    def uniform_discrete() -> MutationIntFunc:
-90        def func(x: int, left: int, right: int) -> int:
-91            return random.randint(left, right)
-92        return func
+            
92    @staticmethod
+93    def uniform_discrete() -> MutationIntFunc:
+94        def func(x: int, left: int, right: int) -> int:
+95            return random.randint(left, right)
+96        return func
 

 
 
diff --git a/docs/geneticalgorithm2/selections.html b/docs/geneticalgorithm2/selections.html
index 5fcb360..d5ddd18 100644
--- a/docs/geneticalgorithm2/selections.html
+++ b/docs/geneticalgorithm2/selections.html
@@ -111,7 +111,7 @@ 

  16
  17def inverse_scores(scores: array1D) -> array1D:
  18    """
- 19    inverses scores (min val goes to max)
+ 19    inverses scores (min values become to max)
  20    """
  21    minobj = scores[0]
  22    normobj = scores - minobj if minobj < 0 else scores
@@ -144,143 +144,145 @@ 

  49class Selection:
  50    """
  51    Selections functions static class
- 52    """
- 53
- 54    @staticmethod
- 55    def selections_dict() -> Dict[str, SelectionFunc]:
- 56        return {
- 57            n: getattr(Selection, n)()
- 58            for n in (
- 59                'fully_random',
- 60                'roulette',
- 61                'stochastic',
- 62                'sigma_scaling',
- 63                'ranking',
- 64                'linear_ranking',
- 65                'tournament',
- 66            )
- 67        }
- 68
- 69    @staticmethod
- 70    def fully_random() -> SelectionFunc:
- 71        """returns the selector of fully random parents (for tests purposes)"""
- 72        
- 73        def func(scores: array1D, parents_count: int):
- 74            indexes = np.arange(parents_count)
- 75            return np.random.choice(indexes, parents_count, replace=False)
- 76        
- 77        return func
- 78
- 79    @staticmethod
- 80    def roulette() -> SelectionFunc:
- 81        
- 82        def func(scores: array1D, parents_count: int):
- 83            return roulette(inverse_scores(scores), parents_count)
- 84        
- 85        return func
- 86
- 87    @staticmethod
- 88    def stochastic() -> SelectionFunc:
- 89        
- 90        def func(scores: np.ndarray, parents_count: int):
- 91            f = inverse_scores(scores)
- 92            
- 93            fN: float = 1.0 / parents_count
- 94            k: int = 0
- 95            acc: float = 0.0
- 96            parents: List[int] = []
- 97            r: float = random.random() * fN
- 98            
- 99            while len(parents) < parents_count:
-100                
-101                acc += f[k]
+ 52    
+ 53    Selection function selects the population subset according to scores and its own rules
+ 54    """
+ 55
+ 56    @staticmethod
+ 57    def selections_dict() -> Dict[str, SelectionFunc]:
+ 58        return {
+ 59            n: getattr(Selection, n)()
+ 60            for n in (
+ 61                'fully_random',
+ 62                'roulette',
+ 63                'stochastic',
+ 64                'sigma_scaling',
+ 65                'ranking',
+ 66                'linear_ranking',
+ 67                'tournament',
+ 68            )
+ 69        }
+ 70
+ 71    @staticmethod
+ 72    def fully_random() -> SelectionFunc:
+ 73        """returns the selector of fully random parents (for tests purposes)"""
+ 74        
+ 75        def func(scores: array1D, parents_count: int):
+ 76            indexes = np.arange(parents_count)
+ 77            return np.random.choice(indexes, parents_count, replace=False)
+ 78        
+ 79        return func
+ 80
+ 81    @staticmethod
+ 82    def roulette() -> SelectionFunc:
+ 83        
+ 84        def func(scores: array1D, parents_count: int):
+ 85            return roulette(inverse_scores(scores), parents_count)
+ 86        
+ 87        return func
+ 88
+ 89    @staticmethod
+ 90    def stochastic() -> SelectionFunc:
+ 91        
+ 92        def func(scores: np.ndarray, parents_count: int):
+ 93            f = inverse_scores(scores)
+ 94            
+ 95            fN: float = 1.0 / parents_count
+ 96            k: int = 0
+ 97            acc: float = 0.0
+ 98            parents: List[int] = []
+ 99            r: float = random.random() * fN
+100            
+101            while len(parents) < parents_count:
 102                
-103                while acc > r:
-104                    parents.append(k)
-105                    if len(parents) == parents_count: 
-106                        break
-107                    r += fN
-108                
-109                k += 1
-110            
-111            return np.array(parents[:parents_count])
-112        
-113        return func
-114
-115    @staticmethod
-116    def sigma_scaling(epsilon: float = 0.01, is_noisy: bool = False) -> SelectionFunc:
-117        
-118        def func(scores: array1D, parents_count):
-119            f = inverse_scores(scores)
-120            
-121            sigma = np.std(f, ddof = 1) if is_noisy else np.std(f)
-122            average = np.mean(f)
-123            
-124            if sigma == 0:
-125                f = 1
-126            else:
-127                f = np.maximum(epsilon, 1 + (f - average)/(2*sigma))
-128            
-129            return Selection.__roulette(f, parents_count)
-130        
-131        return func
-132
-133    @staticmethod
-134    def ranking() -> SelectionFunc:
-135        
-136        def func(scores: array1D, parents_count: int):
-137            return roulette(1 + np.arange(parents_count)[::-1], parents_count)
-138        
-139        return func
-140
-141    @staticmethod
-142    def linear_ranking(selection_pressure: float = 1.5) -> SelectionFunc:
-143        
-144        assert 1 <= selection_pressure <= 2, f"selection_pressure should be in (1, 2), but got {selection_pressure}"
+103                acc += f[k]
+104                
+105                while acc > r:
+106                    parents.append(k)
+107                    if len(parents) == parents_count: 
+108                        break
+109                    r += fN
+110                
+111                k += 1
+112            
+113            return np.array(parents[:parents_count])
+114        
+115        return func
+116
+117    @staticmethod
+118    def sigma_scaling(epsilon: float = 0.01, is_noisy: bool = False) -> SelectionFunc:
+119        
+120        def func(scores: array1D, parents_count):
+121            f = inverse_scores(scores)
+122            
+123            sigma = np.std(f, ddof = 1) if is_noisy else np.std(f)
+124            average = np.mean(f)
+125            
+126            if sigma == 0:
+127                f = 1
+128            else:
+129                f = np.maximum(epsilon, 1 + (f - average)/(2*sigma))
+130            
+131            return Selection.__roulette(f, parents_count)
+132        
+133        return func
+134
+135    @staticmethod
+136    def ranking() -> SelectionFunc:
+137        
+138        def func(scores: array1D, parents_count: int):
+139            return roulette(1 + np.arange(parents_count)[::-1], parents_count)
+140        
+141        return func
+142
+143    @staticmethod
+144    def linear_ranking(selection_pressure: float = 1.5) -> SelectionFunc:
 145        
-146        def func(scores: array1D, parents_count: int):
-147            tmp = parents_count * (parents_count-1)
-148            alpha = (2 * parents_count - selection_pressure * (parents_count + 1)) / tmp
-149            beta = 2 * (selection_pressure - 1) / tmp
-150
-151            a = -2 * alpha - beta
-152            b = (2 * alpha + beta) ** 2
-153            c = 8 * beta
-154            d = 2 * beta
-155            
-156            indexes = np.arange(parents_count)
+146        assert 1 <= selection_pressure <= 2, f"selection_pressure should be in (1, 2), but got {selection_pressure}"
+147        
+148        def func(scores: array1D, parents_count: int):
+149            tmp = parents_count * (parents_count-1)
+150            alpha = (2 * parents_count - selection_pressure * (parents_count + 1)) / tmp
+151            beta = 2 * (selection_pressure - 1) / tmp
+152
+153            a = -2 * alpha - beta
+154            b = (2 * alpha + beta) ** 2
+155            c = 8 * beta
+156            d = 2 * beta
 157            
-158            return np.array(
-159                [
-160                    indexes[-round((a + math.sqrt(b + c * random.random())) / d)]
-161                    for _ in range(parents_count)
-162                ]
-163            )
-164
-165        return func
+158            indexes = np.arange(parents_count)
+159            
+160            return np.array(
+161                [
+162                    indexes[-round((a + math.sqrt(b + c * random.random())) / d)]
+163                    for _ in range(parents_count)
+164                ]
+165            )
 166
-167    @staticmethod
-168    def tournament(tau: int = 2) -> SelectionFunc:
-169
-170        # NOTE
-171        # this code really does tournament selection
-172        # because scores are always sorted
-173        
-174        def func(scores: array1D, parents_count: int):
-175            
-176            indexes = np.arange(parents_count)
+167        return func
+168
+169    @staticmethod
+170    def tournament(tau: int = 2) -> SelectionFunc:
+171
+172        # NOTE
+173        # this code really does tournament selection
+174        # because scores are always sorted
+175        
+176        def func(scores: array1D, parents_count: int):
 177            
-178            return np.array(
-179                [
-180                    np.min(np.random.choice(indexes, tau, replace=False))
-181                    for _ in range(parents_count)
-182                ]
-183            )
-184        
-185        return func
-186    
-187    
+178            indexes = np.arange(parents_count)
+179            
+180            return np.array(
+181                [
+182                    np.min(np.random.choice(indexes, tau, replace=False))
+183                    for _ in range(parents_count)
+184                ]
+185            )
+186        
+187        return func
 188    
+189    
+190
@@ -312,7 +314,7 @@ 

19def inverse_scores(scores: array1D) -> array1D:
 20    """
-21    inverses scores (min val goes to max)
+21    inverses scores (min values become to max)
 22    """
 23    minobj = scores[0]
 24    normobj = scores - minobj if minobj < 0 else scores
@@ -321,7 +323,7 @@
-

inverses scores (min val goes to max)

+

inverses scores (min values become to max)

@@ -377,144 +379,148 @@ 

 51class Selection:
  52    """
  53    Selections functions static class
- 54    """
- 55
- 56    @staticmethod
- 57    def selections_dict() -> Dict[str, SelectionFunc]:
- 58        return {
- 59            n: getattr(Selection, n)()
- 60            for n in (
- 61                'fully_random',
- 62                'roulette',
- 63                'stochastic',
- 64                'sigma_scaling',
- 65                'ranking',
- 66                'linear_ranking',
- 67                'tournament',
- 68            )
- 69        }
- 70
- 71    @staticmethod
- 72    def fully_random() -> SelectionFunc:
- 73        """returns the selector of fully random parents (for tests purposes)"""
- 74        
- 75        def func(scores: array1D, parents_count: int):
- 76            indexes = np.arange(parents_count)
- 77            return np.random.choice(indexes, parents_count, replace=False)
- 78        
- 79        return func
- 80
- 81    @staticmethod
- 82    def roulette() -> SelectionFunc:
- 83        
- 84        def func(scores: array1D, parents_count: int):
- 85            return roulette(inverse_scores(scores), parents_count)
- 86        
- 87        return func
- 88
- 89    @staticmethod
- 90    def stochastic() -> SelectionFunc:
- 91        
- 92        def func(scores: np.ndarray, parents_count: int):
- 93            f = inverse_scores(scores)
- 94            
- 95            fN: float = 1.0 / parents_count
- 96            k: int = 0
- 97            acc: float = 0.0
- 98            parents: List[int] = []
- 99            r: float = random.random() * fN
-100            
-101            while len(parents) < parents_count:
-102                
-103                acc += f[k]
+ 54    
+ 55    Selection function selects the population subset according to scores and its own rules
+ 56    """
+ 57
+ 58    @staticmethod
+ 59    def selections_dict() -> Dict[str, SelectionFunc]:
+ 60        return {
+ 61            n: getattr(Selection, n)()
+ 62            for n in (
+ 63                'fully_random',
+ 64                'roulette',
+ 65                'stochastic',
+ 66                'sigma_scaling',
+ 67                'ranking',
+ 68                'linear_ranking',
+ 69                'tournament',
+ 70            )
+ 71        }
+ 72
+ 73    @staticmethod
+ 74    def fully_random() -> SelectionFunc:
+ 75        """returns the selector of fully random parents (for tests purposes)"""
+ 76        
+ 77        def func(scores: array1D, parents_count: int):
+ 78            indexes = np.arange(parents_count)
+ 79            return np.random.choice(indexes, parents_count, replace=False)
+ 80        
+ 81        return func
+ 82
+ 83    @staticmethod
+ 84    def roulette() -> SelectionFunc:
+ 85        
+ 86        def func(scores: array1D, parents_count: int):
+ 87            return roulette(inverse_scores(scores), parents_count)
+ 88        
+ 89        return func
+ 90
+ 91    @staticmethod
+ 92    def stochastic() -> SelectionFunc:
+ 93        
+ 94        def func(scores: np.ndarray, parents_count: int):
+ 95            f = inverse_scores(scores)
+ 96            
+ 97            fN: float = 1.0 / parents_count
+ 98            k: int = 0
+ 99            acc: float = 0.0
+100            parents: List[int] = []
+101            r: float = random.random() * fN
+102            
+103            while len(parents) < parents_count:
 104                
-105                while acc > r:
-106                    parents.append(k)
-107                    if len(parents) == parents_count: 
-108                        break
-109                    r += fN
-110                
-111                k += 1
-112            
-113            return np.array(parents[:parents_count])
-114        
-115        return func
-116
-117    @staticmethod
-118    def sigma_scaling(epsilon: float = 0.01, is_noisy: bool = False) -> SelectionFunc:
-119        
-120        def func(scores: array1D, parents_count):
-121            f = inverse_scores(scores)
-122            
-123            sigma = np.std(f, ddof = 1) if is_noisy else np.std(f)
-124            average = np.mean(f)
-125            
-126            if sigma == 0:
-127                f = 1
-128            else:
-129                f = np.maximum(epsilon, 1 + (f - average)/(2*sigma))
-130            
-131            return Selection.__roulette(f, parents_count)
-132        
-133        return func
-134
-135    @staticmethod
-136    def ranking() -> SelectionFunc:
-137        
-138        def func(scores: array1D, parents_count: int):
-139            return roulette(1 + np.arange(parents_count)[::-1], parents_count)
-140        
-141        return func
-142
-143    @staticmethod
-144    def linear_ranking(selection_pressure: float = 1.5) -> SelectionFunc:
-145        
-146        assert 1 <= selection_pressure <= 2, f"selection_pressure should be in (1, 2), but got {selection_pressure}"
+105                acc += f[k]
+106                
+107                while acc > r:
+108                    parents.append(k)
+109                    if len(parents) == parents_count: 
+110                        break
+111                    r += fN
+112                
+113                k += 1
+114            
+115            return np.array(parents[:parents_count])
+116        
+117        return func
+118
+119    @staticmethod
+120    def sigma_scaling(epsilon: float = 0.01, is_noisy: bool = False) -> SelectionFunc:
+121        
+122        def func(scores: array1D, parents_count):
+123            f = inverse_scores(scores)
+124            
+125            sigma = np.std(f, ddof = 1) if is_noisy else np.std(f)
+126            average = np.mean(f)
+127            
+128            if sigma == 0:
+129                f = 1
+130            else:
+131                f = np.maximum(epsilon, 1 + (f - average)/(2*sigma))
+132            
+133            return Selection.__roulette(f, parents_count)
+134        
+135        return func
+136
+137    @staticmethod
+138    def ranking() -> SelectionFunc:
+139        
+140        def func(scores: array1D, parents_count: int):
+141            return roulette(1 + np.arange(parents_count)[::-1], parents_count)
+142        
+143        return func
+144
+145    @staticmethod
+146    def linear_ranking(selection_pressure: float = 1.5) -> SelectionFunc:
 147        
-148        def func(scores: array1D, parents_count: int):
-149            tmp = parents_count * (parents_count-1)
-150            alpha = (2 * parents_count - selection_pressure * (parents_count + 1)) / tmp
-151            beta = 2 * (selection_pressure - 1) / tmp
-152
-153            a = -2 * alpha - beta
-154            b = (2 * alpha + beta) ** 2
-155            c = 8 * beta
-156            d = 2 * beta
-157            
-158            indexes = np.arange(parents_count)
+148        assert 1 <= selection_pressure <= 2, f"selection_pressure should be in (1, 2), but got {selection_pressure}"
+149        
+150        def func(scores: array1D, parents_count: int):
+151            tmp = parents_count * (parents_count-1)
+152            alpha = (2 * parents_count - selection_pressure * (parents_count + 1)) / tmp
+153            beta = 2 * (selection_pressure - 1) / tmp
+154
+155            a = -2 * alpha - beta
+156            b = (2 * alpha + beta) ** 2
+157            c = 8 * beta
+158            d = 2 * beta
 159            
-160            return np.array(
-161                [
-162                    indexes[-round((a + math.sqrt(b + c * random.random())) / d)]
-163                    for _ in range(parents_count)
-164                ]
-165            )
-166
-167        return func
+160            indexes = np.arange(parents_count)
+161            
+162            return np.array(
+163                [
+164                    indexes[-round((a + math.sqrt(b + c * random.random())) / d)]
+165                    for _ in range(parents_count)
+166                ]
+167            )
 168
-169    @staticmethod
-170    def tournament(tau: int = 2) -> SelectionFunc:
-171
-172        # NOTE
-173        # this code really does tournament selection
-174        # because scores are always sorted
-175        
-176        def func(scores: array1D, parents_count: int):
-177            
-178            indexes = np.arange(parents_count)
+169        return func
+170
+171    @staticmethod
+172    def tournament(tau: int = 2) -> SelectionFunc:
+173
+174        # NOTE
+175        # this code really does tournament selection
+176        # because scores are always sorted
+177        
+178        def func(scores: array1D, parents_count: int):
 179            
-180            return np.array(
-181                [
-182                    np.min(np.random.choice(indexes, tau, replace=False))
-183                    for _ in range(parents_count)
-184                ]
-185            )
-186        
-187        return func
+180            indexes = np.arange(parents_count)
+181            
+182            return np.array(
+183                [
+184                    np.min(np.random.choice(indexes, tau, replace=False))
+185                    for _ in range(parents_count)
+186                ]
+187            )
+188        
+189        return func

Selections functions static class

+ +

Selection function selects the population subset according to scores and its own rules

@@ -530,20 +536,20 @@

- 
56    @staticmethod
-57    def selections_dict() -> Dict[str, SelectionFunc]:
-58        return {
-59            n: getattr(Selection, n)()
-60            for n in (
-61                'fully_random',
-62                'roulette',
-63                'stochastic',
-64                'sigma_scaling',
-65                'ranking',
-66                'linear_ranking',
-67                'tournament',
-68            )
-69        }
+            
58    @staticmethod
+59    def selections_dict() -> Dict[str, SelectionFunc]:
+60        return {
+61            n: getattr(Selection, n)()
+62            for n in (
+63                'fully_random',
+64                'roulette',
+65                'stochastic',
+66                'sigma_scaling',
+67                'ranking',
+68                'linear_ranking',
+69                'tournament',
+70            )
+71        }
 

 
 
@@ -562,15 +568,15 @@
- 
71    @staticmethod
-72    def fully_random() -> SelectionFunc:
-73        """returns the selector of fully random parents (for tests purposes)"""
-74        
-75        def func(scores: array1D, parents_count: int):
-76            indexes = np.arange(parents_count)
-77            return np.random.choice(indexes, parents_count, replace=False)
-78        
-79        return func
+            
73    @staticmethod
+74    def fully_random() -> SelectionFunc:
+75        """returns the selector of fully random parents (for tests purposes)"""
+76        
+77        def func(scores: array1D, parents_count: int):
+78            indexes = np.arange(parents_count)
+79            return np.random.choice(indexes, parents_count, replace=False)
+80        
+81        return func
 

 
 
@@ -591,13 +597,13 @@
- 
81    @staticmethod
-82    def roulette() -> SelectionFunc:
-83        
-84        def func(scores: array1D, parents_count: int):
-85            return roulette(inverse_scores(scores), parents_count)
-86        
-87        return func
+            
83    @staticmethod
+84    def roulette() -> SelectionFunc:
+85        
+86        def func(scores: array1D, parents_count: int):
+87            return roulette(inverse_scores(scores), parents_count)
+88        
+89        return func
 

 
 
@@ -616,33 +622,33 @@
- 
 89    @staticmethod
- 90    def stochastic() -> SelectionFunc:
- 91        
- 92        def func(scores: np.ndarray, parents_count: int):
- 93            f = inverse_scores(scores)
- 94            
- 95            fN: float = 1.0 / parents_count
- 96            k: int = 0
- 97            acc: float = 0.0
- 98            parents: List[int] = []
- 99            r: float = random.random() * fN
-100            
-101            while len(parents) < parents_count:
-102                
-103                acc += f[k]
+            
 91    @staticmethod
+ 92    def stochastic() -> SelectionFunc:
+ 93        
+ 94        def func(scores: np.ndarray, parents_count: int):
+ 95            f = inverse_scores(scores)
+ 96            
+ 97            fN: float = 1.0 / parents_count
+ 98            k: int = 0
+ 99            acc: float = 0.0
+100            parents: List[int] = []
+101            r: float = random.random() * fN
+102            
+103            while len(parents) < parents_count:
 104                
-105                while acc > r:
-106                    parents.append(k)
-107                    if len(parents) == parents_count: 
-108                        break
-109                    r += fN
-110                
-111                k += 1
-112            
-113            return np.array(parents[:parents_count])
-114        
-115        return func
+105                acc += f[k]
+106                
+107                while acc > r:
+108                    parents.append(k)
+109                    if len(parents) == parents_count: 
+110                        break
+111                    r += fN
+112                
+113                k += 1
+114            
+115            return np.array(parents[:parents_count])
+116        
+117        return func
 

 
 
@@ -661,23 +667,23 @@
- 
117    @staticmethod
-118    def sigma_scaling(epsilon: float = 0.01, is_noisy: bool = False) -> SelectionFunc:
-119        
-120        def func(scores: array1D, parents_count):
-121            f = inverse_scores(scores)
-122            
-123            sigma = np.std(f, ddof = 1) if is_noisy else np.std(f)
-124            average = np.mean(f)
-125            
-126            if sigma == 0:
-127                f = 1
-128            else:
-129                f = np.maximum(epsilon, 1 + (f - average)/(2*sigma))
-130            
-131            return Selection.__roulette(f, parents_count)
-132        
-133        return func
+            
119    @staticmethod
+120    def sigma_scaling(epsilon: float = 0.01, is_noisy: bool = False) -> SelectionFunc:
+121        
+122        def func(scores: array1D, parents_count):
+123            f = inverse_scores(scores)
+124            
+125            sigma = np.std(f, ddof = 1) if is_noisy else np.std(f)
+126            average = np.mean(f)
+127            
+128            if sigma == 0:
+129                f = 1
+130            else:
+131                f = np.maximum(epsilon, 1 + (f - average)/(2*sigma))
+132            
+133            return Selection.__roulette(f, parents_count)
+134        
+135        return func
 

 
 
@@ -696,13 +702,13 @@
- 
135    @staticmethod
-136    def ranking() -> SelectionFunc:
-137        
-138        def func(scores: array1D, parents_count: int):
-139            return roulette(1 + np.arange(parents_count)[::-1], parents_count)
-140        
-141        return func
+            
137    @staticmethod
+138    def ranking() -> SelectionFunc:
+139        
+140        def func(scores: array1D, parents_count: int):
+141            return roulette(1 + np.arange(parents_count)[::-1], parents_count)
+142        
+143        return func
 

 
 
@@ -721,31 +727,31 @@
- 
143    @staticmethod
-144    def linear_ranking(selection_pressure: float = 1.5) -> SelectionFunc:
-145        
-146        assert 1 <= selection_pressure <= 2, f"selection_pressure should be in (1, 2), but got {selection_pressure}"
+            
145    @staticmethod
+146    def linear_ranking(selection_pressure: float = 1.5) -> SelectionFunc:
 147        
-148        def func(scores: array1D, parents_count: int):
-149            tmp = parents_count * (parents_count-1)
-150            alpha = (2 * parents_count - selection_pressure * (parents_count + 1)) / tmp
-151            beta = 2 * (selection_pressure - 1) / tmp
-152
-153            a = -2 * alpha - beta
-154            b = (2 * alpha + beta) ** 2
-155            c = 8 * beta
-156            d = 2 * beta
-157            
-158            indexes = np.arange(parents_count)
+148        assert 1 <= selection_pressure <= 2, f"selection_pressure should be in (1, 2), but got {selection_pressure}"
+149        
+150        def func(scores: array1D, parents_count: int):
+151            tmp = parents_count * (parents_count-1)
+152            alpha = (2 * parents_count - selection_pressure * (parents_count + 1)) / tmp
+153            beta = 2 * (selection_pressure - 1) / tmp
+154
+155            a = -2 * alpha - beta
+156            b = (2 * alpha + beta) ** 2
+157            c = 8 * beta
+158            d = 2 * beta
 159            
-160            return np.array(
-161                [
-162                    indexes[-round((a + math.sqrt(b + c * random.random())) / d)]
-163                    for _ in range(parents_count)
-164                ]
-165            )
-166
-167        return func
+160            indexes = np.arange(parents_count)
+161            
+162            return np.array(
+163                [
+164                    indexes[-round((a + math.sqrt(b + c * random.random())) / d)]
+165                    for _ in range(parents_count)
+166                ]
+167            )
+168
+169        return func
 

 
 
@@ -764,25 +770,25 @@
- 
169    @staticmethod
-170    def tournament(tau: int = 2) -> SelectionFunc:
-171
-172        # NOTE
-173        # this code really does tournament selection
-174        # because scores are always sorted
-175        
-176        def func(scores: array1D, parents_count: int):
-177            
-178            indexes = np.arange(parents_count)
+            
171    @staticmethod
+172    def tournament(tau: int = 2) -> SelectionFunc:
+173
+174        # NOTE
+175        # this code really does tournament selection
+176        # because scores are always sorted
+177        
+178        def func(scores: array1D, parents_count: int):
 179            
-180            return np.array(
-181                [
-182                    np.min(np.random.choice(indexes, tau, replace=False))
-183                    for _ in range(parents_count)
-184                ]
-185            )
-186        
-187        return func
+180            indexes = np.arange(parents_count)
+181            
+182            return np.array(
+183                [
+184                    np.min(np.random.choice(indexes, tau, replace=False))
+185                    for _ in range(parents_count)
+186                ]
+187            )
+188        
+189        return func
 

 
 
diff --git a/docs/search.js b/docs/search.js
index 1c1aecb..8e5233f 100644
--- a/docs/search.js
+++ b/docs/search.js
@@ -1,6 +1,6 @@
 window.pdocSearch = (function(){
 /** elasticlunr - http://weixsong.github.io * Copyright (C) 2017 Oliver Nightingale * Copyright (C) 2017 Wei Song * MIT Licensed */!function(){function e(e){if(null===e||"object"!=typeof e)return e;var t=e.constructor();for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n]);return t}var t=function(e){var n=new t.Index;return n.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),e&&e.call(n,n),n};t.version="0.9.5",lunr=t,t.utils={},t.utils.warn=function(e){return function(t){e.console&&console.warn&&console.warn(t)}}(this),t.utils.toString=function(e){return void 0===e||null===e?"":e.toString()},t.EventEmitter=function(){this.events={}},t.EventEmitter.prototype.addListener=function(){var e=Array.prototype.slice.call(arguments),t=e.pop(),n=e;if("function"!=typeof t)throw new TypeError("last argument must be a function");n.forEach(function(e){this.hasHandler(e)||(this.events[e]=[]),this.events[e].push(t)},this)},t.EventEmitter.prototype.removeListener=function(e,t){if(this.hasHandler(e)){var n=this.events[e].indexOf(t);-1!==n&&(this.events[e].splice(n,1),0==this.events[e].length&&delete this.events[e])}},t.EventEmitter.prototype.emit=function(e){if(this.hasHandler(e)){var t=Array.prototype.slice.call(arguments,1);this.events[e].forEach(function(e){e.apply(void 0,t)},this)}},t.EventEmitter.prototype.hasHandler=function(e){return e in this.events},t.tokenizer=function(e){if(!arguments.length||null===e||void 0===e)return[];if(Array.isArray(e)){var n=e.filter(function(e){return null===e||void 0===e?!1:!0});n=n.map(function(e){return t.utils.toString(e).toLowerCase()});var i=[];return n.forEach(function(e){var n=e.split(t.tokenizer.seperator);i=i.concat(n)},this),i}return e.toString().trim().toLowerCase().split(t.tokenizer.seperator)},t.tokenizer.defaultSeperator=/[\s\-]+/,t.tokenizer.seperator=t.tokenizer.defaultSeperator,t.tokenizer.setSeperator=function(e){null!==e&&void 0!==e&&"object"==typeof e&&(t.tokenizer.seperator=e)},t.tokenizer.resetSeperator=function(){t.tokenizer.seperator=t.tokenizer.defaultSeperator},t.tokenizer.getSeperator=function(){return t.tokenizer.seperator},t.Pipeline=function(){this._queue=[]},t.Pipeline.registeredFunctions={},t.Pipeline.registerFunction=function(e,n){n in t.Pipeline.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+n),e.label=n,t.Pipeline.registeredFunctions[n]=e},t.Pipeline.getRegisteredFunction=function(e){return e in t.Pipeline.registeredFunctions!=!0?null:t.Pipeline.registeredFunctions[e]},t.Pipeline.warnIfFunctionNotRegistered=function(e){var n=e.label&&e.label in this.registeredFunctions;n||t.utils.warn("Function is not registered with pipeline. This may cause problems when serialising the index.\n",e)},t.Pipeline.load=function(e){var n=new t.Pipeline;return e.forEach(function(e){var i=t.Pipeline.getRegisteredFunction(e);if(!i)throw new Error("Cannot load un-registered function: "+e);n.add(i)}),n},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(e){t.Pipeline.warnIfFunctionNotRegistered(e),this._queue.push(e)},this)},t.Pipeline.prototype.after=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i+1,0,n)},t.Pipeline.prototype.before=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i,0,n)},t.Pipeline.prototype.remove=function(e){var t=this._queue.indexOf(e);-1!==t&&this._queue.splice(t,1)},t.Pipeline.prototype.run=function(e){for(var t=[],n=e.length,i=this._queue.length,o=0;n>o;o++){for(var r=e[o],s=0;i>s&&(r=this._queue[s](r,o,e),void 0!==r&&null!==r);s++);void 0!==r&&null!==r&&t.push(r)}return t},t.Pipeline.prototype.reset=function(){this._queue=[]},t.Pipeline.prototype.get=function(){return this._queue},t.Pipeline.prototype.toJSON=function(){return this._queue.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.DocumentStore,this.index={},this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var e=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,e)},t.Index.prototype.off=function(e,t){return this.eventEmitter.removeListener(e,t)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;n._fields=e.fields,n._ref=e.ref,n.documentStore=t.DocumentStore.load(e.documentStore),n.pipeline=t.Pipeline.load(e.pipeline),n.index={};for(var i in e.index)n.index[i]=t.InvertedIndex.load(e.index[i]);return n},t.Index.prototype.addField=function(e){return this._fields.push(e),this.index[e]=new t.InvertedIndex,this},t.Index.prototype.setRef=function(e){return this._ref=e,this},t.Index.prototype.saveDocument=function(e){return this.documentStore=new t.DocumentStore(e),this},t.Index.prototype.addDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.addDoc(i,e),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));this.documentStore.addFieldLength(i,n,o.length);var r={};o.forEach(function(e){e in r?r[e]+=1:r[e]=1},this);for(var s in r){var u=r[s];u=Math.sqrt(u),this.index[n].addToken(s,{ref:i,tf:u})}},this),n&&this.eventEmitter.emit("add",e,this)}},t.Index.prototype.removeDocByRef=function(e){if(e&&this.documentStore.isDocStored()!==!1&&this.documentStore.hasDoc(e)){var t=this.documentStore.getDoc(e);this.removeDoc(t,!1)}},t.Index.prototype.removeDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.hasDoc(i)&&(this.documentStore.removeDoc(i),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));o.forEach(function(e){this.index[n].removeToken(e,i)},this)},this),n&&this.eventEmitter.emit("remove",e,this))}},t.Index.prototype.updateDoc=function(e,t){var t=void 0===t?!0:t;this.removeDocByRef(e[this._ref],!1),this.addDoc(e,!1),t&&this.eventEmitter.emit("update",e,this)},t.Index.prototype.idf=function(e,t){var n="@"+t+"/"+e;if(Object.prototype.hasOwnProperty.call(this._idfCache,n))return this._idfCache[n];var i=this.index[t].getDocFreq(e),o=1+Math.log(this.documentStore.length/(i+1));return this._idfCache[n]=o,o},t.Index.prototype.getFields=function(){return this._fields.slice()},t.Index.prototype.search=function(e,n){if(!e)return[];e="string"==typeof e?{any:e}:JSON.parse(JSON.stringify(e));var i=null;null!=n&&(i=JSON.stringify(n));for(var o=new t.Configuration(i,this.getFields()).get(),r={},s=Object.keys(e),u=0;u0&&t.push(e);for(var i in n)"docs"!==i&&"df"!==i&&this.expandToken(e+i,t,n[i]);return t},t.InvertedIndex.prototype.toJSON=function(){return{root:this.root}},t.Configuration=function(e,n){var e=e||"";if(void 0==n||null==n)throw new Error("fields should not be null");this.config={};var i;try{i=JSON.parse(e),this.buildUserConfig(i,n)}catch(o){t.utils.warn("user configuration parse failed, will use default configuration"),this.buildDefaultConfig(n)}},t.Configuration.prototype.buildDefaultConfig=function(e){this.reset(),e.forEach(function(e){this.config[e]={boost:1,bool:"OR",expand:!1}},this)},t.Configuration.prototype.buildUserConfig=function(e,n){var i="OR",o=!1;if(this.reset(),"bool"in e&&(i=e.bool||i),"expand"in e&&(o=e.expand||o),"fields"in e)for(var r in e.fields)if(n.indexOf(r)>-1){var s=e.fields[r],u=o;void 0!=s.expand&&(u=s.expand),this.config[r]={boost:s.boost||0===s.boost?s.boost:1,bool:s.bool||i,expand:u}}else t.utils.warn("field name in user configuration not found in index instance fields");else this.addAllFields2UserConfig(i,o,n)},t.Configuration.prototype.addAllFields2UserConfig=function(e,t,n){n.forEach(function(n){this.config[n]={boost:1,bool:e,expand:t}},this)},t.Configuration.prototype.get=function(){return this.config},t.Configuration.prototype.reset=function(){this.config={}},lunr.SortedSet=function(){this.length=0,this.elements=[]},lunr.SortedSet.load=function(e){var t=new this;return t.elements=e,t.length=e.length,t},lunr.SortedSet.prototype.add=function(){var e,t;for(e=0;e1;){if(r===e)return o;e>r&&(t=o),r>e&&(n=o),i=n-t,o=t+Math.floor(i/2),r=this.elements[o]}return r===e?o:-1},lunr.SortedSet.prototype.locationFor=function(e){for(var t=0,n=this.elements.length,i=n-t,o=t+Math.floor(i/2),r=this.elements[o];i>1;)e>r&&(t=o),r>e&&(n=o),i=n-t,o=t+Math.floor(i/2),r=this.elements[o];return r>e?o:e>r?o+1:void 0},lunr.SortedSet.prototype.intersect=function(e){for(var t=new lunr.SortedSet,n=0,i=0,o=this.length,r=e.length,s=this.elements,u=e.elements;;){if(n>o-1||i>r-1)break;s[n]!==u[i]?s[n]u[i]&&i++:(t.add(s[n]),n++,i++)}return t},lunr.SortedSet.prototype.clone=function(){var e=new lunr.SortedSet;return e.elements=this.toArray(),e.length=e.elements.length,e},lunr.SortedSet.prototype.union=function(e){var t,n,i;this.length>=e.length?(t=this,n=e):(t=e,n=this),i=t.clone();for(var o=0,r=n.toArray();oGenetic Algorithm (Elitist version) for Python3.8+
\n\n
An implementation of elitist genetic algorithm for solving problems with\ncontinuous, integers, or mixed variables.
\n\n
repo path:       https://github.com/PasaOpasen/geneticalgorithm2
\n\n
code docs path:  https://pasaopasen.github.io/geneticalgorithm2/
\n"}, "geneticalgorithm2.geneticalgorithm2": {"fullname": "geneticalgorithm2.geneticalgorithm2", "modulename": "geneticalgorithm2.geneticalgorithm2", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.Population_initializer": {"fullname": "geneticalgorithm2.Population_initializer", "modulename": "geneticalgorithm2", "qualname": "Population_initializer", "kind": "function", "doc": "
Arguments:
\n\n
    \n
  • select_best_of:  determines population size to select 1/select_best_of best part of start population.\nFor example, for select_best_of = 4 and population_size = N there will be selected N best objects\n    from 5N generated objects (if start_generation=None dictionary).\nIf start_generation is not None dictionary, there will be selected best (start_generation) / N objects
    • \n
  • local_optimization_step:  when to perform local optimization
    • \n
  • local_optimizer:  the local optimization function (object array, its score) -> (modified array, its score)
    • \n
\n\n
Returns:
\n\n
\n  
select_best_of, population modifier
\n
\n", "signature": "(\tselect_best_of: int = 4,\tlocal_optimization_step: Literal['before_select', 'after_select', 'never'] = 'never',\tlocal_optimizer: Union[Callable[[numpy.ndarray, float], Tuple[numpy.ndarray, float]], NoneType] = None) -> Tuple[int, Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]]:", "funcdef": "def"}, "geneticalgorithm2.callbacks": {"fullname": "geneticalgorithm2.callbacks", "modulename": "geneticalgorithm2.callbacks", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.callbacks.data": {"fullname": "geneticalgorithm2.callbacks.data", "modulename": "geneticalgorithm2.callbacks.data", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData", "kind": "class", "doc": "
data object using in middle callbacks
\n", "bases": "geneticalgorithm2.data_types.base.DictLikeGetSet"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.__init__", "kind": "function", "doc": "
\n", "signature": "(\treason_to_stop: Union[str, NoneType],\tlast_generation: geneticalgorithm2.data_types.generation.Generation,\tcurrent_generation: int,\treport_list: List[float],\tmutation_prob: float,\tmutation_discrete_prob: float,\tmutation: Callable[[float, float, float], float],\tmutation_discrete: Callable[[int, int, int], int],\tcrossover: Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]],\tselection: Callable[[numpy.ndarray, int], numpy.ndarray],\tcurrent_stagnation: int,\tmax_stagnation: int,\tparents_portion: float,\telit_ratio: float,\tset_function: Callable[[numpy.ndarray], numpy.ndarray])"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.reason_to_stop", "kind": "variable", "doc": "
\n", "annotation": ": Union[str, NoneType]"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.last_generation", "kind": "variable", "doc": "
\n", "annotation": ": geneticalgorithm2.data_types.generation.Generation"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.current_generation", "kind": "variable", "doc": "
\n", "annotation": ": int"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.report_list", "kind": "variable", "doc": "
\n", "annotation": ": List[float]"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.mutation_prob", "kind": "variable", "doc": "
\n", "annotation": ": float"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.mutation_discrete_prob", "kind": "variable", "doc": "
\n", "annotation": ": float"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.mutation", "kind": "variable", "doc": "
\n", "annotation": ": Callable[[float, float, float], float]"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.mutation_discrete", "kind": "variable", "doc": "
\n", "annotation": ": Callable[[int, int, int], int]"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.crossover", "kind": "variable", "doc": "
\n", "annotation": ": Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.selection", "kind": "variable", "doc": "
\n", "annotation": ": Callable[[numpy.ndarray, int], numpy.ndarray]"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.current_stagnation", "kind": "variable", "doc": "
\n", "annotation": ": int"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.max_stagnation", "kind": "variable", "doc": "
\n", "annotation": ": int"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.parents_portion", "kind": "variable", "doc": "
\n", "annotation": ": float"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.elit_ratio", "kind": "variable", "doc": "
\n", "annotation": ": float"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.set_function", "kind": "variable", "doc": "
\n", "annotation": ": Callable[[numpy.ndarray], numpy.ndarray]"}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"fullname": "geneticalgorithm2.callbacks.data.SimpleCallbackFunc", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "SimpleCallbackFunc", "kind": "variable", "doc": "
Callback function performs any operations on \n    (generation number, best scores report list, last population matrix, last scores vector)
\n\n
Notes: generation number cannot be changed
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Callable[[int, typing.List[float], numpy.ndarray, numpy.ndarray], NoneType]"}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackConditionFunc", "kind": "variable", "doc": "
Function (middle callback data) -> (bool value means whether to call middle callback action)
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], bool]"}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackActionFunc", "kind": "variable", "doc": "
Function which transforms and returns middle callback data or just uses it some way
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], geneticalgorithm2.callbacks.data.MiddleCallbackData]"}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackFunc", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackFunc", "kind": "variable", "doc": "
Function (input middle callback data) -> (output callback data, changes flag)\n    where input and output data may be same \n    and changes flag means whether the output data must be read back\n        to the optimization process (to update by flag only one time -- for acceleration purposes)
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], typing.Tuple[geneticalgorithm2.callbacks.data.MiddleCallbackData, bool]]"}, "geneticalgorithm2.callbacks.middle": {"fullname": "geneticalgorithm2.callbacks.middle", "modulename": "geneticalgorithm2.callbacks.middle", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.callbacks.middle.Actions": {"fullname": "geneticalgorithm2.callbacks.middle.Actions", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "Actions", "kind": "class", "doc": "
Static class of built-in middle callback actions
\n"}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"fullname": "geneticalgorithm2.callbacks.middle.Actions.Stop", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "Actions.Stop", "kind": "function", "doc": "
stops optimization
\n", "signature": "(\treason_name: str = 'stopped by Stop callback') -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], geneticalgorithm2.callbacks.data.MiddleCallbackData]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"fullname": "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "Actions.ReduceMutationProb", "kind": "function", "doc": "
reduces mutation prob by the coefficient
\n", "signature": "(\treduce_coef: float = 0.9) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], geneticalgorithm2.callbacks.data.MiddleCallbackData]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"fullname": "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "Actions.ChangeRandomCrossover", "kind": "function", "doc": "
randomly changes crossover
\n", "signature": "(\tavailable_crossovers: Sequence[Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]]) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], geneticalgorithm2.callbacks.data.MiddleCallbackData]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"fullname": "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "Actions.ChangeRandomSelection", "kind": "function", "doc": "
randomly changes selection function
\n", "signature": "(\tavailable_selections: Sequence[Callable[[numpy.ndarray, int], numpy.ndarray]]) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], geneticalgorithm2.callbacks.data.MiddleCallbackData]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"fullname": "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "Actions.ChangeRandomMutation", "kind": "function", "doc": "
randomly changes mutation function
\n", "signature": "(\tavailable_mutations: Sequence[Union[Callable[[int, int, int], int], Callable[[float, float, float], float]]]) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], geneticalgorithm2.callbacks.data.MiddleCallbackData]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"fullname": "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "Actions.RemoveDuplicates", "kind": "function", "doc": "
Removes duplicates from population
\n\n
Arguments:
\n\n
    \n
  • oppositor:  oppositor from OppOpPopInit, optional\noppositor for applying after duplicates removing.\nNone (default) means to just use the random initializer from creator.
    • \n
  • creator:  the function creates population samples, optional\nthe function creates population samples if oppositor is None. The default is None.
    • \n
  • converter:  function converts (preprocesses) population samples in new format to compare (if needed)\nbefore duplicates will be searched
    • \n
\n", "signature": "(\toppositor: Union[Callable[[numpy.ndarray], numpy.ndarray], NoneType] = None,\tcreator: Union[Callable[[], numpy.ndarray], NoneType] = None,\tconverter: Union[Callable[[numpy.ndarray], numpy.ndarray], NoneType] = None) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], geneticalgorithm2.callbacks.data.MiddleCallbackData]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"fullname": "geneticalgorithm2.callbacks.middle.Actions.CopyBest", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "Actions.CopyBest", "kind": "function", "doc": "
Copies best population object values (from dimensions in by_indexes) to all population
\n", "signature": "(\tby_indexes: Sequence[int]) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], geneticalgorithm2.callbacks.data.MiddleCallbackData]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"fullname": "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "Actions.PlotPopulationScores", "kind": "function", "doc": "
plots population scores\nneeds 2 functions like data->str for title and file name
\n", "signature": "(\ttitle_pattern: Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], str] = <function Actions.<lambda>>,\tsave_as_name_pattern: Union[Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], str], NoneType] = None) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], geneticalgorithm2.callbacks.data.MiddleCallbackData]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"fullname": "geneticalgorithm2.callbacks.middle.ActionConditions", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "ActionConditions", "kind": "class", "doc": "
Static class of built-in middle callback actions
\n"}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"fullname": "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "ActionConditions.EachGen", "kind": "function", "doc": "
\n", "signature": "(\tgeneration_step: int = 10) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], bool]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"fullname": "geneticalgorithm2.callbacks.middle.ActionConditions.Always", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "ActionConditions.Always", "kind": "function", "doc": "
makes action each generation
\n", "signature": "() -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], bool]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"fullname": "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "ActionConditions.AfterStagnation", "kind": "function", "doc": "
\n", "signature": "(\tstagnation_generations: int = 50) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], bool]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"fullname": "geneticalgorithm2.callbacks.middle.ActionConditions.All", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "ActionConditions.All", "kind": "function", "doc": "
returns function which checks all conditions from conditions
\n", "signature": "(\tconditions: Sequence[Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], bool]]) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], bool]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"fullname": "geneticalgorithm2.callbacks.middle.ActionConditions.Any", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "ActionConditions.Any", "kind": "function", "doc": "
returns function which checks for any conditions from conditions
\n", "signature": "(\tconditions: Sequence[Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], bool]]) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], bool]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"fullname": "geneticalgorithm2.callbacks.middle.MiddleCallbacks", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "MiddleCallbacks", "kind": "class", "doc": "
Static class for middle callbacks creation
\n"}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"fullname": "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "MiddleCallbacks.UniversalCallback", "kind": "function", "doc": "
universal function which constructs middle callback from action and condition
\n\n
Arguments:
\n\n
    \n
  • action: 
    • \n
  • condition: 
    • \n
  • set_data_after_callback:  whether to signal internal data update if action update the data
    • \n
\n\n
Returns:
\n", "signature": "(\taction: Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], geneticalgorithm2.callbacks.data.MiddleCallbackData],\tcondition: Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], bool],\tset_data_after_callback: bool = True) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], Tuple[geneticalgorithm2.callbacks.data.MiddleCallbackData, bool]]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"fullname": "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "MiddleCallbacks.ReduceMutationGen", "kind": "function", "doc": "
\n", "signature": "(\treduce_coef: float = 0.9,\tmin_mutation: float = 0.005,\treduce_each_generation: int = 50,\treload_each_generation: int = 500) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], Tuple[geneticalgorithm2.callbacks.data.MiddleCallbackData, bool]]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"fullname": "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "MiddleCallbacks.GeneDiversityStats", "kind": "function", "doc": "
\n", "signature": "(\tstep_generations_for_plotting: int = 10) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], Tuple[geneticalgorithm2.callbacks.data.MiddleCallbackData, bool]]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.simple": {"fullname": "geneticalgorithm2.callbacks.simple", "modulename": "geneticalgorithm2.callbacks.simple", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.callbacks.simple.Callbacks": {"fullname": "geneticalgorithm2.callbacks.simple.Callbacks", "modulename": "geneticalgorithm2.callbacks.simple", "qualname": "Callbacks", "kind": "class", "doc": "
Static class with several simple callback methods
\n"}, "geneticalgorithm2.callbacks.simple.Callbacks.NoneCallback": {"fullname": "geneticalgorithm2.callbacks.simple.Callbacks.NoneCallback", "modulename": "geneticalgorithm2.callbacks.simple", "qualname": "Callbacks.NoneCallback", "kind": "function", "doc": "
\n", "signature": "():", "funcdef": "def"}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"fullname": "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation", "modulename": "geneticalgorithm2.callbacks.simple", "qualname": "Callbacks.SavePopulation", "kind": "function", "doc": "
saves population to disk periodically
\n", "signature": "(\tfolder: Union[str, os.PathLike],\tsave_gen_step: int = 50,\tfile_prefix: str = 'population') -> Callable[[int, List[float], numpy.ndarray, numpy.ndarray], NoneType]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"fullname": "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess", "modulename": "geneticalgorithm2.callbacks.simple", "qualname": "Callbacks.PlotOptimizationProcess", "kind": "function", "doc": "
Saves optimization process plots to disk periodically
\n\n
Arguments:
\n\n
    \n
  • folder: 
    • \n
  • save_gen_step: 
    • \n
  • show: 
    • \n
  • main_color: 
    • \n
  • file_prefix: 
    • \n
\n\n
Returns:
\n", "signature": "(\tfolder: Union[str, os.PathLike],\tsave_gen_step: int = 50,\tshow: bool = False,\tmain_color: str = 'green',\tfile_prefix: str = 'report') -> Callable[[int, List[float], numpy.ndarray, numpy.ndarray], NoneType]:", "funcdef": "def"}, "geneticalgorithm2.crossovers": {"fullname": "geneticalgorithm2.crossovers", "modulename": "geneticalgorithm2.crossovers", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.crossovers.CrossoverFunc": {"fullname": "geneticalgorithm2.crossovers.CrossoverFunc", "modulename": "geneticalgorithm2.crossovers", "qualname": "CrossoverFunc", "kind": "variable", "doc": "
Function (parent1, parent2) -> (child1, child2)
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Callable[[numpy.ndarray, numpy.ndarray], typing.Tuple[numpy.ndarray, numpy.ndarray]]"}, "geneticalgorithm2.crossovers.get_copies": {"fullname": "geneticalgorithm2.crossovers.get_copies", "modulename": "geneticalgorithm2.crossovers", "qualname": "get_copies", "kind": "function", "doc": "
\n", "signature": "(\tx: numpy.ndarray,\ty: numpy.ndarray) -> Tuple[numpy.ndarray, numpy.ndarray]:", "funcdef": "def"}, "geneticalgorithm2.crossovers.Crossover": {"fullname": "geneticalgorithm2.crossovers.Crossover", "modulename": "geneticalgorithm2.crossovers", "qualname": "Crossover", "kind": "class", "doc": "
Crossover functions static class
\n"}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"fullname": "geneticalgorithm2.crossovers.Crossover.crossovers_dict", "modulename": "geneticalgorithm2.crossovers", "qualname": "Crossover.crossovers_dict", "kind": "function", "doc": "
\n", "signature": "() -> Dict[str, Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]]:", "funcdef": "def"}, "geneticalgorithm2.crossovers.Crossover.one_point": {"fullname": "geneticalgorithm2.crossovers.Crossover.one_point", "modulename": "geneticalgorithm2.crossovers", "qualname": "Crossover.one_point", "kind": "function", "doc": "
\n", "signature": "() -> Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]:", "funcdef": "def"}, "geneticalgorithm2.crossovers.Crossover.two_point": {"fullname": "geneticalgorithm2.crossovers.Crossover.two_point", "modulename": "geneticalgorithm2.crossovers", "qualname": "Crossover.two_point", "kind": "function", "doc": "
\n", "signature": "() -> Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]:", "funcdef": "def"}, "geneticalgorithm2.crossovers.Crossover.uniform": {"fullname": "geneticalgorithm2.crossovers.Crossover.uniform", "modulename": "geneticalgorithm2.crossovers", "qualname": "Crossover.uniform", "kind": "function", "doc": "
\n", "signature": "() -> Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]:", "funcdef": "def"}, "geneticalgorithm2.crossovers.Crossover.segment": {"fullname": "geneticalgorithm2.crossovers.Crossover.segment", "modulename": "geneticalgorithm2.crossovers", "qualname": "Crossover.segment", "kind": "function", "doc": "
\n", "signature": "(\tprob: int = 0.6) -> Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]:", "funcdef": "def"}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"fullname": "geneticalgorithm2.crossovers.Crossover.shuffle", "modulename": "geneticalgorithm2.crossovers", "qualname": "Crossover.shuffle", "kind": "function", "doc": "
\n", "signature": "() -> Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]:", "funcdef": "def"}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"fullname": "geneticalgorithm2.crossovers.Crossover.uniform_window", "modulename": "geneticalgorithm2.crossovers", "qualname": "Crossover.uniform_window", "kind": "function", "doc": "
\n", "signature": "(\twindow: int = 7) -> Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]:", "funcdef": "def"}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"fullname": "geneticalgorithm2.crossovers.Crossover.arithmetic", "modulename": "geneticalgorithm2.crossovers", "qualname": "Crossover.arithmetic", "kind": "function", "doc": "
\n", "signature": "() -> Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]:", "funcdef": "def"}, "geneticalgorithm2.crossovers.Crossover.mixed": {"fullname": "geneticalgorithm2.crossovers.Crossover.mixed", "modulename": "geneticalgorithm2.crossovers", "qualname": "Crossover.mixed", "kind": "function", "doc": "
\n", "signature": "(\talpha: float = 0.5) -> Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]:", "funcdef": "def"}, "geneticalgorithm2.data_types": {"fullname": "geneticalgorithm2.data_types", "modulename": "geneticalgorithm2.data_types", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.data_types.algorithm_params": {"fullname": "geneticalgorithm2.data_types.algorithm_params", "modulename": "geneticalgorithm2.data_types.algorithm_params", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams", "kind": "class", "doc": "
Base optimization parameters container
\n", "bases": "geneticalgorithm2.data_types.base.DictLikeGetSet"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.__init__", "kind": "function", "doc": "
\n", "signature": "(\tmax_num_iteration: Union[int, NoneType] = None,\tmax_iteration_without_improv: Union[int, NoneType] = None,\tpopulation_size: int = 100,\tmutation_probability: float = 0.1,\tmutation_discrete_probability: Union[float, NoneType] = None,\tcrossover_probability: Union[float, NoneType] = None,\telit_ratio: float = 0.04,\tparents_portion: float = 0.3,\tcrossover_type: Union[str, Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]] = 'uniform',\tmutation_type: Union[str, Callable[[float, float, float], float]] = 'uniform_by_center',\tmutation_discrete_type: Union[str, Callable[[int, int, int], int]] = 'uniform_discrete',\tselection_type: Union[str, Callable[[numpy.ndarray, int], numpy.ndarray]] = 'roulette')"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.max_num_iteration", "kind": "variable", "doc": "
max iterations count of the algorithm
\n\n
If this parameter's value is None the algorithm sets maximum number of iterations automatically \n    as a function of the dimension, boundaries, and population size. \nThe user may enter any number of iterations that they want. \nIt is highly recommended that the user themselves determines \n    the max_num_iterations and not to use None
\n", "annotation": ": Union[int, NoneType]", "default_value": "None"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.max_iteration_without_improv", "kind": "variable", "doc": "
max iteration without progress
\n\n
if the algorithms does not improve \n    the objective function over the number of successive iterations \n        determined by this parameter, \n        then GA stops and report the best found solution \n        before the max_num_iterations to be met
\n", "annotation": ": Union[int, NoneType]", "default_value": "None"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.population_size", "kind": "variable", "doc": "
determines the number of trial solutions in each iteration
\n", "annotation": ": int", "default_value": "100"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.mutation_probability", "kind": "variable", "doc": "
\n", "annotation": ": float", "default_value": "0.1"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.mutation_discrete_probability", "kind": "variable", "doc": "
\n", "annotation": ": Union[float, NoneType]", "default_value": "None"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.crossover_probability", "kind": "variable", "doc": "
\n", "annotation": ": Union[float, NoneType]", "default_value": "None"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.elit_ratio", "kind": "variable", "doc": "
determines the number of elites in the population. 
\n\n
For example, when population size is 100 and elit_ratio is 0.01 \n    then there is 4 elite units in the population. \nIf this parameter is set to be zero then GeneticAlgorithm2 implements \n    a standard genetic algorithm instead of elitist GA
\n", "annotation": ": float", "default_value": "0.04"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.parents_portion", "kind": "variable", "doc": "
the portion of population filled by the members of the previous generation (aka parents)
\n", "annotation": ": float", "default_value": "0.3"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.crossover_type", "kind": "variable", "doc": "
\n", "annotation": ": Union[str, Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]]", "default_value": "'uniform'"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.mutation_type", "kind": "variable", "doc": "
mutation type for real variable
\n", "annotation": ": Union[str, Callable[[float, float, float], float]]", "default_value": "'uniform_by_center'"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.mutation_discrete_type", "kind": "variable", "doc": "
mutation type for discrete variables
\n", "annotation": ": Union[str, Callable[[int, int, int], int]]", "default_value": "'uniform_discrete'"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.selection_type", "kind": "variable", "doc": "
\n", "annotation": ": Union[str, Callable[[numpy.ndarray, int], numpy.ndarray]]", "default_value": "'roulette'"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.validate", "kind": "function", "doc": "
\n", "signature": "(self) -> None:", "funcdef": "def"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.get_CMS_funcs", "kind": "function", "doc": "
Returns:
\n\n
\n  
gotten (crossover, mutation, discrete mutation, selection) as necessary functions
\n
\n", "signature": "(\tself) -> Tuple[Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[float, float, float], float], Callable[[int, int, int], int], Callable[[numpy.ndarray, int], numpy.ndarray]]:", "funcdef": "def"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.update", "kind": "function", "doc": "
\n", "signature": "(self, dct: Dict[str, Any]):", "funcdef": "def"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.from_dict", "kind": "function", "doc": "
\n", "signature": "(dct: Dict[str, Any]):", "funcdef": "def"}, "geneticalgorithm2.data_types.aliases": {"fullname": "geneticalgorithm2.data_types.aliases", "modulename": "geneticalgorithm2.data_types.aliases", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"fullname": "geneticalgorithm2.data_types.aliases.FunctionToMinimize", "modulename": "geneticalgorithm2.data_types.aliases", "qualname": "FunctionToMinimize", "kind": "variable", "doc": "
usual (vector -> value) function to minimize
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Callable[[numpy.ndarray], float]"}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"fullname": "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize", "modulename": "geneticalgorithm2.data_types.aliases", "qualname": "SetFunctionToMinimize", "kind": "variable", "doc": "
(population -> scores) function to minimize
\n\n
it is like a vectorized version of usual (vector -> value) function\n    performing to all population samples in the one call
\n\n
but it can be written in more optimal way to speed up the calculations;\n    also it can contain any logic due to samples relations and so on -- depends on the task
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Callable[[numpy.ndarray], numpy.ndarray]"}, "geneticalgorithm2.data_types.base": {"fullname": "geneticalgorithm2.data_types.base", "modulename": "geneticalgorithm2.data_types.base", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.data_types.base.DictLikeGetSet": {"fullname": "geneticalgorithm2.data_types.base.DictLikeGetSet", "modulename": "geneticalgorithm2.data_types.base", "qualname": "DictLikeGetSet", "kind": "class", "doc": "
\n"}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"fullname": "geneticalgorithm2.data_types.base.DictLikeGetSet.get", "modulename": "geneticalgorithm2.data_types.base", "qualname": "DictLikeGetSet.get", "kind": "function", "doc": "
\n", "signature": "(self, item):", "funcdef": "def"}, "geneticalgorithm2.data_types.generation": {"fullname": "geneticalgorithm2.data_types.generation", "modulename": "geneticalgorithm2.data_types.generation", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"fullname": "geneticalgorithm2.data_types.generation.GenerationConvertible", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "GenerationConvertible", "kind": "variable", "doc": "
The forms convertible to Generation object:\n    - Generation object\n    - path to saved generation\n    - dict {'population': pop_matrix, 'scores': scores_vector}\n    - wide population matrix\n    - pair (pop_matrix, scores_vector)
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Union[ForwardRef('Generation'), str, typing.Dict[typing.Literal['population', 'scores'], numpy.ndarray], numpy.ndarray, typing.Tuple[typing.Union[numpy.ndarray, NoneType], typing.Union[numpy.ndarray, NoneType]]]"}, "geneticalgorithm2.data_types.generation.Generation": {"fullname": "geneticalgorithm2.data_types.generation.Generation", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "Generation", "kind": "class", "doc": "
wrapper on generation object (pair of samples matrix and samples scores vector)
\n", "bases": "geneticalgorithm2.data_types.base.DictLikeGetSet"}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"fullname": "geneticalgorithm2.data_types.generation.Generation.__init__", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "Generation.__init__", "kind": "function", "doc": "
\n", "signature": "(\tvariables: Union[numpy.ndarray, NoneType] = None,\tscores: Union[numpy.ndarray, NoneType] = None)"}, "geneticalgorithm2.data_types.generation.Generation.variables": {"fullname": "geneticalgorithm2.data_types.generation.Generation.variables", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "Generation.variables", "kind": "variable", "doc": "
\n", "annotation": ": Union[numpy.ndarray, NoneType]", "default_value": "None"}, "geneticalgorithm2.data_types.generation.Generation.scores": {"fullname": "geneticalgorithm2.data_types.generation.Generation.scores", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "Generation.scores", "kind": "variable", "doc": "
\n", "annotation": ": Union[numpy.ndarray, NoneType]", "default_value": "None"}, "geneticalgorithm2.data_types.generation.Generation.size": {"fullname": "geneticalgorithm2.data_types.generation.Generation.size", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "Generation.size", "kind": "variable", "doc": "
\n", "annotation": ": int"}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"fullname": "geneticalgorithm2.data_types.generation.Generation.dim_size", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "Generation.dim_size", "kind": "variable", "doc": "
\n", "annotation": ": int"}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"fullname": "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "Generation.as_wide_matrix", "kind": "function", "doc": "
\n", "signature": "(self) -> numpy.ndarray:", "funcdef": "def"}, "geneticalgorithm2.data_types.generation.Generation.save": {"fullname": "geneticalgorithm2.data_types.generation.Generation.save", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "Generation.save", "kind": "function", "doc": "
\n", "signature": "(self, path: Union[str, os.PathLike]):", "funcdef": "def"}, "geneticalgorithm2.data_types.generation.Generation.load": {"fullname": "geneticalgorithm2.data_types.generation.Generation.load", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "Generation.load", "kind": "function", "doc": "
\n", "signature": "(path: Union[str, os.PathLike]):", "funcdef": "def"}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"fullname": "geneticalgorithm2.data_types.generation.Generation.from_object", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "Generation.from_object", "kind": "function", "doc": "
class constructor
\n", "signature": "(\tdim: int,\tobj: Union[geneticalgorithm2.data_types.generation.Generation, str, Dict[Literal['population', 'scores'], numpy.ndarray], numpy.ndarray, Tuple[Union[numpy.ndarray, NoneType], Union[numpy.ndarray, NoneType]]]):", "funcdef": "def"}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"fullname": "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "Generation.from_pop_matrix", "kind": "function", "doc": "
\n", "signature": "(pop: numpy.ndarray):", "funcdef": "def"}, "geneticalgorithm2.data_types.result": {"fullname": "geneticalgorithm2.data_types.result", "modulename": "geneticalgorithm2.data_types.result", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.data_types.result.GAResult": {"fullname": "geneticalgorithm2.data_types.result.GAResult", "modulename": "geneticalgorithm2.data_types.result", "qualname": "GAResult", "kind": "class", "doc": "
\n", "bases": "geneticalgorithm2.data_types.base.DictLikeGetSet"}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"fullname": "geneticalgorithm2.data_types.result.GAResult.__init__", "modulename": "geneticalgorithm2.data_types.result", "qualname": "GAResult.__init__", "kind": "function", "doc": "
\n", "signature": "(last_generation: geneticalgorithm2.data_types.generation.Generation)"}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"fullname": "geneticalgorithm2.data_types.result.GAResult.last_generation", "modulename": "geneticalgorithm2.data_types.result", "qualname": "GAResult.last_generation", "kind": "variable", "doc": "
\n", "annotation": ": geneticalgorithm2.data_types.generation.Generation"}, "geneticalgorithm2.data_types.result.GAResult.variable": {"fullname": "geneticalgorithm2.data_types.result.GAResult.variable", "modulename": "geneticalgorithm2.data_types.result", "qualname": "GAResult.variable", "kind": "variable", "doc": "
\n", "annotation": ": numpy.ndarray"}, "geneticalgorithm2.data_types.result.GAResult.score": {"fullname": "geneticalgorithm2.data_types.result.GAResult.score", "modulename": "geneticalgorithm2.data_types.result", "qualname": "GAResult.score", "kind": "variable", "doc": "
\n", "annotation": ": float"}, "geneticalgorithm2.data_types.result.GAResult.function": {"fullname": "geneticalgorithm2.data_types.result.GAResult.function", "modulename": "geneticalgorithm2.data_types.result", "qualname": "GAResult.function", "kind": "variable", "doc": "
\n"}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"fullname": "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "VARIABLE_TYPE", "kind": "variable", "doc": "
the variable type for a given or all dimension, determines the values discretion:\n    real: double numbers\n    int: integer number only\n    bool: in the fact is integer with bounds [0, 1]
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Literal['int', 'real', 'bool']"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2", "kind": "class", "doc": "
Genetic algorithm optimization process
\n"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.__init__", "kind": "function", "doc": "
initializes the GA object and performs main checks
\n\n
Arguments:
\n\n
    \n
  • function:  the given objective function to be minimized -- deprecated and moved to run() method
    • \n
  • dimension:  the number of decision variables, the population samples dimension
    • \n
  • variable_type:  string means the variable type for all variables,\nfor mixed types use sequence of strings of type for each variable
    • \n
  • variable_boundaries:  leave it None if variable_type is 'bool';\notherwise provide a sequence of tuples of length two as boundaries for each variable;\nthe length of the array must be equal dimension.\nFor example, ([0,100], [0,200]) determines\n    lower boundary 0 and upper boundary 100 for first\n    and upper boundary 200 for second variable\n    and dimension must be 2.
    • \n
  • variable_type_mixed -- deprecated
    • \n
  • function_timeout:  if the given function does not provide\noutput before function_timeout (unit is seconds) the algorithm raises error.\nFor example, when there is an infinite loop in the given function.\nNone means disabling -- deprecated and moved to run()
    • \n
  • algorithm_parameters:  AlgorithmParams object or usual dictionary with algorithm parameter;\nit is not mandatory to provide all possible parameters
    • \n
\n\n
Notes:
\n\n
\n  
    \n  
  • This implementation minimizes the given objective function.\n  For maximization u can multiply the function by -1 (for instance): the absolute\n  value of the output would be the actual objective function
    • \n  
\n
\n\n
for more details and examples of implementation please visit:\n    https://github.com/PasaOpasen/geneticalgorithm2
\n", "signature": "(\tfunction: Callable[[numpy.ndarray], float] = None,\tdimension: int = 0,\tvariable_type: Union[Literal['int', 'real', 'bool'], Sequence[Literal['int', 'real', 'bool']]] = 'bool',\tvariable_boundaries: Union[numpy.ndarray, Sequence[Tuple[float, float]], NoneType] = None,\tvariable_type_mixed=None,\tfunction_timeout: Union[float, NoneType] = None,\talgorithm_parameters: Union[geneticalgorithm2.data_types.algorithm_params.AlgorithmParams, Dict[str, Any]] = AlgorithmParams(max_num_iteration=None, max_iteration_without_improv=None, population_size=100, mutation_probability=0.1, mutation_discrete_probability=None, crossover_probability=None, elit_ratio=0.04, parents_portion=0.3, crossover_type='uniform', mutation_type='uniform_by_center', mutation_discrete_type='uniform_discrete', selection_type='roulette'))"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.default_params", "kind": "variable", "doc": "
\n", "default_value": "AlgorithmParams(max_num_iteration=None, max_iteration_without_improv=None, population_size=100, mutation_probability=0.1, mutation_discrete_probability=None, crossover_probability=None, elit_ratio=0.04, parents_portion=0.3, crossover_type='uniform', mutation_type='uniform_by_center', mutation_discrete_type='uniform_discrete', selection_type='roulette')"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.PROGRESS_BAR_LEN", "kind": "variable", "doc": "
max count of symbols in the progress bar
\n", "default_value": "20"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.output_dict": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.output_dict", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.output_dict", "kind": "variable", "doc": "
\n"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.needs_mutation", "kind": "variable", "doc": "
whether the mutation is required
\n", "annotation": ": bool"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.revolution_oppositor": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.revolution_oppositor", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.revolution_oppositor", "kind": "variable", "doc": "
\n"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dup_oppositor": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dup_oppositor", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.dup_oppositor", "kind": "variable", "doc": "
\n"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.creator": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.creator", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.creator", "kind": "variable", "doc": "
\n"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.init_oppositors": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.init_oppositors", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.init_oppositors", "kind": "variable", "doc": "
\n"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.f", "kind": "variable", "doc": "
\n", "annotation": ": Callable[[numpy.ndarray], float]"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.funtimeout": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.funtimeout", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.funtimeout", "kind": "variable", "doc": "
\n", "annotation": ": float"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.set_function", "kind": "variable", "doc": "
\n", "annotation": ": Callable[[numpy.ndarray], numpy.ndarray]"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.var_bounds", "kind": "variable", "doc": "
\n", "annotation": ": List[Tuple[Union[int, float], Union[int, float]]]"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.checked_reports", "kind": "variable", "doc": "
\n", "annotation": ": List[Tuple[str, Callable[[numpy.ndarray], NoneType]]]"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.population_size", "kind": "variable", "doc": "
\n", "annotation": ": int"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.progress_stream": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.progress_stream", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.progress_stream", "kind": "variable", "doc": "
\n"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.param": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.param", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.param", "kind": "variable", "doc": "
\n"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dim": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dim", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.dim", "kind": "variable", "doc": "
\n"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.prob_mut", "kind": "variable", "doc": "
\n"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.prob_mut_discrete", "kind": "variable", "doc": "
\n"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.fill_children", "kind": "variable", "doc": "
custom function which adds children for population POP \n    where POP[:parents_count] are parents lines and next lines are for children
\n", "annotation": ": Union[Callable[[numpy.ndarray, int], NoneType], NoneType]"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.run", "kind": "function", "doc": "
runs optimization process
\n\n
Arguments:
\n\n
    \n
  • no_plot:  do not plot results using matplotlib by default
    • \n
  • disable_printing:  do not print log info of optimization process
    • \n
  • progress_bar_stream:  'stdout', 'stderr' or None to disable progress bar
    • \n
  • disable_progress_bar:  deprecated
    • \n
  • function:  the given objective function (sample -> its score) to be minimized;
    • \n
  • function_timeout:  if the given function does not provide\noutput before function_timeout (unit is seconds) the algorithm raises error.\nFor example, when there is an infinite loop in the given function.\nNone means disabling
    • \n
  • set_function:  set function (all samples -> score per sample) to be used instead of usual function\n(usually for optimization purposes)
    • \n
  • apply_function_to_parents:  whether to apply function to parents from previous generation (if it's needed)
    • \n
  • start_generation:  initial generation object of any GenerationConvertible type
    • \n
  • studEA:  using stud EA strategy (crossover with best object always)
    • \n
  • mutation_indexes:  indexes of dimensions where mutation can be performed (all dimensions by default)
    • \n
  • init_creator:  the function creates population samples.\nBy default -- random uniform for real variables and random uniform for int
    • \n
  • init_oppositors:  the list of oppositors creates oppositions for base population. No by default
    • \n
  • duplicates_oppositor:  oppositor for applying after duplicates removing.\nBy default -- using just random initializer from creator
    • \n
  • remove_duplicates_generation_step:  step for removing duplicates (have a sense with discrete tasks).\nNo by default
    • \n
  • revolution_oppositor:  oppositor for revolution time. No by default
    • \n
  • revolution_after_stagnation_step:  create revolution after this generations of stagnation. No by default
    • \n
  • revolution_part:  float, the part of generation to being oppose. By default is 0.3
    • \n
  • population_initializer:  object for actions at population initialization step\nto create better start population. See doc
    • \n
  • stop_when_reached:  stop searching after reaching this value (it can be potential minimum or something else)
    • \n
  • callbacks:  sequence of callback functions with structure:\n(generation_number, report_list, last_population, last_scores) -> do some action
    • \n
  • middle_callbacks:  sequence of functions made MiddleCallback class
    • \n
  • time_limit_secs:  limit time of working (in seconds)
    • \n
  • save_last_generation_as:  path to .npz file for saving last_generation as numpy dictionary like\n{'population': 2D-array, 'scores': 1D-array}, None if doesn't need to save in file
    • \n
  • seed:  random seed (None if doesn't matter)
    • \n
\n\n
Notes:
\n\n
\n  
if function_timeout is enabled then function must be set
\n
\n", "signature": "(\tself,\tno_plot: bool = False,\tdisable_printing: bool = False,\tprogress_bar_stream: Union[str, NoneType] = 'stdout',\tdisable_progress_bar: bool = False,\tfunction: Callable[[numpy.ndarray], float] = None,\tfunction_timeout: Union[float, NoneType] = None,\tset_function: Callable[[numpy.ndarray], numpy.ndarray] = None,\tapply_function_to_parents: bool = False,\tstart_generation: Union[geneticalgorithm2.data_types.generation.Generation, str, Dict[Literal['population', 'scores'], numpy.ndarray], numpy.ndarray, Tuple[Union[numpy.ndarray, NoneType], Union[numpy.ndarray, NoneType]]] = Generation(variables=None, scores=None),\tstudEA: bool = False,\tmutation_indexes: Union[Iterable[int], NoneType] = None,\tinit_creator: Union[Callable[[], numpy.ndarray], NoneType] = None,\tinit_oppositors: Union[Sequence[Callable[[numpy.ndarray], numpy.ndarray]], NoneType] = None,\tduplicates_oppositor: Union[Callable[[numpy.ndarray], numpy.ndarray], NoneType] = None,\tremove_duplicates_generation_step: Union[int, NoneType] = None,\trevolution_oppositor: Union[Callable[[numpy.ndarray], numpy.ndarray], NoneType] = None,\trevolution_after_stagnation_step: Union[int, NoneType] = None,\trevolution_part: float = 0.3,\tpopulation_initializer: Tuple[int, Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]] = (1, <function get_population_initializer.<locals>.process_population>),\tstop_when_reached: Union[float, NoneType] = None,\tcallbacks: Union[Sequence[Callable[[int, List[float], numpy.ndarray, numpy.ndarray], NoneType]], NoneType] = None,\tmiddle_callbacks: Union[Sequence[Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], Tuple[geneticalgorithm2.callbacks.data.MiddleCallbackData, bool]]], NoneType] = None,\ttime_limit_secs: Union[float, NoneType] = None,\tsave_last_generation_as: Union[str, NoneType] = None,\tseed: Union[int, NoneType] = None):", "funcdef": "def"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.plot_results", "kind": "function", "doc": "
Simple plot of self.report (if not empty)
\n", "signature": "(\tself,\ttitle: str = 'Genetic Algorithm',\tsave_as: Union[str, NoneType] = None,\tdpi: int = 200,\tmain_color: str = 'blue'):", "funcdef": "def"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.plot_generation_scores", "kind": "function", "doc": "
Plots barplot of scores of last population
\n", "signature": "(\tself,\ttitle: str = 'Last generation scores',\tsave_as: Union[str, NoneType] = None):", "funcdef": "def"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.mut", "kind": "function", "doc": "
just mutation
\n", "signature": "(self, x: numpy.ndarray):", "funcdef": "def"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.mut_middle", "kind": "function", "doc": "
mutation oriented on parents
\n", "signature": "(self, x: numpy.ndarray, p1: numpy.ndarray, p2: numpy.ndarray):", "funcdef": "def"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.default_set_function", "kind": "function", "doc": "
simple function for creating set_function \nfunction_for_set just applies to each row of population
\n", "signature": "(function_for_set: Callable[[numpy.ndarray], float]):", "funcdef": "def"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.vectorized_set_function", "kind": "function", "doc": "
works like default, but faster for big populations and slower for little\nfunction_for_set just applyes to each row of population
\n", "signature": "(function_for_set: Callable[[numpy.ndarray], float]):", "funcdef": "def"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.set_function_multiprocess", "kind": "function", "doc": "
like function_for_set but uses joblib with n_jobs (-1 goes to count of available processors)
\n", "signature": "(function_for_set: Callable[[numpy.ndarray], float], n_jobs: int = -1):", "funcdef": "def"}, "geneticalgorithm2.mutations": {"fullname": "geneticalgorithm2.mutations", "modulename": "geneticalgorithm2.mutations", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.mutations.MutationFloatFunc": {"fullname": "geneticalgorithm2.mutations.MutationFloatFunc", "modulename": "geneticalgorithm2.mutations", "qualname": "MutationFloatFunc", "kind": "variable", "doc": "
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Callable[[float, float, float], float]"}, "geneticalgorithm2.mutations.MutationIntFunc": {"fullname": "geneticalgorithm2.mutations.MutationIntFunc", "modulename": "geneticalgorithm2.mutations", "qualname": "MutationIntFunc", "kind": "variable", "doc": "
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Callable[[int, int, int], int]"}, "geneticalgorithm2.mutations.MutationFunc": {"fullname": "geneticalgorithm2.mutations.MutationFunc", "modulename": "geneticalgorithm2.mutations", "qualname": "MutationFunc", "kind": "variable", "doc": "
Function (x, left, right) -> value
\n\n
Which mutates x to value according to bounds (left, right)
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Union[typing.Callable[[int, int, int], int], typing.Callable[[float, float, float], float]]"}, "geneticalgorithm2.mutations.Mutations": {"fullname": "geneticalgorithm2.mutations.Mutations", "modulename": "geneticalgorithm2.mutations", "qualname": "Mutations", "kind": "class", "doc": "
Mutations functions static class
\n"}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"fullname": "geneticalgorithm2.mutations.Mutations.mutations_dict", "modulename": "geneticalgorithm2.mutations", "qualname": "Mutations.mutations_dict", "kind": "function", "doc": "
\n", "signature": "() -> Dict[str, Callable[[float, float, float], float]]:", "funcdef": "def"}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"fullname": "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict", "modulename": "geneticalgorithm2.mutations", "qualname": "Mutations.mutations_discrete_dict", "kind": "function", "doc": "
\n", "signature": "() -> Dict[str, Callable[[int, int, int], int]]:", "funcdef": "def"}, "geneticalgorithm2.mutations.Mutations.uniform_by_x": {"fullname": "geneticalgorithm2.mutations.Mutations.uniform_by_x", "modulename": "geneticalgorithm2.mutations", "qualname": "Mutations.uniform_by_x", "kind": "function", "doc": "
\n", "signature": "() -> Callable[[float, float, float], float]:", "funcdef": "def"}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"fullname": "geneticalgorithm2.mutations.Mutations.uniform_by_center", "modulename": "geneticalgorithm2.mutations", "qualname": "Mutations.uniform_by_center", "kind": "function", "doc": "
\n", "signature": "() -> Callable[[float, float, float], float]:", "funcdef": "def"}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"fullname": "geneticalgorithm2.mutations.Mutations.gauss_by_x", "modulename": "geneticalgorithm2.mutations", "qualname": "Mutations.gauss_by_x", "kind": "function", "doc": "
gauss mutation with x as center and sd*length_of_zone as std
\n", "signature": "(sd: float = 0.3) -> Callable[[float, float, float], float]:", "funcdef": "def"}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"fullname": "geneticalgorithm2.mutations.Mutations.gauss_by_center", "modulename": "geneticalgorithm2.mutations", "qualname": "Mutations.gauss_by_center", "kind": "function", "doc": "
gauss mutation with (left+right)/2 as center and sd*length_of_zone as std
\n", "signature": "(sd: float = 0.3) -> Callable[[float, float, float], float]:", "funcdef": "def"}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"fullname": "geneticalgorithm2.mutations.Mutations.uniform_discrete", "modulename": "geneticalgorithm2.mutations", "qualname": "Mutations.uniform_discrete", "kind": "function", "doc": "
\n", "signature": "() -> Callable[[int, int, int], int]:", "funcdef": "def"}, "geneticalgorithm2.population_initializer": {"fullname": "geneticalgorithm2.population_initializer", "modulename": "geneticalgorithm2.population_initializer", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.population_initializer.PopulationModifier": {"fullname": "geneticalgorithm2.population_initializer.PopulationModifier", "modulename": "geneticalgorithm2.population_initializer", "qualname": "PopulationModifier", "kind": "variable", "doc": "
function (population matrix, population scores) -> (new matrix, new scores)\nwhich will perform the bests selection and local optimization and other population transformations
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Callable[[numpy.ndarray, numpy.ndarray], typing.Tuple[numpy.ndarray, numpy.ndarray]]"}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"fullname": "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE", "modulename": "geneticalgorithm2.population_initializer", "qualname": "LOCAL_OPTIMIZATION_STEP_CASE", "kind": "variable", "doc": "
When the local optimization (candidates enhancing) must be performed:\n    * 'never' -- don't do local optimization\n    * 'before_select' -- before selection best N objects \n        (example: do local optimization for 5N objects and select N best results)\n    * 'after_select' -- do local optimization on best selected N objects
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Literal['before_select', 'after_select', 'never']"}, "geneticalgorithm2.population_initializer.get_population_initializer": {"fullname": "geneticalgorithm2.population_initializer.get_population_initializer", "modulename": "geneticalgorithm2.population_initializer", "qualname": "get_population_initializer", "kind": "function", "doc": "
Arguments:
\n\n
    \n
  • select_best_of:  determines population size to select 1/select_best_of best part of start population.\nFor example, for select_best_of = 4 and population_size = N there will be selected N best objects\n    from 5N generated objects (if start_generation=None dictionary).\nIf start_generation is not None dictionary, there will be selected best (start_generation) / N objects
    • \n
  • local_optimization_step:  when to perform local optimization
    • \n
  • local_optimizer:  the local optimization function (object array, its score) -> (modified array, its score)
    • \n
\n\n
Returns:
\n\n
\n  
select_best_of, population modifier
\n
\n", "signature": "(\tselect_best_of: int = 4,\tlocal_optimization_step: Literal['before_select', 'after_select', 'never'] = 'never',\tlocal_optimizer: Union[Callable[[numpy.ndarray, float], Tuple[numpy.ndarray, float]], NoneType] = None) -> Tuple[int, Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]]:", "funcdef": "def"}, "geneticalgorithm2.selections": {"fullname": "geneticalgorithm2.selections", "modulename": "geneticalgorithm2.selections", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.selections.SelectionFunc": {"fullname": "geneticalgorithm2.selections.SelectionFunc", "modulename": "geneticalgorithm2.selections", "qualname": "SelectionFunc", "kind": "variable", "doc": "
Function (scores, count to select) -> indexes of selected
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Callable[[numpy.ndarray, int], numpy.ndarray]"}, "geneticalgorithm2.selections.inverse_scores": {"fullname": "geneticalgorithm2.selections.inverse_scores", "modulename": "geneticalgorithm2.selections", "qualname": "inverse_scores", "kind": "function", "doc": "
inverses scores (min val goes to max)
\n", "signature": "(scores: numpy.ndarray) -> numpy.ndarray:", "funcdef": "def"}, "geneticalgorithm2.selections.roulette": {"fullname": "geneticalgorithm2.selections.roulette", "modulename": "geneticalgorithm2.selections", "qualname": "roulette", "kind": "function", "doc": "
simplest roulette selector for which the highest score means more preferred
\n", "signature": "(scores: numpy.ndarray, parents_count: int) -> numpy.ndarray:", "funcdef": "def"}, "geneticalgorithm2.selections.Selection": {"fullname": "geneticalgorithm2.selections.Selection", "modulename": "geneticalgorithm2.selections", "qualname": "Selection", "kind": "class", "doc": "
Selections functions static class
\n"}, "geneticalgorithm2.selections.Selection.selections_dict": {"fullname": "geneticalgorithm2.selections.Selection.selections_dict", "modulename": "geneticalgorithm2.selections", "qualname": "Selection.selections_dict", "kind": "function", "doc": "
\n", "signature": "() -> Dict[str, Callable[[numpy.ndarray, int], numpy.ndarray]]:", "funcdef": "def"}, "geneticalgorithm2.selections.Selection.fully_random": {"fullname": "geneticalgorithm2.selections.Selection.fully_random", "modulename": "geneticalgorithm2.selections", "qualname": "Selection.fully_random", "kind": "function", "doc": "
returns the selector of fully random parents (for tests purposes)
\n", "signature": "() -> Callable[[numpy.ndarray, int], numpy.ndarray]:", "funcdef": "def"}, "geneticalgorithm2.selections.Selection.roulette": {"fullname": "geneticalgorithm2.selections.Selection.roulette", "modulename": "geneticalgorithm2.selections", "qualname": "Selection.roulette", "kind": "function", "doc": "
\n", "signature": "() -> Callable[[numpy.ndarray, int], numpy.ndarray]:", "funcdef": "def"}, "geneticalgorithm2.selections.Selection.stochastic": {"fullname": "geneticalgorithm2.selections.Selection.stochastic", "modulename": "geneticalgorithm2.selections", "qualname": "Selection.stochastic", "kind": "function", "doc": "
\n", "signature": "() -> Callable[[numpy.ndarray, int], numpy.ndarray]:", "funcdef": "def"}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"fullname": "geneticalgorithm2.selections.Selection.sigma_scaling", "modulename": "geneticalgorithm2.selections", "qualname": "Selection.sigma_scaling", "kind": "function", "doc": "
\n", "signature": "(\tepsilon: float = 0.01,\tis_noisy: bool = False) -> Callable[[numpy.ndarray, int], numpy.ndarray]:", "funcdef": "def"}, "geneticalgorithm2.selections.Selection.ranking": {"fullname": "geneticalgorithm2.selections.Selection.ranking", "modulename": "geneticalgorithm2.selections", "qualname": "Selection.ranking", "kind": "function", "doc": "
\n", "signature": "() -> Callable[[numpy.ndarray, int], numpy.ndarray]:", "funcdef": "def"}, "geneticalgorithm2.selections.Selection.linear_ranking": {"fullname": "geneticalgorithm2.selections.Selection.linear_ranking", "modulename": "geneticalgorithm2.selections", "qualname": "Selection.linear_ranking", "kind": "function", "doc": "
\n", "signature": "(\tselection_pressure: float = 1.5) -> Callable[[numpy.ndarray, int], numpy.ndarray]:", "funcdef": "def"}, "geneticalgorithm2.selections.Selection.tournament": {"fullname": "geneticalgorithm2.selections.Selection.tournament", "modulename": "geneticalgorithm2.selections", "qualname": "Selection.tournament", "kind": "function", "doc": "
\n", "signature": "(tau: int = 2) -> Callable[[numpy.ndarray, int], numpy.ndarray]:", "funcdef": "def"}, "geneticalgorithm2.utils": {"fullname": "geneticalgorithm2.utils", "modulename": "geneticalgorithm2.utils", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.utils.aliases": {"fullname": "geneticalgorithm2.utils.aliases", "modulename": "geneticalgorithm2.utils.aliases", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.utils.aliases.Number": {"fullname": "geneticalgorithm2.utils.aliases.Number", "modulename": "geneticalgorithm2.utils.aliases", "qualname": "Number", "kind": "variable", "doc": "
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Union[int, float]"}, "geneticalgorithm2.utils.aliases.array1D": {"fullname": "geneticalgorithm2.utils.aliases.array1D", "modulename": "geneticalgorithm2.utils.aliases", "qualname": "array1D", "kind": "variable", "doc": "
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "<class 'numpy.ndarray'>"}, "geneticalgorithm2.utils.aliases.array2D": {"fullname": "geneticalgorithm2.utils.aliases.array2D", "modulename": "geneticalgorithm2.utils.aliases", "qualname": "array2D", "kind": "variable", "doc": "
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "<class 'numpy.ndarray'>"}, "geneticalgorithm2.utils.aliases.PathLike": {"fullname": "geneticalgorithm2.utils.aliases.PathLike", "modulename": "geneticalgorithm2.utils.aliases", "qualname": "PathLike", "kind": "variable", "doc": "
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Union[str, os.PathLike]"}, "geneticalgorithm2.utils.cache": {"fullname": "geneticalgorithm2.utils.cache", "modulename": "geneticalgorithm2.utils.cache", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.utils.cache.np_lru_cache": {"fullname": "geneticalgorithm2.utils.cache.np_lru_cache", "modulename": "geneticalgorithm2.utils.cache", "qualname": "np_lru_cache", "kind": "function", "doc": "
LRU cache implementation for functions whose FIRST parameter is a numpy array\n    forked from: https://gist.github.com/Susensio/61f4fee01150caaac1e10fc5f005eb75
\n", "signature": "(*args, **kwargs):", "funcdef": "def"}, "geneticalgorithm2.utils.files": {"fullname": "geneticalgorithm2.utils.files", "modulename": "geneticalgorithm2.utils.files", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.utils.files.mkdir_of_file": {"fullname": "geneticalgorithm2.utils.files.mkdir_of_file", "modulename": "geneticalgorithm2.utils.files", "qualname": "mkdir_of_file", "kind": "function", "doc": "
\u0434\u043b\u044f \u044d\u0442\u043e\u0433\u043e \u0444\u0430\u0439\u043b\u0430 \u0441\u043e\u0437\u0434\u0430\u0451\u0442 \u043f\u0430\u043f\u043a\u0443, \u0432 \u043a\u043e\u0442\u043e\u0440\u043e\u0439 \u043e\u043d \u0434\u043e\u043b\u0436\u0435\u043d \u043b\u0435\u0436\u0430\u0442\u044c
\n", "signature": "(file_path: Union[str, os.PathLike]):", "funcdef": "def"}, "geneticalgorithm2.utils.files.mkdir": {"fullname": "geneticalgorithm2.utils.files.mkdir", "modulename": "geneticalgorithm2.utils.files", "qualname": "mkdir", "kind": "function", "doc": "
mkdir with parents
\n", "signature": "(path: Union[str, os.PathLike]):", "funcdef": "def"}, "geneticalgorithm2.utils.files.touch": {"fullname": "geneticalgorithm2.utils.files.touch", "modulename": "geneticalgorithm2.utils.files", "qualname": "touch", "kind": "function", "doc": "
makes empty file, makes directories for this file automatically
\n", "signature": "(path: Union[str, os.PathLike]):", "funcdef": "def"}, "geneticalgorithm2.utils.funcs": {"fullname": "geneticalgorithm2.utils.funcs", "modulename": "geneticalgorithm2.utils.funcs", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.utils.funcs.fast_min": {"fullname": "geneticalgorithm2.utils.funcs.fast_min", "modulename": "geneticalgorithm2.utils.funcs", "qualname": "fast_min", "kind": "function", "doc": "
1.5 times faster than row min(a, b)
\n", "signature": "(a, b):", "funcdef": "def"}, "geneticalgorithm2.utils.funcs.fast_max": {"fullname": "geneticalgorithm2.utils.funcs.fast_max", "modulename": "geneticalgorithm2.utils.funcs", "qualname": "fast_max", "kind": "function", "doc": "
\n", "signature": "(a, b):", "funcdef": "def"}, "geneticalgorithm2.utils.funcs.can_be_prob": {"fullname": "geneticalgorithm2.utils.funcs.can_be_prob", "modulename": "geneticalgorithm2.utils.funcs", "qualname": "can_be_prob", "kind": "function", "doc": "
\n", "signature": "(value: float) -> bool:", "funcdef": "def"}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"fullname": "geneticalgorithm2.utils.funcs.is_current_gen_number", "modulename": "geneticalgorithm2.utils.funcs", "qualname": "is_current_gen_number", "kind": "function", "doc": "
\n", "signature": "(number: Union[int, NoneType]):", "funcdef": "def"}, "geneticalgorithm2.utils.funcs.is_numpy": {"fullname": "geneticalgorithm2.utils.funcs.is_numpy", "modulename": "geneticalgorithm2.utils.funcs", "qualname": "is_numpy", "kind": "function", "doc": "
\n", "signature": "(arg: Any):", "funcdef": "def"}, "geneticalgorithm2.utils.funcs.split_matrix": {"fullname": "geneticalgorithm2.utils.funcs.split_matrix", "modulename": "geneticalgorithm2.utils.funcs", "qualname": "split_matrix", "kind": "function", "doc": "
splits wide pop matrix to variables and scores
\n", "signature": "(mat: numpy.ndarray) -> Tuple[numpy.ndarray, numpy.ndarray]:", "funcdef": "def"}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"fullname": "geneticalgorithm2.utils.funcs.union_to_matrix", "modulename": "geneticalgorithm2.utils.funcs", "qualname": "union_to_matrix", "kind": "function", "doc": "
union variables and scores to wide pop matrix
\n", "signature": "(variables_2D: numpy.ndarray, scores_1D: numpy.ndarray) -> numpy.ndarray:", "funcdef": "def"}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"fullname": "geneticalgorithm2.utils.funcs.random_indexes_pair", "modulename": "geneticalgorithm2.utils.funcs", "qualname": "random_indexes_pair", "kind": "function", "doc": "
works 3 times faster than random.sample(range(seq_len), 2)
\n", "signature": "(seq_len: int) -> Tuple[int, int]:", "funcdef": "def"}, "geneticalgorithm2.utils.plotting": {"fullname": "geneticalgorithm2.utils.plotting", "modulename": "geneticalgorithm2.utils.plotting", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"fullname": "geneticalgorithm2.utils.plotting.plot_several_lines", "modulename": "geneticalgorithm2.utils.plotting", "qualname": "plot_several_lines", "kind": "function", "doc": "
\n", "signature": "(\tlines: Sequence[Sequence[float]],\tcolors: Sequence[str],\tlabels: Union[Sequence[str], NoneType] = None,\tlinewidths: Union[Sequence[int], NoneType] = None,\ttitle: str = '',\txlabel: str = 'Generation',\tylabel: str = 'Minimized function',\tsave_as: Union[str, os.PathLike, NoneType] = None,\tdpi: int = 200):", "funcdef": "def"}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"fullname": "geneticalgorithm2.utils.plotting.plot_pop_scores", "modulename": "geneticalgorithm2.utils.plotting", "qualname": "plot_pop_scores", "kind": "function", "doc": "
plots scores (numeric values) as sorted bars
\n", "signature": "(\tscores: Sequence[float],\ttitle: str = 'Population scores',\tsave_as: Union[str, NoneType] = None):", "funcdef": "def"}}, "docInfo": {"geneticalgorithm2": {"qualname": 0, "fullname": 1, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 45}, "geneticalgorithm2.geneticalgorithm2": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.Population_initializer": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 210, "bases": 0, "doc": 117}, "geneticalgorithm2.callbacks": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 5, "doc": 8}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 363, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"qualname": 4, "fullname": 7, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"qualname": 3, "fullname": 6, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"qualname": 4, "fullname": 7, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"qualname": 3, "fullname": 6, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"qualname": 2, "fullname": 5, "annotation": 9, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"qualname": 2, "fullname": 5, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"qualname": 3, "fullname": 6, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"qualname": 1, "fullname": 4, "annotation": 4, "default_value": 9, "signature": 0, "bases": 0, "doc": 29}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"qualname": 1, "fullname": 4, "annotation": 4, "default_value": 6, "signature": 0, "bases": 0, "doc": 17}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"qualname": 1, "fullname": 4, "annotation": 4, "default_value": 9, "signature": 0, "bases": 0, "doc": 16}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"qualname": 1, "fullname": 4, "annotation": 4, "default_value": 11, "signature": 0, "bases": 0, "doc": 48}, "geneticalgorithm2.callbacks.middle": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.middle.Actions": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 10}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 77, "bases": 0, "doc": 4}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 71, "bases": 0, "doc": 8}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 115, "bases": 0, "doc": 5}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 95, "bases": 0, "doc": 6}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 123, "bases": 0, "doc": 6}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 192, "bases": 0, "doc": 87}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 69, "bases": 0, "doc": 15}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 173, "bases": 0, "doc": 16}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 10}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 55, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 37, "bases": 0, "doc": 6}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 55, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 78, "bases": 0, "doc": 10}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 78, "bases": 0, "doc": 11}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 8}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 173, "bases": 0, "doc": 53}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 141, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 82, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.simple": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.simple.Callbacks": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 9}, "geneticalgorithm2.callbacks.simple.Callbacks.NoneCallback": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 7, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 124, "bases": 0, "doc": 7}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 165, "bases": 0, "doc": 53}, "geneticalgorithm2.crossovers": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.CrossoverFunc": {"qualname": 1, "fullname": 3, "annotation": 4, "default_value": 10, "signature": 0, "bases": 0, "doc": 9}, "geneticalgorithm2.crossovers.get_copies": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 63, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 6}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 68, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.one_point": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.two_point": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.uniform": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.segment": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 76, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 75, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.mixed": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 76, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.algorithm_params": {"qualname": 0, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 5, "doc": 6}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 471, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"qualname": 4, "fullname": 9, "annotation": 3, "default_value": 1, "signature": 0, "bases": 0, "doc": 70}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"qualname": 5, "fullname": 10, "annotation": 3, "default_value": 1, "signature": 0, "bases": 0, "doc": 46}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 11}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 2, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"qualname": 4, "fullname": 9, "annotation": 3, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"qualname": 3, "fullname": 8, "annotation": 3, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 2, "signature": 0, "bases": 0, "doc": 58}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 2, "signature": 0, "bases": 0, "doc": 17}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"qualname": 3, "fullname": 8, "annotation": 10, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"qualname": 3, "fullname": 8, "annotation": 6, "default_value": 7, "signature": 0, "bases": 0, "doc": 7}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"qualname": 4, "fullname": 9, "annotation": 6, "default_value": 6, "signature": 0, "bases": 0, "doc": 7}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"qualname": 3, "fullname": 8, "annotation": 7, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"qualname": 4, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 155, "bases": 0, "doc": 18}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 33, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 28, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.aliases": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"qualname": 1, "fullname": 5, "annotation": 4, "default_value": 4, "signature": 0, "bases": 0, "doc": 9}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"qualname": 1, "fullname": 5, "annotation": 4, "default_value": 5, "signature": 0, "bases": 0, "doc": 65}, "geneticalgorithm2.data_types.base": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.base.DictLikeGetSet": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.generation": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"qualname": 1, "fullname": 5, "annotation": 4, "default_value": 29, "signature": 0, "bases": 0, "doc": 37}, "geneticalgorithm2.data_types.generation.Generation": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 5, "doc": 15}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 74, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.generation.Generation.variables": {"qualname": 2, "fullname": 6, "annotation": 4, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.generation.Generation.scores": {"qualname": 2, "fullname": 6, "annotation": 4, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.generation.Generation.size": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"qualname": 3, "fullname": 7, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 19, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.generation.Generation.save": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.generation.Generation.load": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 33, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 152, "bases": 0, "doc": 4}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 21, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.result": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.result.GAResult": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 5, "doc": 3}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 31, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"qualname": 3, "fullname": 7, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.result.GAResult.variable": {"qualname": 2, "fullname": 6, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.result.GAResult.score": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.result.GAResult.function": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"qualname": 2, "fullname": 4, "annotation": 4, "default_value": 12, "signature": 0, "bases": 0, "doc": 32}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 6}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 483, "bases": 0, "doc": 276}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 57, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 10}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.output_dict": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"qualname": 3, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 7}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.revolution_oppositor": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dup_oppositor": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.creator": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.init_oppositors": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"qualname": 2, "fullname": 4, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.funtimeout": {"qualname": 2, "fullname": 4, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"qualname": 3, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"qualname": 3, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"qualname": 3, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size": {"qualname": 3, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.progress_stream": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.param": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dim": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"qualname": 3, "fullname": 5, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 22}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 1142, "bases": 0, "doc": 517}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 107, "bases": 0, "doc": 11}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 67, "bases": 0, "doc": 9}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 4}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 56, "bases": 0, "doc": 6}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 35, "bases": 0, "doc": 18}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 35, "bases": 0, "doc": 24}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 56, "bases": 0, "doc": 20}, "geneticalgorithm2.mutations": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.mutations.MutationFloatFunc": {"qualname": 1, "fullname": 3, "annotation": 4, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.mutations.MutationIntFunc": {"qualname": 1, "fullname": 3, "annotation": 4, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.mutations.MutationFunc": {"qualname": 1, "fullname": 3, "annotation": 4, "default_value": 11, "signature": 0, "bases": 0, "doc": 21}, "geneticalgorithm2.mutations.Mutations": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 6}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 44, "bases": 0, "doc": 3}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 44, "bases": 0, "doc": 3}, "geneticalgorithm2.mutations.Mutations.uniform_by_x": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 34, "bases": 0, "doc": 3}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 34, "bases": 0, "doc": 3}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 51, "bases": 0, "doc": 14}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 51, "bases": 0, "doc": 15}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 34, "bases": 0, "doc": 3}, "geneticalgorithm2.population_initializer": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.population_initializer.PopulationModifier": {"qualname": 1, "fullname": 4, "annotation": 4, "default_value": 10, "signature": 0, "bases": 0, "doc": 25}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"qualname": 4, "fullname": 7, "annotation": 4, "default_value": 14, "signature": 0, "bases": 0, "doc": 49}, "geneticalgorithm2.population_initializer.get_population_initializer": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 210, "bases": 0, "doc": 117}, "geneticalgorithm2.selections": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.SelectionFunc": {"qualname": 1, "fullname": 3, "annotation": 4, "default_value": 6, "signature": 0, "bases": 0, "doc": 11}, "geneticalgorithm2.selections.inverse_scores": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 10}, "geneticalgorithm2.selections.roulette": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 40, "bases": 0, "doc": 13}, "geneticalgorithm2.selections.Selection": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 6}, "geneticalgorithm2.selections.Selection.selections_dict": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 48, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.fully_random": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 13}, "geneticalgorithm2.selections.Selection.roulette": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.stochastic": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 75, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.ranking": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.linear_ranking": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 57, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.tournament": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 54, "bases": 0, "doc": 3}, "geneticalgorithm2.utils": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.aliases": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.aliases.Number": {"qualname": 1, "fullname": 4, "annotation": 4, "default_value": 3, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.aliases.array1D": {"qualname": 1, "fullname": 4, "annotation": 4, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.aliases.array2D": {"qualname": 1, "fullname": 4, "annotation": 4, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.aliases.PathLike": {"qualname": 1, "fullname": 4, "annotation": 4, "default_value": 4, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.cache": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.cache.np_lru_cache": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 21}, "geneticalgorithm2.utils.files": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.files.mkdir_of_file": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 34, "bases": 0, "doc": 12}, "geneticalgorithm2.utils.files.mkdir": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 33, "bases": 0, "doc": 5}, "geneticalgorithm2.utils.files.touch": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 33, "bases": 0, "doc": 11}, "geneticalgorithm2.utils.funcs": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.funcs.fast_min": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 12}, "geneticalgorithm2.utils.funcs.fast_max": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.funcs.can_be_prob": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 19, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 28, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.funcs.is_numpy": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.funcs.split_matrix": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 10}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 10}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 32, "bases": 0, "doc": 16}, "geneticalgorithm2.utils.plotting": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 238, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 77, "bases": 0, "doc": 9}}, "length": 194, "save": true}, "index": {"qualname": {"root": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 5, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"2": {"docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.output_dict": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.revolution_oppositor": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dup_oppositor": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.creator": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.init_oppositors": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.funtimeout": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.progress_stream": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.param": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dim": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 31}, "docs": {}, "df": 0}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}}, "df": 15, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "t": {"docs": {"geneticalgorithm2.crossovers.get_copies": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 4}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.result.GAResult": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.score": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.function": {"tf": 1}}, "df": 6}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 2}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 2, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 4, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete": {"tf": 1}, "geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}}, "df": 5, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}}, "df": 3}}}}}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.progress_stream": {"tf": 1}}, "df": 2}}}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.param": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 4, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.init_oppositors": {"tf": 1}}, "df": 6, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}}}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.selections.inverse_scores": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 2}}}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {"geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_numpy": {"tf": 1}}, "df": 2}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}}, "df": 1, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}}, "df": 17}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}}, "df": 1}}}}}}}}}}, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}}, "df": 4}}}}}}}}}}}}}, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}}, "df": 1}}}, "n": {"docs": {"geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}}, "df": 4, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}}, "df": 9, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1}}, "df": 1}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.mutations.MutationFunc": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {"geneticalgorithm2.mutations.Mutations": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"tf": 1}}, "df": 8}}}}}}}, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 1}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "x": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_max": {"tf": 1}}, "df": 4}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {"geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 4}}}}}, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}}, "df": 2}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}}, "df": 1}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "v": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.revolution_oppositor": {"tf": 1}}, "df": 1}}}}}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 2}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 2}}}, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.selections.Selection.ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}}, "df": 2}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.selections.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 1}}, "df": 2}}}}}}}}, "t": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 2, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.selections.Selection.tournament": {"tf": 1}}, "df": 1}}}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {"geneticalgorithm2.utils.files.touch": {"tf": 1}}, "df": 1}}}}, "w": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 1}}, "df": 1}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}}, "df": 5}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}}, "df": 2}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.selections.Selection.stochastic": {"tf": 1}}, "df": 1}}}}}}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1}}, "df": 2}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.progress_stream": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.selections.Selection": {"tf": 1}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection.stochastic": {"tf": 1}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}, "geneticalgorithm2.selections.Selection.ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.tournament": {"tf": 1}}, "df": 11, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.selections.SelectionFunc": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {"geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 5, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "g": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}}, "df": 1}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "z": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size": {"tf": 1}}, "df": 4}}, "g": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}}, "df": 1, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "h": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 1}}, "df": 1}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.result.GAResult.score": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 4}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}}, "df": 1}}, "s": {"docs": {"geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "u": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}}, "df": 3}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}}, "df": 13, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {"geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.creator": {"tf": 1}}, "df": 1}}}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}}, "df": 1}}}}}}}}}, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.crossovers.get_copies": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.NoneCallback": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 4}}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}}, "n": {"docs": {"geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}}, "df": 1}}, "m": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 2}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"tf": 1}}, "df": 7}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.output_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 1}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1}}, "df": 6, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.base.DictLikeGetSet": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 1}}, "df": 2}}}}}}}}}}}}, "m": {"docs": {"geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dim": {"tf": 1}}, "df": 2}}, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}}, "df": 2}}}}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dup_oppositor": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 2}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}}, "df": 1}}}}}}}, "f": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1}}, "df": 1, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 6, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}}, "df": 1}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.funtimeout": {"tf": 1}}, "df": 1}}}}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}}, "df": 3}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 1}, "e": {"docs": {"geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_max": {"tf": 1}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}}, "df": 9}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}}, "df": 6}}}}}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}}, "df": 1}, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}}, "df": 18}}}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"1": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.utils.aliases.array1D": {"tf": 1}}, "df": 1}}, "2": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.utils.aliases.array2D": {"tf": 1}}, "df": 1}}, "docs": {}, "df": 0}}}}, "s": {"docs": {"geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"tf": 1}}, "df": 5}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.NoneCallback": {"tf": 1}}, "df": 1}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 1, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.utils.aliases.Number": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}}, "df": 2}}}, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.utils.funcs.is_numpy": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 1}}, "df": 1}}, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.output_dict": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.revolution_oppositor": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dup_oppositor": {"tf": 1}}, "df": 2, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.init_oppositors": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}}}}}}}}}, "f": {"docs": {"geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}}, "df": 1}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}}, "df": 2, "s": {"docs": {"geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}}, "df": 1}}}}}}}}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"tf": 1}}, "df": 1}}}}}, "y": {"docs": {"geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 4}, "e": {"docs": {"geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}}, "df": 1}}, "x": {"docs": {"geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}}, "df": 2}}}, "fullname": {"root": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 5, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"2": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2": {"tf": 1.4142135623730951}, "geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks": {"tf": 1}, "geneticalgorithm2.callbacks.data": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}, "geneticalgorithm2.callbacks.simple": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.NoneCallback": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.crossovers": {"tf": 1}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}, "geneticalgorithm2.crossovers.get_copies": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}, "geneticalgorithm2.data_types": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}, "geneticalgorithm2.data_types.aliases": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.base": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 1}, "geneticalgorithm2.data_types.generation": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}, "geneticalgorithm2.data_types.result": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.score": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.output_dict": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.revolution_oppositor": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dup_oppositor": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.creator": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.init_oppositors": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.funtimeout": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.progress_stream": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.param": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dim": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations": {"tf": 1}, "geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}, "geneticalgorithm2.mutations.Mutations": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"tf": 1}, "geneticalgorithm2.population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}, "geneticalgorithm2.selections": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1}, "geneticalgorithm2.selections.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection": {"tf": 1}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection.stochastic": {"tf": 1}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}, "geneticalgorithm2.selections.Selection.ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.tournament": {"tf": 1}, "geneticalgorithm2.utils": {"tf": 1}, "geneticalgorithm2.utils.aliases": {"tf": 1}, "geneticalgorithm2.utils.aliases.Number": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}, "geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}, "geneticalgorithm2.utils.cache": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}, "geneticalgorithm2.utils.files": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1}, "geneticalgorithm2.utils.funcs": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_max": {"tf": 1}, "geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_numpy": {"tf": 1}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}, "geneticalgorithm2.utils.plotting": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 194}, "docs": {}, "df": 0}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1}, "geneticalgorithm2.data_types.generation": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.size": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}}, "df": 17, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "t": {"docs": {"geneticalgorithm2.crossovers.get_copies": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 4}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.result.GAResult": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.score": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.function": {"tf": 1}}, "df": 6}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 2}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 2, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size": {"tf": 1}, "geneticalgorithm2.population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 7, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete": {"tf": 1}, "geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}}, "df": 5, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}}, "df": 3}}}}}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.progress_stream": {"tf": 1}}, "df": 2}}}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.param": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 20}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 4, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.utils.plotting": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 3}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.init_oppositors": {"tf": 1}}, "df": 6, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 5}}}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.selections.inverse_scores": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 2}}}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {"geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_numpy": {"tf": 1}}, "df": 2}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks": {"tf": 1}, "geneticalgorithm2.callbacks.data": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}, "geneticalgorithm2.callbacks.simple": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.NoneCallback": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1.4142135623730951}}, "df": 48}}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.utils.cache": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1.4142135623730951}}, "df": 2}}}, "n": {"docs": {"geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}}, "df": 3}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}}, "df": 13, "s": {"docs": {"geneticalgorithm2.crossovers": {"tf": 1}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}, "geneticalgorithm2.crossovers.get_copies": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1.4142135623730951}, "geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}}, "df": 13}, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}}, "df": 1}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.creator": {"tf": 1}}, "df": 1}}}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}}, "df": 1}}}}}}}}}, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.crossovers.get_copies": {"tf": 1}}, "df": 1}}}}}, "m": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 2}}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.callbacks.data": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.data_types": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}, "geneticalgorithm2.data_types.aliases": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.base": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 1}, "geneticalgorithm2.data_types.generation": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}, "geneticalgorithm2.data_types.result": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.score": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.function": {"tf": 1}}, "df": 68}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"tf": 1}}, "df": 7}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.output_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 1}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1}}, "df": 6, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.base.DictLikeGetSet": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 1}}, "df": 2}}}}}}}}}}}}, "m": {"docs": {"geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dim": {"tf": 1}}, "df": 2}}, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}}, "df": 2}}}}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dup_oppositor": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}}, "df": 21, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}}, "df": 17}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}}, "df": 1}}}}}}}}}}, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}}, "df": 4}}}}}}}}}}}}}, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}}, "df": 1}}}, "n": {"docs": {"geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}}, "df": 4, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}}, "df": 9, "s": {"docs": {"geneticalgorithm2.mutations": {"tf": 1}, "geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}, "geneticalgorithm2.mutations.Mutations": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"tf": 1.4142135623730951}}, "df": 12}, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1}}, "df": 1}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.mutations.MutationFunc": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 1}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "x": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_max": {"tf": 1}}, "df": 4}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {"geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 4}}}}}, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}}, "df": 2}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}}, "df": 1}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.result": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.score": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.function": {"tf": 1}}, "df": 7, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}}, "df": 1}}}}}, "v": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.revolution_oppositor": {"tf": 1}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 2}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 2}}}, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.selections.Selection.ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}}, "df": 2}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.selections.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 1}}, "df": 2}}}}}}}}, "t": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 2, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.selections.Selection.tournament": {"tf": 1}}, "df": 1}}}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {"geneticalgorithm2.utils.files.touch": {"tf": 1}}, "df": 1}}}}, "w": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 1}}, "df": 1}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}}, "df": 5, "s": {"docs": {"geneticalgorithm2.data_types": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}, "geneticalgorithm2.data_types.aliases": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.base": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 1}, "geneticalgorithm2.data_types.generation": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}, "geneticalgorithm2.data_types.result": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.score": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.function": {"tf": 1}}, "df": 46}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}}, "df": 2}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.selections.Selection.stochastic": {"tf": 1}}, "df": 1}}}}}}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1}}, "df": 2}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.progress_stream": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.selections.Selection": {"tf": 1}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection.stochastic": {"tf": 1}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}, "geneticalgorithm2.selections.Selection.ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.tournament": {"tf": 1}}, "df": 11, "s": {"docs": {"geneticalgorithm2.selections": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1}, "geneticalgorithm2.selections.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection": {"tf": 1}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection.stochastic": {"tf": 1}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}, "geneticalgorithm2.selections.Selection.ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.tournament": {"tf": 1}}, "df": 13}, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.selections.SelectionFunc": {"tf": 1}}, "df": 1}}}}}}}}}}}, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 5, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "g": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}}, "df": 1}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.simple": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.NoneCallback": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 5, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "z": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size": {"tf": 1}}, "df": 4}}, "g": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}}, "df": 1, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "h": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 1}}, "df": 1}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.result.GAResult.score": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 4}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}}, "df": 1}}, "s": {"docs": {"geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "u": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 2}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}}, "df": 1}}}}}}}, "f": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1}}, "df": 1, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 6, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.utils.funcs": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_max": {"tf": 1}, "geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_numpy": {"tf": 1}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 10}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.funtimeout": {"tf": 1}}, "df": 1}}}}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}}, "df": 3}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 1}, "e": {"docs": {"geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.utils.files": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1}}, "df": 4}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_max": {"tf": 1}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}}, "df": 9}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}}, "df": 6}}}}}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}}, "df": 1}, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.data_types.algorithm_params": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}}, "df": 19, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}}, "df": 18}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.aliases": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.utils.aliases": {"tf": 1}, "geneticalgorithm2.utils.aliases.Number": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}, "geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}}, "df": 8}}}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"1": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.utils.aliases.array1D": {"tf": 1}}, "df": 1}}, "2": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.utils.aliases.array2D": {"tf": 1}}, "df": 1}}, "docs": {}, "df": 0}}}}, "s": {"docs": {"geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"tf": 1}}, "df": 5}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.utils": {"tf": 1}, "geneticalgorithm2.utils.aliases": {"tf": 1}, "geneticalgorithm2.utils.aliases.Number": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}, "geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}, "geneticalgorithm2.utils.cache": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}, "geneticalgorithm2.utils.files": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1}, "geneticalgorithm2.utils.funcs": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_max": {"tf": 1}, "geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_numpy": {"tf": 1}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}, "geneticalgorithm2.utils.plotting": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 24}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.NoneCallback": {"tf": 1}}, "df": 1}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 1, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.utils.aliases.Number": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}}, "df": 2}}}, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.utils.funcs.is_numpy": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 1}}, "df": 1}}, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.output_dict": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.revolution_oppositor": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dup_oppositor": {"tf": 1}}, "df": 2, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.init_oppositors": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}}}}}}}}}, "f": {"docs": {"geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}}, "df": 1}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}}, "df": 2, "s": {"docs": {"geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}}, "df": 1}}}}}}}}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.base": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 1}}, "df": 3}}, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"tf": 1}}, "df": 1}}}}}, "y": {"docs": {"geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 4}, "e": {"docs": {"geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}}, "df": 1}}, "x": {"docs": {"geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}}, "df": 2}}}, "annotation": {"root": {"docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.score": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.funtimeout": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}, "geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.utils.aliases.Number": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}, "geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}}, "df": 62, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.utils.aliases.Number": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}, "geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}}, "df": 20}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.utils.aliases.Number": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}, "geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}}, "df": 20}}}}}, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}}, "df": 2}}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}}, "df": 2}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.utils.aliases.Number": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}, "geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}}, "df": 20}}}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}}, "df": 5}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"tf": 1}}, "df": 3}}}, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}}, "df": 2}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1}}, "df": 2}}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1.4142135623730951}}, "df": 9}}}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 2}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 2}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 12}}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1}}, "df": 7}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"2": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}}, "df": 2}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 12}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.result.GAResult.score": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.funtimeout": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"tf": 1.4142135623730951}}, "df": 13}}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}}, "df": 2}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}}, "df": 8}}}}}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}}, "df": 1}}}}}}, "default_value": {"root": {"0": {"4": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 2}, "docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1.7320508075688772}}, "df": 4}, "1": {"0": {"0": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 2}, "2": {"0": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "3": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 2}, "docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1.4142135623730951}}, "df": 11, "l": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}}, "df": 3}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 3}}}}}}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}}, "df": 3}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}}, "df": 3}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"2": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}}, "df": 3}, "docs": {}, "df": 0}}}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}}, "df": 5}}}}}, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}}, "df": 2}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.4142135623730951}}, "df": 3}}}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 2}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}, "x": {"2": {"7": {"docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 2.449489742783178}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 2.449489742783178}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 2.8284271247461903}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 2.449489742783178}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1.4142135623730951}}, "df": 11}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"2": {"docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1}}}}}}}}}, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}}, "df": 3}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.utils.aliases.Number": {"tf": 1}, "geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}}, "df": 17}}}, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 2}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"2": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}}}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}}, "df": 2}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}}, "df": 8}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 2}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 2}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 2}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}}, "df": 9}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 2}}, "df": 7, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.4142135623730951}}, "df": 3}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1.7320508075688772}}, "df": 2}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.4142135623730951}}, "df": 3}}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "x": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1.4142135623730951}}, "df": 1}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 2}}, "df": 1}}}}}}}}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}}, "df": 3}}}, "y": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 2}, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1.7320508075688772}}, "df": 4}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1}}}}}}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.mutations.MutationFunc": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.utils.aliases.Number": {"tf": 1}}, "df": 1}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 2}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1}}}}}, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.aliases.Number": {"tf": 1}}, "df": 4}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1.4142135623730951}}, "df": 1, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1}}}}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 2}}}}}}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1.7320508075688772}}, "df": 1}}}}}}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}}, "df": 1}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1.7320508075688772}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}}, "df": 4}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1}}}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}}, "df": 1}}}}, "signature": {"root": {"0": {"0": {"5": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "1": {"docs": {"geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}}, "df": 1}, "4": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}, "docs": {"geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1.4142135623730951}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}}, "df": 10}, "1": {"0": {"0": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}, "docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}}, "df": 2}, "docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}}, "df": 5, "d": {"docs": {"geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 1}}, "2": {"0": {"0": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "docs": {"geneticalgorithm2.selections.Selection.tournament": {"tf": 1}}, "df": 1, "d": {"docs": {"geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 1}}, "3": {"9": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 2.8284271247461903}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 2}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2.8284271247461903}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 4.69041575982343}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.449489742783178}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 2.8284271247461903}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 2.449489742783178}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1.4142135623730951}}, "df": 13}, "docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 5}, "4": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}, "5": {"0": {"0": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}}, "df": 1}, "docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 4}, "docs": {"geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}}, "df": 2}, "6": {"docs": {"geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}}, "df": 1}, "7": {"docs": {"geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}}, "df": 1}, "9": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}}, "df": 2}, "docs": {"geneticalgorithm2.Population_initializer": {"tf": 12.727922061357855}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 16.911534525287763}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 7.681145747868608}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 7.54983443527075}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 9.643650760992955}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 8.774964387392123}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 10}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 12.569805089976535}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 7.483314773547883}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 11.661903789690601}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 6.708203932499369}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 5.5677643628300215}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 6.708203932499369}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 8}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 8}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 11.789826122551595}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 10.488088481701515}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 8.06225774829855}, "geneticalgorithm2.callbacks.simple.Callbacks.NoneCallback": {"tf": 2.6457513110645907}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 9.9498743710662}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 11.445523142259598}, "geneticalgorithm2.crossovers.get_copies": {"tf": 7.211102550927978}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 7.483314773547883}, "geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 6.928203230275509}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 6.928203230275509}, "geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 6.928203230275509}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 7.874007874011811}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 6.928203230275509}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 7.874007874011811}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 6.928203230275509}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 7.874007874011811}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 19.131126469708992}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 3.4641016151377544}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 11.269427669584644}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 5.291502622129181}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 4.898979485566356}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 3.7416573867739413}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 7.874007874011811}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 4}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 5.656854249492381}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 5.291502622129181}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 11}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 4.242640687119285}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 4.898979485566356}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 18.920887928424502}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 30.066592756745816}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 9.219544457292887}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 7.280109889280518}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 4.69041575982343}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 6.782329983125268}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 5.291502622129181}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 5.291502622129181}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 6.708203932499369}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"tf": 6.082762530298219}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 6.082762530298219}, "geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 5.385164807134504}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 5.385164807134504}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 6.48074069840786}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 6.48074069840786}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"tf": 5.385164807134504}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 12.727922061357855}, "geneticalgorithm2.selections.inverse_scores": {"tf": 4.898979485566356}, "geneticalgorithm2.selections.roulette": {"tf": 5.656854249492381}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 6.324555320336759}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 5.656854249492381}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 5.656854249492381}, "geneticalgorithm2.selections.Selection.stochastic": {"tf": 5.656854249492381}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 7.810249675906654}, "geneticalgorithm2.selections.Selection.ranking": {"tf": 5.656854249492381}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 6.782329983125268}, "geneticalgorithm2.selections.Selection.tournament": {"tf": 6.708203932499369}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 4.242640687119285}, "geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 5.291502622129181}, "geneticalgorithm2.utils.files.mkdir": {"tf": 5.291502622129181}, "geneticalgorithm2.utils.files.touch": {"tf": 5.291502622129181}, "geneticalgorithm2.utils.funcs.fast_min": {"tf": 3.7416573867739413}, "geneticalgorithm2.utils.funcs.fast_max": {"tf": 3.7416573867739413}, "geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 4}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 4.898979485566356}, "geneticalgorithm2.utils.funcs.is_numpy": {"tf": 3.7416573867739413}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 6.164414002968976}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 6}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 5.0990195135927845}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 13.892443989449804}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 7.874007874011811}}, "df": 85, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.7320508075688772}}, "df": 2, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}}, "df": 4, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}}, "df": 1}}}}}}}, "f": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}}, "df": 11}}, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 6}, "q": {"docs": {"geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 1, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 2.23606797749979}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 10}}}}}}, "c": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 7}}, "o": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1.7320508075688772}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 1}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 2.449489742783178}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1.4142135623730951}}, "df": 24, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3}}}}}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 8}}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1}, "geneticalgorithm2.selections.roulette": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1.4142135623730951}}, "df": 8}}}}}, "d": {"docs": {"geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 2}}, "b": {"docs": {"geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_max": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}}}}}, "y": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 4}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.449489742783178}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}, "geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}}, "df": 13}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1}}, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "f": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 8}, "b": {"docs": {}, "df": 0, "j": {"docs": {"geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 2.8284271247461903}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 2}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1.4142135623730951}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2.8284271247461903}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 2.23606797749979}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.449489742783178}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 2}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"tf": 2}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection.stochastic": {"tf": 1}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}, "geneticalgorithm2.selections.Selection.ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.tournament": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1.4142135623730951}}, "df": 35}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 2}}}}, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}, "m": {"docs": {"geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}}}}}, "s": {"docs": {"geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 2, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 5}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 4}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 1}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}}, "df": 4}}, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}}, "df": 1}}}}, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2}, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 1}}}, "a": {"docs": {"geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_max": {"tf": 1}}, "df": 2, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 4}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}}, "df": 3}}}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 6}, "l": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}}, "df": 1}}}, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}}, "df": 2, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_numpy": {"tf": 1}}, "df": 4}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.utils.funcs.is_numpy": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 2}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 2.449489742783178}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 2.8284271247461903}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 2}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 2.23606797749979}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1.4142135623730951}, "geneticalgorithm2.crossovers.get_copies": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 2}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2.449489742783178}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 2.449489742783178}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 2}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 4.47213595499958}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 2.449489742783178}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.roulette": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.stochastic": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.ranking": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.tournament": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1.7320508075688772}}, "df": 43}}, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 2.449489742783178}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 2.8284271247461903}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 2}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 2.23606797749979}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1.4142135623730951}, "geneticalgorithm2.crossovers.get_copies": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 2}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2.449489742783178}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 2.449489742783178}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 2}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 4.47213595499958}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 2.449489742783178}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.roulette": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.stochastic": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.ranking": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.tournament": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1.7320508075688772}}, "df": 43}}}}}}, "o": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "n": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2.8284271247461903}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 4.242640687119285}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 13, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 4.242640687119285}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 17}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}}, "df": 2}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2.8284271247461903}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 4.242640687119285}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 23}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}}, "df": 2}}}}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 2.23606797749979}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 2}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection.stochastic": {"tf": 1}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}, "geneticalgorithm2.selections.Selection.ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.tournament": {"tf": 1}}, "df": 52}}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}}, "df": 2, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 2}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 2.23606797749979}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}}, "df": 17}}}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 3, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}}}}, "o": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}}, "df": 2}}, "n": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}}, "df": 1}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}}, "df": 2}}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}}, "df": 2, "s": {"docs": {"geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}}}}}}, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 3}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 2}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.449489742783178}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"tf": 2}, "geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 2}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 2}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 2.23606797749979}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 2.23606797749979}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}, "geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 26}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.23606797749979}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 8}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 4}, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}}, "df": 3}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.23606797749979}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}}, "df": 3}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}, "geneticalgorithm2.crossovers.get_copies": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 24}}}}, "o": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2.449489742783178}}, "df": 2, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 5}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 5}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "u": {"docs": {"geneticalgorithm2.selections.Selection.tournament": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}}, "df": 2}}}, "l": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 1}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 2}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1.4142135623730951}}, "df": 2}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 3}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}}}}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 2}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.449489742783178}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 8, "s": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}}, "df": 2}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"2": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 2}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 2.23606797749979}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}}, "df": 21}, "docs": {}, "df": 0}}}}}}}}}}}}}}, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "t": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 2}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 2.449489742783178}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}}, "df": 21}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}}, "df": 3}}}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 1}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1}}, "df": 9}}, "m": {"docs": {"geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}}, "df": 2}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}, "p": {"docs": {}, "df": 0, "i": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 2}}}, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 2}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 5, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}}, "df": 1}}}}}}}}, "a": {"docs": {}, "df": 0, "x": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 3}, "i": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}}, "df": 2}}, "t": {"docs": {"geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 2}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 2.23606797749979}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 17}}}}}}}}}}}}}}}}, "n": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 1}}}}}}}, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}, "p": {"1": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}}, "df": 1}, "2": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}}, "df": 2, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}}, "df": 2}}}}}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 2}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 5}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1.4142135623730951}}, "df": 1}}}}, "h": {"docs": {"geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1}}, "df": 5, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 8}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 3}}}}}, "p": {"docs": {"geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}}, "df": 1, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 6}}}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 3}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1.4142135623730951}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}}, "df": 1}}}}}}}, "x": {"docs": {"geneticalgorithm2.crossovers.get_copies": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}}, "df": 3, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 1}}}}}}, "y": {"docs": {"geneticalgorithm2.crossovers.get_copies": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 1}}}}}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}}, "df": 1, "s": {"docs": {"geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 3}}}}}}}, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}}, "df": 1}}}}}, "j": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 1}}}}, "k": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}}}}}}}, "bases": {"root": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"2": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult": {"tf": 1}}, "df": 4}, "docs": {}, "df": 0}}}}}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult": {"tf": 1}}, "df": 4}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult": {"tf": 1}}, "df": 4}}}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult": {"tf": 1}}, "df": 4}}}}}}, "doc": {"root": {"0": {"1": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 1}, "docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 4}, "1": {"0": {"0": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 2}, "docs": {}, "df": 0}, "docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}}, "df": 4, "/": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}}}}}}}, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "2": {"0": {"0": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 1}, "docs": {}, "df": 0}, "docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 4, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "3": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 2}, "4": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 3}, "5": {"docs": {"geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}}, "df": 1, "n": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 3}}, "8": {"docs": {"geneticalgorithm2": {"tf": 1}}, "df": 1}, "docs": {"geneticalgorithm2": {"tf": 3.605551275463989}, "geneticalgorithm2.geneticalgorithm2": {"tf": 1.7320508075688772}, "geneticalgorithm2.Population_initializer": {"tf": 5.385164807134504}, "geneticalgorithm2.callbacks": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 2.23606797749979}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 2}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 2}, "geneticalgorithm2.callbacks.middle": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.Actions": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 4.69041575982343}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 4.898979485566356}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.simple": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.NoneCallback": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 5.916079783099616}, "geneticalgorithm2.crossovers": {"tf": 1.7320508075688772}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 2}, "geneticalgorithm2.crossovers.get_copies": {"tf": 1.7320508075688772}, "geneticalgorithm2.crossovers.Crossover": {"tf": 1.4142135623730951}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1.7320508075688772}, "geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 1.7320508075688772}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 1.7320508075688772}, "geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 1.7320508075688772}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1.7320508075688772}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 1.7320508075688772}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1.7320508075688772}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 1.7320508075688772}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 3.1622776601683795}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 2.449489742783178}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 2.8284271247461903}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.aliases": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 3}, "geneticalgorithm2.data_types.base": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.base.DictLikeGetSet": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 3.1622776601683795}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation.size": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.result": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.result.GAResult": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.result.GAResult.score": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.result.GAResult.function": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 7.416198487095663}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.output_dict": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.revolution_oppositor": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dup_oppositor": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.creator": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.init_oppositors": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.funtimeout": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.progress_stream": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.param": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dim": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 11.832159566199232}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 2.449489742783178}, "geneticalgorithm2.mutations.Mutations": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 2.23606797749979}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 5.385164807134504}, "geneticalgorithm2.selections": {"tf": 1.7320508075688772}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1.7320508075688772}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1.7320508075688772}, "geneticalgorithm2.selections.roulette": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1.7320508075688772}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1.7320508075688772}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 1.7320508075688772}, "geneticalgorithm2.selections.Selection.stochastic": {"tf": 1.7320508075688772}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1.7320508075688772}, "geneticalgorithm2.selections.Selection.ranking": {"tf": 1.7320508075688772}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1.7320508075688772}, "geneticalgorithm2.selections.Selection.tournament": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.aliases": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.aliases.Number": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.aliases.PathLike": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.cache": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 2}, "geneticalgorithm2.utils.files": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 3.4641016151377544}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.files.touch": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.funcs": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.funcs.fast_min": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.funcs.fast_max": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.funcs.is_numpy": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 2.23606797749979}, "geneticalgorithm2.utils.plotting": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1.4142135623730951}}, "df": 194, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2": {"tf": 1}}, "df": 3, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"2": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.8284271247461903}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.7320508075688772}}, "df": 8, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}}}}}, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "b": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 2}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}}, "df": 3}}}}, "a": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 3, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 2}}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1}}, "df": 2}}}}, "a": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}}, "df": 8, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 6, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "l": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 6}, "s": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3, "d": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2.6457513110645907}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 21}, "y": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 5}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 7}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 5}}}, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1.4142135623730951}}, "df": 1}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 4, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3}}}}, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}}, "df": 1}}}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.mutations.MutationFunc": {"tf": 1}}, "df": 1}}}}}}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}}, "df": 1}}}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 4}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1}}, "df": 2}}}}}}}}}}}}, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 7}, "k": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}}, "df": 1}}, "b": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 1}}}, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 1}}}}}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 2}}}, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "x": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 6, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "c": {"docs": {}, "df": 0, "h": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}}, "df": 5}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}}}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1}}, "df": 2}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 2}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}}, "df": 5, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2.8284271247461903}}, "df": 3, "s": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 6}}}}}}}, "l": {"docs": {"geneticalgorithm2.selections.inverse_scores": {"tf": 1}}, "df": 1, "u": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1.4142135623730951}}, "df": 7, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 3}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2": {"tf": 1.4142135623730951}, "geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 3.3166247903554}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 3.1622776601683795}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1}}, "df": 23, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}}, "df": 1}}, "s": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1}}, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 9}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 3.7416573867739413}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}}, "df": 26, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations": {"tf": 1}, "geneticalgorithm2.selections.Selection": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 7}}}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.7320508075688772}}, "df": 1}}, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.files.touch": {"tf": 1.4142135623730951}}, "df": 4}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 3}}}}}}, "p": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"3": {"docs": {"geneticalgorithm2": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 4, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 1}}}}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}}, "df": 3}}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}}}, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}}, "df": 1}}}}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 1}}}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"geneticalgorithm2": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3}}, "r": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 3}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"1": {"docs": {"geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}}, "df": 1}, "2": {"docs": {"geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}}, "df": 6}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 5, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}}, "df": 2}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 4, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 2}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 2}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.6457513110645907}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 2}}, "df": 19, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}}, "df": 1}}}}}}}}, "[": {"docs": {}, "df": 0, ":": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 1}}}}}}}}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 3, "s": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 2}}}}}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 2}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}}, "df": 3}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}}, "df": 2, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 4}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 3}}}}}, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}}, "df": 12, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"geneticalgorithm2": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.4142135623730951}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2}, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}}, "df": 3}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}}}, "o": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.selections.inverse_scores": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"2": {"docs": {"geneticalgorithm2": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}}}}}}}}}}}}}}}}}}, "f": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.23606797749979}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 10}, "s": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 2}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 11}, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 5, "s": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 3}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}}, "df": 2, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 2}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}}}, "o": {"docs": {}, "df": 0, "f": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.Population_initializer": {"tf": 2.23606797749979}, "geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 2}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2.8284271247461903}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 3.1622776601683795}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 2.23606797749979}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}}, "df": 24}, "r": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 5, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}}, "df": 1}}}}}}}, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 8, "s": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.7320508075688772}}, "df": 3}, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3}}}}}}}}, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 2}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.7320508075688772}}, "df": 10}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}}, "df": 1}}}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}}, "df": 2, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}}, "df": 1}}}}}}}}}}}, "n": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 5, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}}, "df": 2}}, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 2}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}}, "df": 1, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2, "o": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}}, "df": 1}}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 2}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 2}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}}, "df": 4, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}}, "df": 4}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 4, "s": {"docs": {"geneticalgorithm2.selections.Selection": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.selections.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}}, "df": 2}}}}}, "f": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 6, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 1}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1}}, "df": 1}}}}}, "q": {"docs": {"geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 1, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2}}}}, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 4}}, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}}, "df": 3, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 2}}, "df": 3}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover": {"tf": 1}, "geneticalgorithm2.mutations.Mutations": {"tf": 1}, "geneticalgorithm2.selections.Selection": {"tf": 1}}, "df": 7}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 1}}}}}, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 4}}, "o": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 2}}}, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}, "d": {"docs": {"geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 2, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 4, "s": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 13}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}}, "df": 1}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 2, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 5}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2, "s": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 2}, "d": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1}}}}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}}, "df": 1}}}}}, "y": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "*": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 2}}}}}}}}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}}, "df": 9, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 4}}, "d": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 3}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 6}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 5}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 8}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 2}, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.data_types.generation.Generation": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 2}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}}, "df": 1}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}}, "df": 1}}, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1}}}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}}, "df": 1}, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": null}}, "df": 1}}}}}}}}}, "m": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"2": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}}}}}}}}}}}}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "/": {"6": {"1": {"docs": {}, "df": 0, "f": {"4": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"0": {"1": {"1": {"5": {"0": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"1": {"docs": {}, "df": 0, "e": {"1": {"0": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "c": {"5": {"docs": {}, "df": 0, "f": {"0": {"0": {"5": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "b": {"7": {"5": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}, "docs": {}, "df": 0}}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}, "docs": {}, "df": 0}}}}}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}}}, "docs": {}, "df": 0}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}}}}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}}, "df": 1}}}}}}}}}, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}}, "df": 5}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 2, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 9, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 3}}}}}}, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}}}}}}}}, "n": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 3, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}}, "df": 1}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}}, "df": 1}, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}}, "df": 4}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 3}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"1": {"docs": {"geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}}, "df": 1}, "2": {"docs": {"geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.mutations.Mutations": {"tf": 1}, "geneticalgorithm2.selections.Selection": {"tf": 1}}, "df": 9}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 4}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2}}, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 2}}}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 2}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 9, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "n": {"docs": {"geneticalgorithm2.selections.inverse_scores": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 2, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}, "r": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 3}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 6}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 2}, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1.4142135623730951}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}}, "x": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1}}, "df": 4, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 6}}}, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1}}, "df": 1}}}}}, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 4}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 11, "s": {"docs": {"geneticalgorithm2.mutations.Mutations": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.mutations.MutationFunc": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}}, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.utils.files.mkdir": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2": {"tf": 1}}, "df": 1, "r": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}}, "df": 4}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}}, "df": 9}}}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}}, "df": 1}, "l": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}}, "df": 1}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 1}}}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 2}}}}}, "v": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.23606797749979}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 4, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}}, "df": 3}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "w": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}}, "df": 3}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.mutations.MutationFunc": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, ":": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "b": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1.7320508075688772}}, "df": 2, "c": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 7}, "d": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}}, "df": 3}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}}}}}}, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 4}}}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2}}, "df": 3, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}, "s": {"docs": {}, "df": 0, "k": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 2}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.utils.files.touch": {"tf": 1}}, "df": 1}}}}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 2}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1.7320508075688772}}, "df": 6}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}}, "df": 2}}}}}}}}, "e": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}, "b": {"docs": {"geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}}, "df": 1, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.23606797749979}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 11, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 2.6457513110645907}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 2.6457513110645907}}, "df": 7, "s": {"docs": {"geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}}, "df": 1}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1.4142135623730951}}, "df": 5}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 3}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 2}}}, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}}, "df": 1}}}, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}}, "df": 2, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {"geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 1}}}, "y": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 3}}, "df": 7}, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}}, "df": 2}}}, "t": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 3}}, "i": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}}, "df": 1}}}, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 2, "o": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 2}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 3.1622776601683795}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 25}, "h": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 2}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 2.449489742783178}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 2.23606797749979}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 3.872983346207417}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.6457513110645907}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}, "geneticalgorithm2.selections.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}}, "df": 22, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 5}}, "y": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 1}, "m": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3}}, "i": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.files.touch": {"tf": 1}}, "df": 6}}, "a": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1.4142135623730951}}, "df": 1}, "n": {"docs": {"geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}}, "df": 1}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}}, "df": 2, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}}, "df": 2}}}, "s": {"docs": {"geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 2}}}, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2.23606797749979}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 5, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}, "w": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.7320508075688772}}, "df": 4, "o": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.23606797749979}}, "df": 1, "n": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 6}}, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 7, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 2, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 8, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 2}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "w": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1.4142135623730951}}, "df": 2}, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}}, "df": 1}}}}}}}, "x": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 1}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "z": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 2}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 2}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 2}}, "df": 4}}}, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2}}, "k": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 5}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1.4142135623730951}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}}, "df": 3}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}, "n": {"docs": {"geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 1, "g": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 1}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.mutations.MutationFunc": {"tf": 1.4142135623730951}}, "df": 1, "+": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}}, "u": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}}, "df": 2}}}, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 3, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 2}, "r": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1.4142135623730951}}, "df": 1}, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 4, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1.4142135623730951}}, "df": 2}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 1}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 1}}}}}, "j": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}}, "df": 6}}}, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 1}}}}, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 2}}}}, "x": {"docs": {"geneticalgorithm2.mutations.MutationFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}}, "df": 2}}}}, "pipeline": ["trimmer"], "_isPrebuiltIndex": true};
+    /** pdoc search index */const docs = {"version": "0.9.5", "fields": ["qualname", "fullname", "annotation", "default_value", "signature", "bases", "doc"], "ref": "fullname", "documentStore": {"docs": {"geneticalgorithm2": {"fullname": "geneticalgorithm2", "modulename": "geneticalgorithm2", "kind": "module", "doc": "
Genetic Algorithm (Elitist version) for Python3.8+
\n\n
An implementation of elitist genetic algorithm for solving problems with\ncontinuous, integers, or mixed variables.
\n\n
repo path:       https://github.com/PasaOpasen/geneticalgorithm2
\n\n
code docs path:  https://pasaopasen.github.io/geneticalgorithm2/
\n"}, "geneticalgorithm2.geneticalgorithm2": {"fullname": "geneticalgorithm2.geneticalgorithm2", "modulename": "geneticalgorithm2.geneticalgorithm2", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.Population_initializer": {"fullname": "geneticalgorithm2.Population_initializer", "modulename": "geneticalgorithm2", "qualname": "Population_initializer", "kind": "function", "doc": "
Arguments:
\n\n
    \n
  • select_best_of:  determines population size to select 1/select_best_of best part of start population.\nFor example, for select_best_of = 4 and population_size = N there will be selected N best objects\n    from 5N generated objects (if start_generation=None dictionary).\nIf start_generation is not None dictionary, there will be selected best (start_generation) / N objects
    • \n
  • local_optimization_step:  when to perform local optimization
    • \n
  • local_optimizer:  the local optimization function (object array, its score) -> (modified array, its score)
    • \n
\n\n
Returns:
\n\n
\n  
select_best_of, population modifier
\n
\n", "signature": "(\tselect_best_of: int = 4,\tlocal_optimization_step: Literal['before_select', 'after_select', 'never'] = 'never',\tlocal_optimizer: Union[Callable[[numpy.ndarray, float], Tuple[numpy.ndarray, float]], NoneType] = None) -> Tuple[int, Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]]:", "funcdef": "def"}, "geneticalgorithm2.callbacks": {"fullname": "geneticalgorithm2.callbacks", "modulename": "geneticalgorithm2.callbacks", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.callbacks.data": {"fullname": "geneticalgorithm2.callbacks.data", "modulename": "geneticalgorithm2.callbacks.data", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData", "kind": "class", "doc": "
data object using in middle callbacks
\n", "bases": "geneticalgorithm2.data_types.base.DictLikeGetSet"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.__init__", "kind": "function", "doc": "
\n", "signature": "(\treason_to_stop: Union[str, NoneType],\tlast_generation: geneticalgorithm2.data_types.generation.Generation,\tcurrent_generation: int,\treport_list: List[float],\tmutation_prob: float,\tmutation_discrete_prob: float,\tmutation: Callable[[float, float, float], float],\tmutation_discrete: Callable[[int, int, int], int],\tcrossover: Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]],\tselection: Callable[[numpy.ndarray, int], numpy.ndarray],\tcurrent_stagnation: int,\tmax_stagnation: int,\tparents_portion: float,\telit_ratio: float,\tset_function: Callable[[numpy.ndarray], numpy.ndarray])"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.reason_to_stop", "kind": "variable", "doc": "
\n", "annotation": ": Union[str, NoneType]"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.last_generation", "kind": "variable", "doc": "
\n", "annotation": ": geneticalgorithm2.data_types.generation.Generation"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.current_generation", "kind": "variable", "doc": "
\n", "annotation": ": int"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.report_list", "kind": "variable", "doc": "
\n", "annotation": ": List[float]"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.mutation_prob", "kind": "variable", "doc": "
\n", "annotation": ": float"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.mutation_discrete_prob", "kind": "variable", "doc": "
\n", "annotation": ": float"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.mutation", "kind": "variable", "doc": "
\n", "annotation": ": Callable[[float, float, float], float]"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.mutation_discrete", "kind": "variable", "doc": "
\n", "annotation": ": Callable[[int, int, int], int]"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.crossover", "kind": "variable", "doc": "
\n", "annotation": ": Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.selection", "kind": "variable", "doc": "
\n", "annotation": ": Callable[[numpy.ndarray, int], numpy.ndarray]"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.current_stagnation", "kind": "variable", "doc": "
\n", "annotation": ": int"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.max_stagnation", "kind": "variable", "doc": "
\n", "annotation": ": int"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.parents_portion", "kind": "variable", "doc": "
\n", "annotation": ": float"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.elit_ratio", "kind": "variable", "doc": "
\n", "annotation": ": float"}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackData.set_function", "kind": "variable", "doc": "
\n", "annotation": ": Callable[[numpy.ndarray], numpy.ndarray]"}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"fullname": "geneticalgorithm2.callbacks.data.SimpleCallbackFunc", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "SimpleCallbackFunc", "kind": "variable", "doc": "
Callback function performs any operations on \n    (generation number, best scores report list, last population matrix, last scores vector)
\n\n
Notes: generation number cannot be changed
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Callable[[int, typing.List[float], numpy.ndarray, numpy.ndarray], NoneType]"}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackConditionFunc", "kind": "variable", "doc": "
Function (middle callback data) -> (bool value means whether to call middle callback action)
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], bool]"}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackActionFunc", "kind": "variable", "doc": "
Function which transforms and returns middle callback data or just uses it some way
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], geneticalgorithm2.callbacks.data.MiddleCallbackData]"}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"fullname": "geneticalgorithm2.callbacks.data.MiddleCallbackFunc", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "MiddleCallbackFunc", "kind": "variable", "doc": "
Function (input middle callback data) -> (output callback data, changes flag)\n    where input and output data may be same \n    and changes flag means whether the output data must be read back\n        to the optimization process (to update by flag only one time -- for acceleration purposes)
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], typing.Tuple[geneticalgorithm2.callbacks.data.MiddleCallbackData, bool]]"}, "geneticalgorithm2.callbacks.middle": {"fullname": "geneticalgorithm2.callbacks.middle", "modulename": "geneticalgorithm2.callbacks.middle", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.callbacks.middle.Actions": {"fullname": "geneticalgorithm2.callbacks.middle.Actions", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "Actions", "kind": "class", "doc": "
Static class of built-in middle callback actions
\n"}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"fullname": "geneticalgorithm2.callbacks.middle.Actions.Stop", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "Actions.Stop", "kind": "function", "doc": "
stops optimization
\n", "signature": "(\treason_name: str = 'stopped by Stop callback') -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], geneticalgorithm2.callbacks.data.MiddleCallbackData]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"fullname": "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "Actions.ReduceMutationProb", "kind": "function", "doc": "
reduces mutation prob by the coefficient
\n", "signature": "(\treduce_coef: float = 0.9) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], geneticalgorithm2.callbacks.data.MiddleCallbackData]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"fullname": "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "Actions.ChangeRandomCrossover", "kind": "function", "doc": "
randomly changes crossover
\n", "signature": "(\tavailable_crossovers: Sequence[Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]]) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], geneticalgorithm2.callbacks.data.MiddleCallbackData]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"fullname": "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "Actions.ChangeRandomSelection", "kind": "function", "doc": "
randomly changes selection function
\n", "signature": "(\tavailable_selections: Sequence[Callable[[numpy.ndarray, int], numpy.ndarray]]) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], geneticalgorithm2.callbacks.data.MiddleCallbackData]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"fullname": "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "Actions.ChangeRandomMutation", "kind": "function", "doc": "
randomly changes mutation function
\n", "signature": "(\tavailable_mutations: Sequence[Union[Callable[[int, int, int], int], Callable[[float, float, float], float]]]) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], geneticalgorithm2.callbacks.data.MiddleCallbackData]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"fullname": "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "Actions.RemoveDuplicates", "kind": "function", "doc": "
Removes duplicates from population
\n\n
Arguments:
\n\n
    \n
  • oppositor:  oppositor from OppOpPopInit, optional\noppositor for applying after duplicates removing.\nNone (default) means to just use the random initializer from creator.
    • \n
  • creator:  the function creates population samples, optional\nthe function creates population samples if oppositor is None. The default is None.
    • \n
  • converter:  function converts (preprocesses) population samples in new format to compare (if needed)\nbefore duplicates will be searched
    • \n
\n", "signature": "(\toppositor: Union[Callable[[numpy.ndarray], numpy.ndarray], NoneType] = None,\tcreator: Union[Callable[[], numpy.ndarray], NoneType] = None,\tconverter: Union[Callable[[numpy.ndarray], numpy.ndarray], NoneType] = None) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], geneticalgorithm2.callbacks.data.MiddleCallbackData]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"fullname": "geneticalgorithm2.callbacks.middle.Actions.CopyBest", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "Actions.CopyBest", "kind": "function", "doc": "
Copies best population object values (from dimensions in by_indexes) to all population
\n", "signature": "(\tby_indexes: Sequence[int]) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], geneticalgorithm2.callbacks.data.MiddleCallbackData]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"fullname": "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "Actions.PlotPopulationScores", "kind": "function", "doc": "
plots population scores\nneeds 2 functions like data->str for title and file name
\n", "signature": "(\ttitle_pattern: Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], str] = <function Actions.<lambda>>,\tsave_as_name_pattern: Union[Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], str], NoneType] = None) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], geneticalgorithm2.callbacks.data.MiddleCallbackData]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"fullname": "geneticalgorithm2.callbacks.middle.ActionConditions", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "ActionConditions", "kind": "class", "doc": "
Static class of built-in middle callback actions
\n"}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"fullname": "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "ActionConditions.EachGen", "kind": "function", "doc": "
\n", "signature": "(\tgeneration_step: int = 10) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], bool]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"fullname": "geneticalgorithm2.callbacks.middle.ActionConditions.Always", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "ActionConditions.Always", "kind": "function", "doc": "
makes action each generation
\n", "signature": "() -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], bool]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"fullname": "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "ActionConditions.AfterStagnation", "kind": "function", "doc": "
\n", "signature": "(\tstagnation_generations: int = 50) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], bool]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"fullname": "geneticalgorithm2.callbacks.middle.ActionConditions.All", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "ActionConditions.All", "kind": "function", "doc": "
returns function which checks all conditions from conditions
\n", "signature": "(\tconditions: Sequence[Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], bool]]) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], bool]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"fullname": "geneticalgorithm2.callbacks.middle.ActionConditions.Any", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "ActionConditions.Any", "kind": "function", "doc": "
returns function which checks for any conditions from conditions
\n", "signature": "(\tconditions: Sequence[Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], bool]]) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], bool]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"fullname": "geneticalgorithm2.callbacks.middle.MiddleCallbacks", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "MiddleCallbacks", "kind": "class", "doc": "
Static class for middle callbacks creation
\n"}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"fullname": "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "MiddleCallbacks.UniversalCallback", "kind": "function", "doc": "
universal function which constructs middle callback from action and condition
\n\n
Arguments:
\n\n
    \n
  • action: 
    • \n
  • condition: 
    • \n
  • set_data_after_callback:  whether to signal internal data update if action update the data
    • \n
\n\n
Returns:
\n", "signature": "(\taction: Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], geneticalgorithm2.callbacks.data.MiddleCallbackData],\tcondition: Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], bool],\tset_data_after_callback: bool = True) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], Tuple[geneticalgorithm2.callbacks.data.MiddleCallbackData, bool]]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"fullname": "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "MiddleCallbacks.ReduceMutationGen", "kind": "function", "doc": "
\n", "signature": "(\treduce_coef: float = 0.9,\tmin_mutation: float = 0.005,\treduce_each_generation: int = 50,\treload_each_generation: int = 500) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], Tuple[geneticalgorithm2.callbacks.data.MiddleCallbackData, bool]]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"fullname": "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats", "modulename": "geneticalgorithm2.callbacks.middle", "qualname": "MiddleCallbacks.GeneDiversityStats", "kind": "function", "doc": "
\n", "signature": "(\tstep_generations_for_plotting: int = 10) -> Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], Tuple[geneticalgorithm2.callbacks.data.MiddleCallbackData, bool]]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.simple": {"fullname": "geneticalgorithm2.callbacks.simple", "modulename": "geneticalgorithm2.callbacks.simple", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.callbacks.simple.Callbacks": {"fullname": "geneticalgorithm2.callbacks.simple.Callbacks", "modulename": "geneticalgorithm2.callbacks.simple", "qualname": "Callbacks", "kind": "class", "doc": "
Static class with several simple callback methods
\n"}, "geneticalgorithm2.callbacks.simple.Callbacks.NoneCallback": {"fullname": "geneticalgorithm2.callbacks.simple.Callbacks.NoneCallback", "modulename": "geneticalgorithm2.callbacks.simple", "qualname": "Callbacks.NoneCallback", "kind": "function", "doc": "
\n", "signature": "():", "funcdef": "def"}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"fullname": "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation", "modulename": "geneticalgorithm2.callbacks.simple", "qualname": "Callbacks.SavePopulation", "kind": "function", "doc": "
saves population to disk periodically
\n", "signature": "(\tfolder: Union[str, os.PathLike],\tsave_gen_step: int = 50,\tfile_prefix: str = 'population') -> Callable[[int, List[float], numpy.ndarray, numpy.ndarray], NoneType]:", "funcdef": "def"}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"fullname": "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess", "modulename": "geneticalgorithm2.callbacks.simple", "qualname": "Callbacks.PlotOptimizationProcess", "kind": "function", "doc": "
Saves optimization process plots to disk periodically
\n\n
Arguments:
\n\n
    \n
  • folder: 
    • \n
  • save_gen_step: 
    • \n
  • show: 
    • \n
  • main_color: 
    • \n
  • file_prefix: 
    • \n
\n\n
Returns:
\n", "signature": "(\tfolder: Union[str, os.PathLike],\tsave_gen_step: int = 50,\tshow: bool = False,\tmain_color: str = 'green',\tfile_prefix: str = 'report') -> Callable[[int, List[float], numpy.ndarray, numpy.ndarray], NoneType]:", "funcdef": "def"}, "geneticalgorithm2.crossovers": {"fullname": "geneticalgorithm2.crossovers", "modulename": "geneticalgorithm2.crossovers", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.crossovers.CrossoverFunc": {"fullname": "geneticalgorithm2.crossovers.CrossoverFunc", "modulename": "geneticalgorithm2.crossovers", "qualname": "CrossoverFunc", "kind": "variable", "doc": "
Function (parent1, parent2) -> (child1, child2)
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Callable[[numpy.ndarray, numpy.ndarray], typing.Tuple[numpy.ndarray, numpy.ndarray]]"}, "geneticalgorithm2.crossovers.get_copies": {"fullname": "geneticalgorithm2.crossovers.get_copies", "modulename": "geneticalgorithm2.crossovers", "qualname": "get_copies", "kind": "function", "doc": "
\n", "signature": "(\tx: numpy.ndarray,\ty: numpy.ndarray) -> Tuple[numpy.ndarray, numpy.ndarray]:", "funcdef": "def"}, "geneticalgorithm2.crossovers.Crossover": {"fullname": "geneticalgorithm2.crossovers.Crossover", "modulename": "geneticalgorithm2.crossovers", "qualname": "Crossover", "kind": "class", "doc": "
Crossover functions static class
\n\n
Crossover creates 2 children from 2 parents someway, usually mixing the parents
\n"}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"fullname": "geneticalgorithm2.crossovers.Crossover.crossovers_dict", "modulename": "geneticalgorithm2.crossovers", "qualname": "Crossover.crossovers_dict", "kind": "function", "doc": "
\n", "signature": "() -> Dict[str, Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]]:", "funcdef": "def"}, "geneticalgorithm2.crossovers.Crossover.one_point": {"fullname": "geneticalgorithm2.crossovers.Crossover.one_point", "modulename": "geneticalgorithm2.crossovers", "qualname": "Crossover.one_point", "kind": "function", "doc": "
\n", "signature": "() -> Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]:", "funcdef": "def"}, "geneticalgorithm2.crossovers.Crossover.two_point": {"fullname": "geneticalgorithm2.crossovers.Crossover.two_point", "modulename": "geneticalgorithm2.crossovers", "qualname": "Crossover.two_point", "kind": "function", "doc": "
\n", "signature": "() -> Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]:", "funcdef": "def"}, "geneticalgorithm2.crossovers.Crossover.uniform": {"fullname": "geneticalgorithm2.crossovers.Crossover.uniform", "modulename": "geneticalgorithm2.crossovers", "qualname": "Crossover.uniform", "kind": "function", "doc": "
\n", "signature": "() -> Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]:", "funcdef": "def"}, "geneticalgorithm2.crossovers.Crossover.segment": {"fullname": "geneticalgorithm2.crossovers.Crossover.segment", "modulename": "geneticalgorithm2.crossovers", "qualname": "Crossover.segment", "kind": "function", "doc": "
\n", "signature": "(\tprob: int = 0.6) -> Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]:", "funcdef": "def"}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"fullname": "geneticalgorithm2.crossovers.Crossover.shuffle", "modulename": "geneticalgorithm2.crossovers", "qualname": "Crossover.shuffle", "kind": "function", "doc": "
\n", "signature": "() -> Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]:", "funcdef": "def"}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"fullname": "geneticalgorithm2.crossovers.Crossover.uniform_window", "modulename": "geneticalgorithm2.crossovers", "qualname": "Crossover.uniform_window", "kind": "function", "doc": "
\n", "signature": "(\twindow: int = 7) -> Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]:", "funcdef": "def"}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"fullname": "geneticalgorithm2.crossovers.Crossover.arithmetic", "modulename": "geneticalgorithm2.crossovers", "qualname": "Crossover.arithmetic", "kind": "function", "doc": "
\n", "signature": "() -> Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]:", "funcdef": "def"}, "geneticalgorithm2.crossovers.Crossover.mixed": {"fullname": "geneticalgorithm2.crossovers.Crossover.mixed", "modulename": "geneticalgorithm2.crossovers", "qualname": "Crossover.mixed", "kind": "function", "doc": "
\n", "signature": "(\talpha: float = 0.5) -> Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]:", "funcdef": "def"}, "geneticalgorithm2.data_types": {"fullname": "geneticalgorithm2.data_types", "modulename": "geneticalgorithm2.data_types", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.data_types.algorithm_params": {"fullname": "geneticalgorithm2.data_types.algorithm_params", "modulename": "geneticalgorithm2.data_types.algorithm_params", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams", "kind": "class", "doc": "
Base optimization parameters container
\n", "bases": "geneticalgorithm2.data_types.base.DictLikeGetSet"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.__init__", "kind": "function", "doc": "
\n", "signature": "(\tmax_num_iteration: Union[int, NoneType] = None,\tmax_iteration_without_improv: Union[int, NoneType] = None,\tpopulation_size: int = 100,\tmutation_probability: float = 0.1,\tmutation_discrete_probability: Union[float, NoneType] = None,\tcrossover_probability: Union[float, NoneType] = None,\telit_ratio: float = 0.04,\tparents_portion: float = 0.3,\tcrossover_type: Union[str, Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]] = 'uniform',\tmutation_type: Union[str, Callable[[float, float, float], float]] = 'uniform_by_center',\tmutation_discrete_type: Union[str, Callable[[int, int, int], int]] = 'uniform_discrete',\tselection_type: Union[str, Callable[[numpy.ndarray, int], numpy.ndarray]] = 'roulette')"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.max_num_iteration", "kind": "variable", "doc": "
max iterations count of the algorithm
\n\n
If this parameter's value is None the algorithm sets maximum number of iterations automatically \n    as a function of the dimension, boundaries, and population size. \nThe user may enter any number of iterations that they want. \nIt is highly recommended that the user themselves determines \n    the max_num_iterations and not to use None
\n", "annotation": ": Union[int, NoneType]", "default_value": "None"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.max_iteration_without_improv", "kind": "variable", "doc": "
max iteration without progress
\n\n
if the algorithms does not improve \n    the objective function over the number of successive iterations \n        determined by this parameter, \n        then GA stops and report the best found solution \n        before the max_num_iterations to be met
\n", "annotation": ": Union[int, NoneType]", "default_value": "None"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.population_size", "kind": "variable", "doc": "
determines the number of trial solutions in each iteration
\n", "annotation": ": int", "default_value": "100"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.mutation_probability", "kind": "variable", "doc": "
\n", "annotation": ": float", "default_value": "0.1"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.mutation_discrete_probability", "kind": "variable", "doc": "
works like mutation_probability but for discrete variables. 
\n\n
If None, will be assigned to mutation_probability value; \n    so just don't specify this parameter \n    if u don't need special mutation behavior for discrete variables
\n", "annotation": ": Union[float, NoneType]", "default_value": "None"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.crossover_probability", "kind": "variable", "doc": "
\n", "annotation": ": Union[float, NoneType]", "default_value": "None"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.elit_ratio", "kind": "variable", "doc": "
determines the number of elites in the population. 
\n\n
For example, when population size is 100 and elit_ratio is 0.01 \n    then there is 4 elite units in the population. \nIf this parameter is set to be zero then GeneticAlgorithm2 implements \n    a standard genetic algorithm instead of elitist GA
\n", "annotation": ": float", "default_value": "0.04"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.parents_portion", "kind": "variable", "doc": "
the portion of population filled by the members of the previous generation (aka parents)
\n", "annotation": ": float", "default_value": "0.3"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.crossover_type", "kind": "variable", "doc": "
\n", "annotation": ": Union[str, Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]]", "default_value": "'uniform'"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.mutation_type", "kind": "variable", "doc": "
mutation type for real variable
\n", "annotation": ": Union[str, Callable[[float, float, float], float]]", "default_value": "'uniform_by_center'"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.mutation_discrete_type", "kind": "variable", "doc": "
mutation type for discrete variables
\n", "annotation": ": Union[str, Callable[[int, int, int], int]]", "default_value": "'uniform_discrete'"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.selection_type", "kind": "variable", "doc": "
\n", "annotation": ": Union[str, Callable[[numpy.ndarray, int], numpy.ndarray]]", "default_value": "'roulette'"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.validate", "kind": "function", "doc": "
\n", "signature": "(self) -> None:", "funcdef": "def"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.get_CMS_funcs", "kind": "function", "doc": "
Returns:
\n\n
\n  
gotten (crossover, mutation, discrete mutation, selection) as necessary functions
\n
\n", "signature": "(\tself) -> Tuple[Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]], Callable[[float, float, float], float], Callable[[int, int, int], int], Callable[[numpy.ndarray, int], numpy.ndarray]]:", "funcdef": "def"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.update", "kind": "function", "doc": "
\n", "signature": "(self, dct: Dict[str, Any]):", "funcdef": "def"}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"fullname": "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict", "modulename": "geneticalgorithm2.data_types.algorithm_params", "qualname": "AlgorithmParams.from_dict", "kind": "function", "doc": "
\n", "signature": "(dct: Dict[str, Any]):", "funcdef": "def"}, "geneticalgorithm2.data_types.aliases": {"fullname": "geneticalgorithm2.data_types.aliases", "modulename": "geneticalgorithm2.data_types.aliases", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"fullname": "geneticalgorithm2.data_types.aliases.FunctionToMinimize", "modulename": "geneticalgorithm2.data_types.aliases", "qualname": "FunctionToMinimize", "kind": "variable", "doc": "
usual (vector -> value) function to minimize
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Callable[[numpy.ndarray], float]"}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"fullname": "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize", "modulename": "geneticalgorithm2.data_types.aliases", "qualname": "SetFunctionToMinimize", "kind": "variable", "doc": "
(population -> scores) function to minimize
\n\n
it is like a vectorized version of usual (vector -> value) function\n    performing to all population samples in the one call
\n\n
but it can be written in more optimal way to speed up the calculations;\n    also it can contain any logic due to samples relations and so on -- depends on the task
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Callable[[numpy.ndarray], numpy.ndarray]"}, "geneticalgorithm2.data_types.base": {"fullname": "geneticalgorithm2.data_types.base", "modulename": "geneticalgorithm2.data_types.base", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.data_types.base.DictLikeGetSet": {"fullname": "geneticalgorithm2.data_types.base.DictLikeGetSet", "modulename": "geneticalgorithm2.data_types.base", "qualname": "DictLikeGetSet", "kind": "class", "doc": "
\n"}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"fullname": "geneticalgorithm2.data_types.base.DictLikeGetSet.get", "modulename": "geneticalgorithm2.data_types.base", "qualname": "DictLikeGetSet.get", "kind": "function", "doc": "
\n", "signature": "(self, item):", "funcdef": "def"}, "geneticalgorithm2.data_types.generation": {"fullname": "geneticalgorithm2.data_types.generation", "modulename": "geneticalgorithm2.data_types.generation", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"fullname": "geneticalgorithm2.data_types.generation.GenerationConvertible", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "GenerationConvertible", "kind": "variable", "doc": "
The forms convertible to Generation object:\n    - Generation object\n    - path to saved generation\n    - dict {'population': pop_matrix, 'scores': scores_vector}\n    - wide population matrix\n    - pair (pop_matrix, scores_vector)
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Union[ForwardRef('Generation'), str, typing.Dict[typing.Literal['population', 'scores'], numpy.ndarray], numpy.ndarray, typing.Tuple[typing.Union[numpy.ndarray, NoneType], typing.Union[numpy.ndarray, NoneType]]]"}, "geneticalgorithm2.data_types.generation.Generation": {"fullname": "geneticalgorithm2.data_types.generation.Generation", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "Generation", "kind": "class", "doc": "
wrapper on generation object (pair of samples matrix and samples scores vector)
\n", "bases": "geneticalgorithm2.data_types.base.DictLikeGetSet"}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"fullname": "geneticalgorithm2.data_types.generation.Generation.__init__", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "Generation.__init__", "kind": "function", "doc": "
\n", "signature": "(\tvariables: Union[numpy.ndarray, NoneType] = None,\tscores: Union[numpy.ndarray, NoneType] = None)"}, "geneticalgorithm2.data_types.generation.Generation.variables": {"fullname": "geneticalgorithm2.data_types.generation.Generation.variables", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "Generation.variables", "kind": "variable", "doc": "
\n", "annotation": ": Union[numpy.ndarray, NoneType]", "default_value": "None"}, "geneticalgorithm2.data_types.generation.Generation.scores": {"fullname": "geneticalgorithm2.data_types.generation.Generation.scores", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "Generation.scores", "kind": "variable", "doc": "
\n", "annotation": ": Union[numpy.ndarray, NoneType]", "default_value": "None"}, "geneticalgorithm2.data_types.generation.Generation.size": {"fullname": "geneticalgorithm2.data_types.generation.Generation.size", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "Generation.size", "kind": "variable", "doc": "
\n", "annotation": ": int"}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"fullname": "geneticalgorithm2.data_types.generation.Generation.dim_size", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "Generation.dim_size", "kind": "variable", "doc": "
\n", "annotation": ": int"}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"fullname": "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "Generation.as_wide_matrix", "kind": "function", "doc": "
\n", "signature": "(self) -> numpy.ndarray:", "funcdef": "def"}, "geneticalgorithm2.data_types.generation.Generation.save": {"fullname": "geneticalgorithm2.data_types.generation.Generation.save", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "Generation.save", "kind": "function", "doc": "
\n", "signature": "(self, path: Union[str, os.PathLike]):", "funcdef": "def"}, "geneticalgorithm2.data_types.generation.Generation.load": {"fullname": "geneticalgorithm2.data_types.generation.Generation.load", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "Generation.load", "kind": "function", "doc": "
\n", "signature": "(path: Union[str, os.PathLike]):", "funcdef": "def"}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"fullname": "geneticalgorithm2.data_types.generation.Generation.from_object", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "Generation.from_object", "kind": "function", "doc": "
class constructor
\n", "signature": "(\tdim: int,\tobj: Union[geneticalgorithm2.data_types.generation.Generation, str, Dict[Literal['population', 'scores'], numpy.ndarray], numpy.ndarray, Tuple[Union[numpy.ndarray, NoneType], Union[numpy.ndarray, NoneType]]]):", "funcdef": "def"}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"fullname": "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix", "modulename": "geneticalgorithm2.data_types.generation", "qualname": "Generation.from_pop_matrix", "kind": "function", "doc": "
\n", "signature": "(pop: numpy.ndarray):", "funcdef": "def"}, "geneticalgorithm2.data_types.result": {"fullname": "geneticalgorithm2.data_types.result", "modulename": "geneticalgorithm2.data_types.result", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.data_types.result.GAResult": {"fullname": "geneticalgorithm2.data_types.result.GAResult", "modulename": "geneticalgorithm2.data_types.result", "qualname": "GAResult", "kind": "class", "doc": "
\n", "bases": "geneticalgorithm2.data_types.base.DictLikeGetSet"}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"fullname": "geneticalgorithm2.data_types.result.GAResult.__init__", "modulename": "geneticalgorithm2.data_types.result", "qualname": "GAResult.__init__", "kind": "function", "doc": "
\n", "signature": "(last_generation: geneticalgorithm2.data_types.generation.Generation)"}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"fullname": "geneticalgorithm2.data_types.result.GAResult.last_generation", "modulename": "geneticalgorithm2.data_types.result", "qualname": "GAResult.last_generation", "kind": "variable", "doc": "
\n", "annotation": ": geneticalgorithm2.data_types.generation.Generation"}, "geneticalgorithm2.data_types.result.GAResult.variable": {"fullname": "geneticalgorithm2.data_types.result.GAResult.variable", "modulename": "geneticalgorithm2.data_types.result", "qualname": "GAResult.variable", "kind": "variable", "doc": "
\n", "annotation": ": numpy.ndarray"}, "geneticalgorithm2.data_types.result.GAResult.score": {"fullname": "geneticalgorithm2.data_types.result.GAResult.score", "modulename": "geneticalgorithm2.data_types.result", "qualname": "GAResult.score", "kind": "variable", "doc": "
\n", "annotation": ": float"}, "geneticalgorithm2.data_types.result.GAResult.function": {"fullname": "geneticalgorithm2.data_types.result.GAResult.function", "modulename": "geneticalgorithm2.data_types.result", "qualname": "GAResult.function", "kind": "variable", "doc": "
\n"}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"fullname": "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "VARIABLE_TYPE", "kind": "variable", "doc": "
the variable type for a given or all dimension, determines the values discretion:\n    real: double numbers\n    int: integer number only\n    bool: in the fact is integer with bounds [0, 1]
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Literal['int', 'real', 'bool']"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2", "kind": "class", "doc": "
Genetic algorithm optimization process
\n"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.__init__", "kind": "function", "doc": "
initializes the GA object and performs main checks
\n\n
Arguments:
\n\n
    \n
  • function:  the given objective function to be minimized -- deprecated and moved to run() method
    • \n
  • dimension:  the number of decision variables, the population samples dimension
    • \n
  • variable_type:  string means the variable type for all variables,\nfor mixed types use sequence of strings of type for each variable
    • \n
  • variable_boundaries:  leave it None if variable_type is 'bool';\notherwise provide a sequence of tuples of length two as boundaries for each variable;\nthe length of the array must be equal dimension.\nFor example, ([0,100], [0,200]) determines\n    lower boundary 0 and upper boundary 100 for first\n    and upper boundary 200 for second variable\n    and dimension must be 2.
    • \n
  • variable_type_mixed -- deprecated
    • \n
  • function_timeout:  if the given function does not provide\noutput before function_timeout (unit is seconds) the algorithm raises error.\nFor example, when there is an infinite loop in the given function.\nNone means disabling -- deprecated and moved to run()
    • \n
  • algorithm_parameters:  AlgorithmParams object or usual dictionary with algorithm parameter;\nit is not mandatory to provide all possible parameters
    • \n
\n\n
Notes:
\n\n
\n  
    \n  
  • This implementation minimizes the given objective function.\n  For maximization u can multiply the function by -1 (for instance): the absolute\n  value of the output would be the actual objective function
    • \n  
\n
\n\n
for more details and examples of implementation please visit:\n    https://github.com/PasaOpasen/geneticalgorithm2
\n", "signature": "(\tfunction: Callable[[numpy.ndarray], float] = None,\tdimension: int = 0,\tvariable_type: Union[Literal['int', 'real', 'bool'], Sequence[Literal['int', 'real', 'bool']]] = 'bool',\tvariable_boundaries: Union[numpy.ndarray, Sequence[Tuple[float, float]], NoneType] = None,\tvariable_type_mixed=None,\tfunction_timeout: Union[float, NoneType] = None,\talgorithm_parameters: Union[geneticalgorithm2.data_types.algorithm_params.AlgorithmParams, Dict[str, Any]] = AlgorithmParams(max_num_iteration=None, max_iteration_without_improv=None, population_size=100, mutation_probability=0.1, mutation_discrete_probability=None, crossover_probability=None, elit_ratio=0.04, parents_portion=0.3, crossover_type='uniform', mutation_type='uniform_by_center', mutation_discrete_type='uniform_discrete', selection_type='roulette'))"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.default_params", "kind": "variable", "doc": "
\n", "default_value": "AlgorithmParams(max_num_iteration=None, max_iteration_without_improv=None, population_size=100, mutation_probability=0.1, mutation_discrete_probability=None, crossover_probability=None, elit_ratio=0.04, parents_portion=0.3, crossover_type='uniform', mutation_type='uniform_by_center', mutation_discrete_type='uniform_discrete', selection_type='roulette')"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.PROGRESS_BAR_LEN", "kind": "variable", "doc": "
max count of symbols in the progress bar
\n", "default_value": "20"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.output_dict": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.output_dict", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.output_dict", "kind": "variable", "doc": "
\n"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.needs_mutation", "kind": "variable", "doc": "
whether the mutation is required
\n", "annotation": ": bool"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.revolution_oppositor": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.revolution_oppositor", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.revolution_oppositor", "kind": "variable", "doc": "
\n"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dup_oppositor": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dup_oppositor", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.dup_oppositor", "kind": "variable", "doc": "
\n"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.creator": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.creator", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.creator", "kind": "variable", "doc": "
\n"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.init_oppositors": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.init_oppositors", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.init_oppositors", "kind": "variable", "doc": "
\n"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.f", "kind": "variable", "doc": "
\n", "annotation": ": Callable[[numpy.ndarray], float]"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.funtimeout": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.funtimeout", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.funtimeout", "kind": "variable", "doc": "
\n", "annotation": ": float"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.set_function", "kind": "variable", "doc": "
\n", "annotation": ": Callable[[numpy.ndarray], numpy.ndarray]"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.var_bounds", "kind": "variable", "doc": "
\n", "annotation": ": List[Tuple[Union[int, float], Union[int, float]]]"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.checked_reports", "kind": "variable", "doc": "
\n", "annotation": ": List[Tuple[str, Callable[[numpy.ndarray], NoneType]]]"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.population_size", "kind": "variable", "doc": "
\n", "annotation": ": int"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.progress_stream": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.progress_stream", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.progress_stream", "kind": "variable", "doc": "
\n"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.param": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.param", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.param", "kind": "variable", "doc": "
\n"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dim": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dim", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.dim", "kind": "variable", "doc": "
\n"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.prob_mut", "kind": "variable", "doc": "
\n"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.prob_mut_discrete", "kind": "variable", "doc": "
\n"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.fill_children", "kind": "variable", "doc": "
custom function which adds children for population POP \n    where POP[:parents_count] are parents lines and next lines are for children
\n", "annotation": ": Union[Callable[[numpy.ndarray, int], NoneType], NoneType]"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.run", "kind": "function", "doc": "
runs optimization process
\n\n
Arguments:
\n\n
    \n
  • no_plot:  do not plot results using matplotlib by default
    • \n
  • disable_printing:  do not print log info of optimization process
    • \n
  • progress_bar_stream:  'stdout', 'stderr' or None to disable progress bar
    • \n
  • disable_progress_bar:  deprecated
    • \n
  • function:  the given objective function (sample -> its score) to be minimized;
    • \n
  • function_timeout:  if the given function does not provide\noutput before function_timeout (unit is seconds) the algorithm raises error.\nFor example, when there is an infinite loop in the given function.\nNone means disabling
    • \n
  • set_function:  set function (all samples -> score per sample) to be used instead of usual function\n(usually for optimization purposes)
    • \n
  • apply_function_to_parents:  whether to apply function to parents from previous generation (if it's needed)
    • \n
  • start_generation:  initial generation object of any GenerationConvertible type
    • \n
  • studEA:  using stud EA strategy (crossover with best object always)
    • \n
  • mutation_indexes:  indexes of dimensions where mutation can be performed (all dimensions by default)
    • \n
  • init_creator:  the function creates population samples.\nBy default -- random uniform for real variables and random uniform for int
    • \n
  • init_oppositors:  the list of oppositors creates oppositions for base population. No by default
    • \n
  • duplicates_oppositor:  oppositor for applying after duplicates removing.\nBy default -- using just random initializer from creator
    • \n
  • remove_duplicates_generation_step:  step for removing duplicates (have a sense with discrete tasks).\nNo by default
    • \n
  • revolution_oppositor:  oppositor for revolution time. No by default
    • \n
  • revolution_after_stagnation_step:  create revolution after this generations of stagnation. No by default
    • \n
  • revolution_part:  float, the part of generation to being oppose. By default is 0.3
    • \n
  • population_initializer:  object for actions at population initialization step\nto create better start population. See doc
    • \n
  • stop_when_reached:  stop searching after reaching this value (it can be potential minimum or something else)
    • \n
  • callbacks:  sequence of callback functions with structure:\n(generation_number, report_list, last_population, last_scores) -> do some action
    • \n
  • middle_callbacks:  sequence of functions made MiddleCallback class
    • \n
  • time_limit_secs:  limit time of working (in seconds)
    • \n
  • save_last_generation_as:  path to .npz file for saving last_generation as numpy dictionary like\n{'population': 2D-array, 'scores': 1D-array}, None if doesn't need to save in file
    • \n
  • seed:  random seed (None if doesn't matter)
    • \n
\n\n
Notes:
\n\n
\n  
if function_timeout is enabled then function must be set
\n
\n", "signature": "(\tself,\tno_plot: bool = False,\tdisable_printing: bool = False,\tprogress_bar_stream: Union[str, NoneType] = 'stdout',\tdisable_progress_bar: bool = False,\tfunction: Callable[[numpy.ndarray], float] = None,\tfunction_timeout: Union[float, NoneType] = None,\tset_function: Callable[[numpy.ndarray], numpy.ndarray] = None,\tapply_function_to_parents: bool = False,\tstart_generation: Union[geneticalgorithm2.data_types.generation.Generation, str, Dict[Literal['population', 'scores'], numpy.ndarray], numpy.ndarray, Tuple[Union[numpy.ndarray, NoneType], Union[numpy.ndarray, NoneType]]] = Generation(variables=None, scores=None),\tstudEA: bool = False,\tmutation_indexes: Union[Iterable[int], NoneType] = None,\tinit_creator: Union[Callable[[], numpy.ndarray], NoneType] = None,\tinit_oppositors: Union[Sequence[Callable[[numpy.ndarray], numpy.ndarray]], NoneType] = None,\tduplicates_oppositor: Union[Callable[[numpy.ndarray], numpy.ndarray], NoneType] = None,\tremove_duplicates_generation_step: Union[int, NoneType] = None,\trevolution_oppositor: Union[Callable[[numpy.ndarray], numpy.ndarray], NoneType] = None,\trevolution_after_stagnation_step: Union[int, NoneType] = None,\trevolution_part: float = 0.3,\tpopulation_initializer: Tuple[int, Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]] = (1, <function get_population_initializer.<locals>.process_population>),\tstop_when_reached: Union[float, NoneType] = None,\tcallbacks: Union[Sequence[Callable[[int, List[float], numpy.ndarray, numpy.ndarray], NoneType]], NoneType] = None,\tmiddle_callbacks: Union[Sequence[Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], Tuple[geneticalgorithm2.callbacks.data.MiddleCallbackData, bool]]], NoneType] = None,\ttime_limit_secs: Union[float, NoneType] = None,\tsave_last_generation_as: Union[str, NoneType] = None,\tseed: Union[int, NoneType] = None):", "funcdef": "def"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.plot_results", "kind": "function", "doc": "
Simple plot of self.report (if not empty)
\n", "signature": "(\tself,\ttitle: str = 'Genetic Algorithm',\tsave_as: Union[str, NoneType] = None,\tdpi: int = 200,\tmain_color: str = 'blue'):", "funcdef": "def"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.plot_generation_scores", "kind": "function", "doc": "
Plots barplot of scores of last population
\n", "signature": "(\tself,\ttitle: str = 'Last generation scores',\tsave_as: Union[str, NoneType] = None):", "funcdef": "def"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.mut", "kind": "function", "doc": "
just mutation
\n", "signature": "(self, x: numpy.ndarray):", "funcdef": "def"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.mut_middle", "kind": "function", "doc": "
mutation oriented on parents
\n", "signature": "(self, x: numpy.ndarray, p1: numpy.ndarray, p2: numpy.ndarray):", "funcdef": "def"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.default_set_function", "kind": "function", "doc": "
simple function for creating set_function \nfunction_for_set just applies to each row of population
\n", "signature": "(function_for_set: Callable[[numpy.ndarray], float]):", "funcdef": "def"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.vectorized_set_function", "kind": "function", "doc": "
works like default, but faster for big populations and slower for little\nfunction_for_set just applyes to each row of population
\n", "signature": "(function_for_set: Callable[[numpy.ndarray], float]):", "funcdef": "def"}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.set_function_multiprocess", "kind": "function", "doc": "
like function_for_set but uses joblib with n_jobs (-1 goes to count of available processors)
\n", "signature": "(function_for_set: Callable[[numpy.ndarray], float], n_jobs: int = -1):", "funcdef": "def"}, "geneticalgorithm2.mutations": {"fullname": "geneticalgorithm2.mutations", "modulename": "geneticalgorithm2.mutations", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.mutations.MutationFloatFunc": {"fullname": "geneticalgorithm2.mutations.MutationFloatFunc", "modulename": "geneticalgorithm2.mutations", "qualname": "MutationFloatFunc", "kind": "variable", "doc": "
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Callable[[float, float, float], float]"}, "geneticalgorithm2.mutations.MutationIntFunc": {"fullname": "geneticalgorithm2.mutations.MutationIntFunc", "modulename": "geneticalgorithm2.mutations", "qualname": "MutationIntFunc", "kind": "variable", "doc": "
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Callable[[int, int, int], int]"}, "geneticalgorithm2.mutations.MutationFunc": {"fullname": "geneticalgorithm2.mutations.MutationFunc", "modulename": "geneticalgorithm2.mutations", "qualname": "MutationFunc", "kind": "variable", "doc": "
Function (x, left, right) -> value
\n\n
Which mutates x to value according to bounds (left, right)
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Union[typing.Callable[[int, int, int], int], typing.Callable[[float, float, float], float]]"}, "geneticalgorithm2.mutations.Mutations": {"fullname": "geneticalgorithm2.mutations.Mutations", "modulename": "geneticalgorithm2.mutations", "qualname": "Mutations", "kind": "class", "doc": "
Mutations functions static class
\n\n
Mutation changes the sample randomly providing the evolution component to optimization
\n"}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"fullname": "geneticalgorithm2.mutations.Mutations.mutations_dict", "modulename": "geneticalgorithm2.mutations", "qualname": "Mutations.mutations_dict", "kind": "function", "doc": "
\n", "signature": "() -> Dict[str, Callable[[float, float, float], float]]:", "funcdef": "def"}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"fullname": "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict", "modulename": "geneticalgorithm2.mutations", "qualname": "Mutations.mutations_discrete_dict", "kind": "function", "doc": "
\n", "signature": "() -> Dict[str, Callable[[int, int, int], int]]:", "funcdef": "def"}, "geneticalgorithm2.mutations.Mutations.uniform_by_x": {"fullname": "geneticalgorithm2.mutations.Mutations.uniform_by_x", "modulename": "geneticalgorithm2.mutations", "qualname": "Mutations.uniform_by_x", "kind": "function", "doc": "
\n", "signature": "() -> Callable[[float, float, float], float]:", "funcdef": "def"}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"fullname": "geneticalgorithm2.mutations.Mutations.uniform_by_center", "modulename": "geneticalgorithm2.mutations", "qualname": "Mutations.uniform_by_center", "kind": "function", "doc": "
\n", "signature": "() -> Callable[[float, float, float], float]:", "funcdef": "def"}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"fullname": "geneticalgorithm2.mutations.Mutations.gauss_by_x", "modulename": "geneticalgorithm2.mutations", "qualname": "Mutations.gauss_by_x", "kind": "function", "doc": "
gauss mutation with x as center and sd*length_of_zone as std
\n", "signature": "(sd: float = 0.3) -> Callable[[float, float, float], float]:", "funcdef": "def"}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"fullname": "geneticalgorithm2.mutations.Mutations.gauss_by_center", "modulename": "geneticalgorithm2.mutations", "qualname": "Mutations.gauss_by_center", "kind": "function", "doc": "
gauss mutation with (left+right)/2 as center and sd*length_of_zone as std
\n", "signature": "(sd: float = 0.3) -> Callable[[float, float, float], float]:", "funcdef": "def"}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"fullname": "geneticalgorithm2.mutations.Mutations.uniform_discrete", "modulename": "geneticalgorithm2.mutations", "qualname": "Mutations.uniform_discrete", "kind": "function", "doc": "
\n", "signature": "() -> Callable[[int, int, int], int]:", "funcdef": "def"}, "geneticalgorithm2.population_initializer": {"fullname": "geneticalgorithm2.population_initializer", "modulename": "geneticalgorithm2.population_initializer", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.population_initializer.PopulationModifier": {"fullname": "geneticalgorithm2.population_initializer.PopulationModifier", "modulename": "geneticalgorithm2.population_initializer", "qualname": "PopulationModifier", "kind": "variable", "doc": "
function (population matrix, population scores) -> (new matrix, new scores)\nwhich will perform the bests selection and local optimization and other population transformations
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Callable[[numpy.ndarray, numpy.ndarray], typing.Tuple[numpy.ndarray, numpy.ndarray]]"}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"fullname": "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE", "modulename": "geneticalgorithm2.population_initializer", "qualname": "LOCAL_OPTIMIZATION_STEP_CASE", "kind": "variable", "doc": "
When the local optimization (candidates enhancing) must be performed:\n    * 'never' -- don't do local optimization\n    * 'before_select' -- before selection best N objects \n        (example: do local optimization for 5N objects and select N best results)\n    * 'after_select' -- do local optimization on best selected N objects
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Literal['before_select', 'after_select', 'never']"}, "geneticalgorithm2.population_initializer.get_population_initializer": {"fullname": "geneticalgorithm2.population_initializer.get_population_initializer", "modulename": "geneticalgorithm2.population_initializer", "qualname": "get_population_initializer", "kind": "function", "doc": "
Arguments:
\n\n
    \n
  • select_best_of:  determines population size to select 1/select_best_of best part of start population.\nFor example, for select_best_of = 4 and population_size = N there will be selected N best objects\n    from 5N generated objects (if start_generation=None dictionary).\nIf start_generation is not None dictionary, there will be selected best (start_generation) / N objects
    • \n
  • local_optimization_step:  when to perform local optimization
    • \n
  • local_optimizer:  the local optimization function (object array, its score) -> (modified array, its score)
    • \n
\n\n
Returns:
\n\n
\n  
select_best_of, population modifier
\n
\n", "signature": "(\tselect_best_of: int = 4,\tlocal_optimization_step: Literal['before_select', 'after_select', 'never'] = 'never',\tlocal_optimizer: Union[Callable[[numpy.ndarray, float], Tuple[numpy.ndarray, float]], NoneType] = None) -> Tuple[int, Callable[[numpy.ndarray, numpy.ndarray], Tuple[numpy.ndarray, numpy.ndarray]]]:", "funcdef": "def"}, "geneticalgorithm2.selections": {"fullname": "geneticalgorithm2.selections", "modulename": "geneticalgorithm2.selections", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.selections.SelectionFunc": {"fullname": "geneticalgorithm2.selections.SelectionFunc", "modulename": "geneticalgorithm2.selections", "qualname": "SelectionFunc", "kind": "variable", "doc": "
Function (scores, count to select) -> indexes of selected
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Callable[[numpy.ndarray, int], numpy.ndarray]"}, "geneticalgorithm2.selections.inverse_scores": {"fullname": "geneticalgorithm2.selections.inverse_scores", "modulename": "geneticalgorithm2.selections", "qualname": "inverse_scores", "kind": "function", "doc": "
inverses scores (min values become to max)
\n", "signature": "(scores: numpy.ndarray) -> numpy.ndarray:", "funcdef": "def"}, "geneticalgorithm2.selections.roulette": {"fullname": "geneticalgorithm2.selections.roulette", "modulename": "geneticalgorithm2.selections", "qualname": "roulette", "kind": "function", "doc": "
simplest roulette selector for which the highest score means more preferred
\n", "signature": "(scores: numpy.ndarray, parents_count: int) -> numpy.ndarray:", "funcdef": "def"}, "geneticalgorithm2.selections.Selection": {"fullname": "geneticalgorithm2.selections.Selection", "modulename": "geneticalgorithm2.selections", "qualname": "Selection", "kind": "class", "doc": "
Selections functions static class
\n\n
Selection function selects the population subset according to scores and its own rules
\n"}, "geneticalgorithm2.selections.Selection.selections_dict": {"fullname": "geneticalgorithm2.selections.Selection.selections_dict", "modulename": "geneticalgorithm2.selections", "qualname": "Selection.selections_dict", "kind": "function", "doc": "
\n", "signature": "() -> Dict[str, Callable[[numpy.ndarray, int], numpy.ndarray]]:", "funcdef": "def"}, "geneticalgorithm2.selections.Selection.fully_random": {"fullname": "geneticalgorithm2.selections.Selection.fully_random", "modulename": "geneticalgorithm2.selections", "qualname": "Selection.fully_random", "kind": "function", "doc": "
returns the selector of fully random parents (for tests purposes)
\n", "signature": "() -> Callable[[numpy.ndarray, int], numpy.ndarray]:", "funcdef": "def"}, "geneticalgorithm2.selections.Selection.roulette": {"fullname": "geneticalgorithm2.selections.Selection.roulette", "modulename": "geneticalgorithm2.selections", "qualname": "Selection.roulette", "kind": "function", "doc": "
\n", "signature": "() -> Callable[[numpy.ndarray, int], numpy.ndarray]:", "funcdef": "def"}, "geneticalgorithm2.selections.Selection.stochastic": {"fullname": "geneticalgorithm2.selections.Selection.stochastic", "modulename": "geneticalgorithm2.selections", "qualname": "Selection.stochastic", "kind": "function", "doc": "
\n", "signature": "() -> Callable[[numpy.ndarray, int], numpy.ndarray]:", "funcdef": "def"}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"fullname": "geneticalgorithm2.selections.Selection.sigma_scaling", "modulename": "geneticalgorithm2.selections", "qualname": "Selection.sigma_scaling", "kind": "function", "doc": "
\n", "signature": "(\tepsilon: float = 0.01,\tis_noisy: bool = False) -> Callable[[numpy.ndarray, int], numpy.ndarray]:", "funcdef": "def"}, "geneticalgorithm2.selections.Selection.ranking": {"fullname": "geneticalgorithm2.selections.Selection.ranking", "modulename": "geneticalgorithm2.selections", "qualname": "Selection.ranking", "kind": "function", "doc": "
\n", "signature": "() -> Callable[[numpy.ndarray, int], numpy.ndarray]:", "funcdef": "def"}, "geneticalgorithm2.selections.Selection.linear_ranking": {"fullname": "geneticalgorithm2.selections.Selection.linear_ranking", "modulename": "geneticalgorithm2.selections", "qualname": "Selection.linear_ranking", "kind": "function", "doc": "
\n", "signature": "(\tselection_pressure: float = 1.5) -> Callable[[numpy.ndarray, int], numpy.ndarray]:", "funcdef": "def"}, "geneticalgorithm2.selections.Selection.tournament": {"fullname": "geneticalgorithm2.selections.Selection.tournament", "modulename": "geneticalgorithm2.selections", "qualname": "Selection.tournament", "kind": "function", "doc": "
\n", "signature": "(tau: int = 2) -> Callable[[numpy.ndarray, int], numpy.ndarray]:", "funcdef": "def"}, "geneticalgorithm2.utils": {"fullname": "geneticalgorithm2.utils", "modulename": "geneticalgorithm2.utils", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.utils.aliases": {"fullname": "geneticalgorithm2.utils.aliases", "modulename": "geneticalgorithm2.utils.aliases", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.utils.aliases.Number": {"fullname": "geneticalgorithm2.utils.aliases.Number", "modulename": "geneticalgorithm2.utils.aliases", "qualname": "Number", "kind": "variable", "doc": "
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Union[int, float]"}, "geneticalgorithm2.utils.aliases.array1D": {"fullname": "geneticalgorithm2.utils.aliases.array1D", "modulename": "geneticalgorithm2.utils.aliases", "qualname": "array1D", "kind": "variable", "doc": "
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "<class 'numpy.ndarray'>"}, "geneticalgorithm2.utils.aliases.array2D": {"fullname": "geneticalgorithm2.utils.aliases.array2D", "modulename": "geneticalgorithm2.utils.aliases", "qualname": "array2D", "kind": "variable", "doc": "
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "<class 'numpy.ndarray'>"}, "geneticalgorithm2.utils.aliases.PathLike": {"fullname": "geneticalgorithm2.utils.aliases.PathLike", "modulename": "geneticalgorithm2.utils.aliases", "qualname": "PathLike", "kind": "variable", "doc": "
\n", "annotation": ": typing_extensions.TypeAlias", "default_value": "typing.Union[str, os.PathLike]"}, "geneticalgorithm2.utils.cache": {"fullname": "geneticalgorithm2.utils.cache", "modulename": "geneticalgorithm2.utils.cache", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.utils.cache.np_lru_cache": {"fullname": "geneticalgorithm2.utils.cache.np_lru_cache", "modulename": "geneticalgorithm2.utils.cache", "qualname": "np_lru_cache", "kind": "function", "doc": "
LRU cache implementation for functions whose FIRST parameter is a numpy array\n    forked from: https://gist.github.com/Susensio/61f4fee01150caaac1e10fc5f005eb75
\n", "signature": "(*args, **kwargs):", "funcdef": "def"}, "geneticalgorithm2.utils.files": {"fullname": "geneticalgorithm2.utils.files", "modulename": "geneticalgorithm2.utils.files", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.utils.files.mkdir_of_file": {"fullname": "geneticalgorithm2.utils.files.mkdir_of_file", "modulename": "geneticalgorithm2.utils.files", "qualname": "mkdir_of_file", "kind": "function", "doc": "
\u0434\u043b\u044f \u044d\u0442\u043e\u0433\u043e \u0444\u0430\u0439\u043b\u0430 \u0441\u043e\u0437\u0434\u0430\u0451\u0442 \u043f\u0430\u043f\u043a\u0443, \u0432 \u043a\u043e\u0442\u043e\u0440\u043e\u0439 \u043e\u043d \u0434\u043e\u043b\u0436\u0435\u043d \u043b\u0435\u0436\u0430\u0442\u044c
\n", "signature": "(file_path: Union[str, os.PathLike]):", "funcdef": "def"}, "geneticalgorithm2.utils.files.mkdir": {"fullname": "geneticalgorithm2.utils.files.mkdir", "modulename": "geneticalgorithm2.utils.files", "qualname": "mkdir", "kind": "function", "doc": "
mkdir with parents
\n", "signature": "(path: Union[str, os.PathLike]):", "funcdef": "def"}, "geneticalgorithm2.utils.files.touch": {"fullname": "geneticalgorithm2.utils.files.touch", "modulename": "geneticalgorithm2.utils.files", "qualname": "touch", "kind": "function", "doc": "
makes empty file, makes directories for this file automatically
\n", "signature": "(path: Union[str, os.PathLike]):", "funcdef": "def"}, "geneticalgorithm2.utils.funcs": {"fullname": "geneticalgorithm2.utils.funcs", "modulename": "geneticalgorithm2.utils.funcs", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.utils.funcs.fast_min": {"fullname": "geneticalgorithm2.utils.funcs.fast_min", "modulename": "geneticalgorithm2.utils.funcs", "qualname": "fast_min", "kind": "function", "doc": "
1.5 times faster than row min(a, b)
\n", "signature": "(a, b):", "funcdef": "def"}, "geneticalgorithm2.utils.funcs.fast_max": {"fullname": "geneticalgorithm2.utils.funcs.fast_max", "modulename": "geneticalgorithm2.utils.funcs", "qualname": "fast_max", "kind": "function", "doc": "
\n", "signature": "(a, b):", "funcdef": "def"}, "geneticalgorithm2.utils.funcs.can_be_prob": {"fullname": "geneticalgorithm2.utils.funcs.can_be_prob", "modulename": "geneticalgorithm2.utils.funcs", "qualname": "can_be_prob", "kind": "function", "doc": "
\n", "signature": "(value: float) -> bool:", "funcdef": "def"}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"fullname": "geneticalgorithm2.utils.funcs.is_current_gen_number", "modulename": "geneticalgorithm2.utils.funcs", "qualname": "is_current_gen_number", "kind": "function", "doc": "
\n", "signature": "(number: Union[int, NoneType]):", "funcdef": "def"}, "geneticalgorithm2.utils.funcs.is_numpy": {"fullname": "geneticalgorithm2.utils.funcs.is_numpy", "modulename": "geneticalgorithm2.utils.funcs", "qualname": "is_numpy", "kind": "function", "doc": "
\n", "signature": "(arg: Any):", "funcdef": "def"}, "geneticalgorithm2.utils.funcs.split_matrix": {"fullname": "geneticalgorithm2.utils.funcs.split_matrix", "modulename": "geneticalgorithm2.utils.funcs", "qualname": "split_matrix", "kind": "function", "doc": "
splits wide pop matrix to variables and scores
\n", "signature": "(mat: numpy.ndarray) -> Tuple[numpy.ndarray, numpy.ndarray]:", "funcdef": "def"}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"fullname": "geneticalgorithm2.utils.funcs.union_to_matrix", "modulename": "geneticalgorithm2.utils.funcs", "qualname": "union_to_matrix", "kind": "function", "doc": "
union variables and scores to wide pop matrix
\n", "signature": "(variables_2D: numpy.ndarray, scores_1D: numpy.ndarray) -> numpy.ndarray:", "funcdef": "def"}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"fullname": "geneticalgorithm2.utils.funcs.random_indexes_pair", "modulename": "geneticalgorithm2.utils.funcs", "qualname": "random_indexes_pair", "kind": "function", "doc": "
works 3 times faster than random.sample(range(seq_len), 2)
\n", "signature": "(seq_len: int) -> Tuple[int, int]:", "funcdef": "def"}, "geneticalgorithm2.utils.plotting": {"fullname": "geneticalgorithm2.utils.plotting", "modulename": "geneticalgorithm2.utils.plotting", "kind": "module", "doc": "
\n"}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"fullname": "geneticalgorithm2.utils.plotting.plot_several_lines", "modulename": "geneticalgorithm2.utils.plotting", "qualname": "plot_several_lines", "kind": "function", "doc": "
\n", "signature": "(\tlines: Sequence[Sequence[float]],\tcolors: Sequence[str],\tlabels: Union[Sequence[str], NoneType] = None,\tlinewidths: Union[Sequence[int], NoneType] = None,\ttitle: str = '',\txlabel: str = 'Generation',\tylabel: str = 'Minimized function',\tsave_as: Union[str, os.PathLike, NoneType] = None,\tdpi: int = 200):", "funcdef": "def"}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"fullname": "geneticalgorithm2.utils.plotting.plot_pop_scores", "modulename": "geneticalgorithm2.utils.plotting", "qualname": "plot_pop_scores", "kind": "function", "doc": "
plots scores (numeric values) as sorted bars
\n", "signature": "(\tscores: Sequence[float],\ttitle: str = 'Population scores',\tsave_as: Union[str, NoneType] = None):", "funcdef": "def"}}, "docInfo": {"geneticalgorithm2": {"qualname": 0, "fullname": 1, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 45}, "geneticalgorithm2.geneticalgorithm2": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.Population_initializer": {"qualname": 2, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 210, "bases": 0, "doc": 117}, "geneticalgorithm2.callbacks": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 5, "doc": 8}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 363, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"qualname": 4, "fullname": 7, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"qualname": 3, "fullname": 6, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"qualname": 4, "fullname": 7, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"qualname": 2, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"qualname": 3, "fullname": 6, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"qualname": 2, "fullname": 5, "annotation": 9, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"qualname": 2, "fullname": 5, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"qualname": 3, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"qualname": 3, "fullname": 6, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"qualname": 1, "fullname": 4, "annotation": 4, "default_value": 9, "signature": 0, "bases": 0, "doc": 29}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"qualname": 1, "fullname": 4, "annotation": 4, "default_value": 6, "signature": 0, "bases": 0, "doc": 17}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"qualname": 1, "fullname": 4, "annotation": 4, "default_value": 9, "signature": 0, "bases": 0, "doc": 16}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"qualname": 1, "fullname": 4, "annotation": 4, "default_value": 11, "signature": 0, "bases": 0, "doc": 48}, "geneticalgorithm2.callbacks.middle": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.middle.Actions": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 10}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 77, "bases": 0, "doc": 4}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 71, "bases": 0, "doc": 8}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 115, "bases": 0, "doc": 5}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 95, "bases": 0, "doc": 6}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 123, "bases": 0, "doc": 6}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 192, "bases": 0, "doc": 87}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 69, "bases": 0, "doc": 15}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 173, "bases": 0, "doc": 16}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 10}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 55, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 37, "bases": 0, "doc": 6}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 55, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 78, "bases": 0, "doc": 10}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 78, "bases": 0, "doc": 11}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 8}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 173, "bases": 0, "doc": 53}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 141, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 82, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.simple": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.simple.Callbacks": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 9}, "geneticalgorithm2.callbacks.simple.Callbacks.NoneCallback": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 7, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 124, "bases": 0, "doc": 7}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 165, "bases": 0, "doc": 53}, "geneticalgorithm2.crossovers": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.CrossoverFunc": {"qualname": 1, "fullname": 3, "annotation": 4, "default_value": 10, "signature": 0, "bases": 0, "doc": 9}, "geneticalgorithm2.crossovers.get_copies": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 63, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 20}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 68, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.one_point": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.two_point": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.uniform": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.segment": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 76, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 75, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.mixed": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 76, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.algorithm_params": {"qualname": 0, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 5, "doc": 6}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 471, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"qualname": 4, "fullname": 9, "annotation": 3, "default_value": 1, "signature": 0, "bases": 0, "doc": 70}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"qualname": 5, "fullname": 10, "annotation": 3, "default_value": 1, "signature": 0, "bases": 0, "doc": 46}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 11}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 2, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"qualname": 4, "fullname": 9, "annotation": 3, "default_value": 1, "signature": 0, "bases": 0, "doc": 46}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"qualname": 3, "fullname": 8, "annotation": 3, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 2, "signature": 0, "bases": 0, "doc": 58}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 2, "signature": 0, "bases": 0, "doc": 17}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"qualname": 3, "fullname": 8, "annotation": 10, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"qualname": 3, "fullname": 8, "annotation": 6, "default_value": 7, "signature": 0, "bases": 0, "doc": 7}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"qualname": 4, "fullname": 9, "annotation": 6, "default_value": 6, "signature": 0, "bases": 0, "doc": 7}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"qualname": 3, "fullname": 8, "annotation": 7, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 14, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"qualname": 4, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 155, "bases": 0, "doc": 18}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 33, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 28, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.aliases": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"qualname": 1, "fullname": 5, "annotation": 4, "default_value": 4, "signature": 0, "bases": 0, "doc": 9}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"qualname": 1, "fullname": 5, "annotation": 4, "default_value": 5, "signature": 0, "bases": 0, "doc": 65}, "geneticalgorithm2.data_types.base": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.base.DictLikeGetSet": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.generation": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"qualname": 1, "fullname": 5, "annotation": 4, "default_value": 29, "signature": 0, "bases": 0, "doc": 37}, "geneticalgorithm2.data_types.generation.Generation": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 5, "doc": 15}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 74, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.generation.Generation.variables": {"qualname": 2, "fullname": 6, "annotation": 4, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.generation.Generation.scores": {"qualname": 2, "fullname": 6, "annotation": 4, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.generation.Generation.size": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"qualname": 3, "fullname": 7, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 19, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.generation.Generation.save": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.generation.Generation.load": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 33, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 152, "bases": 0, "doc": 4}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 21, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.result": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.result.GAResult": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 5, "doc": 3}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 31, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"qualname": 3, "fullname": 7, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.result.GAResult.variable": {"qualname": 2, "fullname": 6, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.result.GAResult.score": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.result.GAResult.function": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"qualname": 2, "fullname": 4, "annotation": 4, "default_value": 12, "signature": 0, "bases": 0, "doc": 32}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 6}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 483, "bases": 0, "doc": 276}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 57, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 10}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.output_dict": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"qualname": 3, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 7}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.revolution_oppositor": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dup_oppositor": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.creator": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.init_oppositors": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"qualname": 2, "fullname": 4, "annotation": 4, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.funtimeout": {"qualname": 2, "fullname": 4, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"qualname": 3, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"qualname": 3, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"qualname": 3, "fullname": 5, "annotation": 5, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size": {"qualname": 3, "fullname": 5, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.progress_stream": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.param": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dim": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"qualname": 3, "fullname": 5, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 22}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 1142, "bases": 0, "doc": 517}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 107, "bases": 0, "doc": 11}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 67, "bases": 0, "doc": 9}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 4}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 56, "bases": 0, "doc": 6}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 35, "bases": 0, "doc": 18}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 35, "bases": 0, "doc": 24}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 56, "bases": 0, "doc": 20}, "geneticalgorithm2.mutations": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.mutations.MutationFloatFunc": {"qualname": 1, "fullname": 3, "annotation": 4, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.mutations.MutationIntFunc": {"qualname": 1, "fullname": 3, "annotation": 4, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.mutations.MutationFunc": {"qualname": 1, "fullname": 3, "annotation": 4, "default_value": 11, "signature": 0, "bases": 0, "doc": 21}, "geneticalgorithm2.mutations.Mutations": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 19}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 44, "bases": 0, "doc": 3}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 44, "bases": 0, "doc": 3}, "geneticalgorithm2.mutations.Mutations.uniform_by_x": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 34, "bases": 0, "doc": 3}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 34, "bases": 0, "doc": 3}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 51, "bases": 0, "doc": 14}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 51, "bases": 0, "doc": 15}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 34, "bases": 0, "doc": 3}, "geneticalgorithm2.population_initializer": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.population_initializer.PopulationModifier": {"qualname": 1, "fullname": 4, "annotation": 4, "default_value": 10, "signature": 0, "bases": 0, "doc": 25}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"qualname": 4, "fullname": 7, "annotation": 4, "default_value": 14, "signature": 0, "bases": 0, "doc": 49}, "geneticalgorithm2.population_initializer.get_population_initializer": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 210, "bases": 0, "doc": 117}, "geneticalgorithm2.selections": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.SelectionFunc": {"qualname": 1, "fullname": 3, "annotation": 4, "default_value": 6, "signature": 0, "bases": 0, "doc": 11}, "geneticalgorithm2.selections.inverse_scores": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 10}, "geneticalgorithm2.selections.roulette": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 40, "bases": 0, "doc": 13}, "geneticalgorithm2.selections.Selection": {"qualname": 1, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 21}, "geneticalgorithm2.selections.Selection.selections_dict": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 48, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.fully_random": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 13}, "geneticalgorithm2.selections.Selection.roulette": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.stochastic": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 75, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.ranking": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.linear_ranking": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 57, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.tournament": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 54, "bases": 0, "doc": 3}, "geneticalgorithm2.utils": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.aliases": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.aliases.Number": {"qualname": 1, "fullname": 4, "annotation": 4, "default_value": 3, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.aliases.array1D": {"qualname": 1, "fullname": 4, "annotation": 4, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.aliases.array2D": {"qualname": 1, "fullname": 4, "annotation": 4, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.aliases.PathLike": {"qualname": 1, "fullname": 4, "annotation": 4, "default_value": 4, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.cache": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.cache.np_lru_cache": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 21}, "geneticalgorithm2.utils.files": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.files.mkdir_of_file": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 34, "bases": 0, "doc": 12}, "geneticalgorithm2.utils.files.mkdir": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 33, "bases": 0, "doc": 5}, "geneticalgorithm2.utils.files.touch": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 33, "bases": 0, "doc": 11}, "geneticalgorithm2.utils.funcs": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.funcs.fast_min": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 12}, "geneticalgorithm2.utils.funcs.fast_max": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.funcs.can_be_prob": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 19, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 28, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.funcs.is_numpy": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.funcs.split_matrix": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 10}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 10}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 32, "bases": 0, "doc": 16}, "geneticalgorithm2.utils.plotting": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 238, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 77, "bases": 0, "doc": 9}}, "length": 194, "save": true}, "index": {"qualname": {"root": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 5, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"2": {"docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.output_dict": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.revolution_oppositor": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dup_oppositor": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.creator": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.init_oppositors": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.funtimeout": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.progress_stream": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.param": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dim": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 31}, "docs": {}, "df": 0}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}}, "df": 15, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "t": {"docs": {"geneticalgorithm2.crossovers.get_copies": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 4}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.result.GAResult": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.score": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.function": {"tf": 1}}, "df": 6}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 2}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 2, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 4, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete": {"tf": 1}, "geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}}, "df": 5, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}}, "df": 3}}}}}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.progress_stream": {"tf": 1}}, "df": 2}}}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.param": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 4, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.init_oppositors": {"tf": 1}}, "df": 6, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}}}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.selections.inverse_scores": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 2}}}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {"geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_numpy": {"tf": 1}}, "df": 2}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}}, "df": 1, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}}, "df": 17}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}}, "df": 1}}}}}}}}}}, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}}, "df": 4}}}}}}}}}}}}}, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}}, "df": 1}}}, "n": {"docs": {"geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}}, "df": 4, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}}, "df": 9, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1}}, "df": 1}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.mutations.MutationFunc": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {"geneticalgorithm2.mutations.Mutations": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"tf": 1}}, "df": 8}}}}}}}, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 1}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "x": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_max": {"tf": 1}}, "df": 4}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {"geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 4}}}}}, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}}, "df": 2}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}}, "df": 1}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "v": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.revolution_oppositor": {"tf": 1}}, "df": 1}}}}}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 2}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 2}}}, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.selections.Selection.ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}}, "df": 2}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.selections.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 1}}, "df": 2}}}}}}}}, "t": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 2, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.selections.Selection.tournament": {"tf": 1}}, "df": 1}}}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {"geneticalgorithm2.utils.files.touch": {"tf": 1}}, "df": 1}}}}, "w": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 1}}, "df": 1}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}}, "df": 5}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}}, "df": 2}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.selections.Selection.stochastic": {"tf": 1}}, "df": 1}}}}}}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1}}, "df": 2}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.progress_stream": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.selections.Selection": {"tf": 1}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection.stochastic": {"tf": 1}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}, "geneticalgorithm2.selections.Selection.ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.tournament": {"tf": 1}}, "df": 11, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.selections.SelectionFunc": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {"geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 5, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "g": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}}, "df": 1}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "z": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size": {"tf": 1}}, "df": 4}}, "g": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}}, "df": 1, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "h": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 1}}, "df": 1}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.result.GAResult.score": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 4}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}}, "df": 1}}, "s": {"docs": {"geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "u": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}}, "df": 3}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}}, "df": 13, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {"geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.creator": {"tf": 1}}, "df": 1}}}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}}, "df": 1}}}}}}}}}, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.crossovers.get_copies": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.NoneCallback": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 4}}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}}, "n": {"docs": {"geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}}, "df": 1}}, "m": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 2}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"tf": 1}}, "df": 7}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.output_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 1}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1}}, "df": 6, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.base.DictLikeGetSet": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 1}}, "df": 2}}}}}}}}}}}}, "m": {"docs": {"geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dim": {"tf": 1}}, "df": 2}}, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}}, "df": 2}}}}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dup_oppositor": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 2}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}}, "df": 1}}}}}}}, "f": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1}}, "df": 1, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 6, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}}, "df": 1}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.funtimeout": {"tf": 1}}, "df": 1}}}}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}}, "df": 3}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 1}, "e": {"docs": {"geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_max": {"tf": 1}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}}, "df": 9}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}}, "df": 6}}}}}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}}, "df": 1}, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}}, "df": 18}}}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"1": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.utils.aliases.array1D": {"tf": 1}}, "df": 1}}, "2": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.utils.aliases.array2D": {"tf": 1}}, "df": 1}}, "docs": {}, "df": 0}}}}, "s": {"docs": {"geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"tf": 1}}, "df": 5}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.NoneCallback": {"tf": 1}}, "df": 1}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 1, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.utils.aliases.Number": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}}, "df": 2}}}, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.utils.funcs.is_numpy": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 1}}, "df": 1}}, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.output_dict": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.revolution_oppositor": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dup_oppositor": {"tf": 1}}, "df": 2, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.init_oppositors": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}}}}}}}}}, "f": {"docs": {"geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}}, "df": 1}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}}, "df": 2, "s": {"docs": {"geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}}, "df": 1}}}}}}}}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"tf": 1}}, "df": 1}}}}}, "y": {"docs": {"geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 4}, "e": {"docs": {"geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}}, "df": 1}}, "x": {"docs": {"geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}}, "df": 2}}}, "fullname": {"root": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 5, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"2": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2": {"tf": 1.4142135623730951}, "geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks": {"tf": 1}, "geneticalgorithm2.callbacks.data": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}, "geneticalgorithm2.callbacks.simple": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.NoneCallback": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.crossovers": {"tf": 1}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}, "geneticalgorithm2.crossovers.get_copies": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}, "geneticalgorithm2.data_types": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}, "geneticalgorithm2.data_types.aliases": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.base": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 1}, "geneticalgorithm2.data_types.generation": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}, "geneticalgorithm2.data_types.result": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.score": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.output_dict": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.revolution_oppositor": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dup_oppositor": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.creator": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.init_oppositors": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.funtimeout": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.progress_stream": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.param": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dim": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations": {"tf": 1}, "geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}, "geneticalgorithm2.mutations.Mutations": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"tf": 1}, "geneticalgorithm2.population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}, "geneticalgorithm2.selections": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1}, "geneticalgorithm2.selections.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection": {"tf": 1}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection.stochastic": {"tf": 1}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}, "geneticalgorithm2.selections.Selection.ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.tournament": {"tf": 1}, "geneticalgorithm2.utils": {"tf": 1}, "geneticalgorithm2.utils.aliases": {"tf": 1}, "geneticalgorithm2.utils.aliases.Number": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}, "geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}, "geneticalgorithm2.utils.cache": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}, "geneticalgorithm2.utils.files": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1}, "geneticalgorithm2.utils.funcs": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_max": {"tf": 1}, "geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_numpy": {"tf": 1}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}, "geneticalgorithm2.utils.plotting": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 194}, "docs": {}, "df": 0}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1}, "geneticalgorithm2.data_types.generation": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.size": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}}, "df": 17, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "t": {"docs": {"geneticalgorithm2.crossovers.get_copies": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 4}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.result.GAResult": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.score": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.function": {"tf": 1}}, "df": 6}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 2}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 2, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size": {"tf": 1}, "geneticalgorithm2.population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 7, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete": {"tf": 1}, "geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}}, "df": 5, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}}, "df": 3}}}}}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.progress_stream": {"tf": 1}}, "df": 2}}}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.param": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 20}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 4, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.utils.plotting": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 3}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.init_oppositors": {"tf": 1}}, "df": 6, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 5}}}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.selections.inverse_scores": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 2}}}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {"geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_numpy": {"tf": 1}}, "df": 2}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks": {"tf": 1}, "geneticalgorithm2.callbacks.data": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}, "geneticalgorithm2.callbacks.simple": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.NoneCallback": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1.4142135623730951}}, "df": 48}}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.utils.cache": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1.4142135623730951}}, "df": 2}}}, "n": {"docs": {"geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}}, "df": 3}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}}, "df": 13, "s": {"docs": {"geneticalgorithm2.crossovers": {"tf": 1}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}, "geneticalgorithm2.crossovers.get_copies": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1.4142135623730951}, "geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}}, "df": 13}, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}}, "df": 1}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.creator": {"tf": 1}}, "df": 1}}}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}}, "df": 1}}}}}}}}}, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.crossovers.get_copies": {"tf": 1}}, "df": 1}}}}}, "m": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 2}}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.callbacks.data": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.data_types": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}, "geneticalgorithm2.data_types.aliases": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.base": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 1}, "geneticalgorithm2.data_types.generation": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}, "geneticalgorithm2.data_types.result": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.score": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.function": {"tf": 1}}, "df": 68}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"tf": 1}}, "df": 7}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.output_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 1}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1}}, "df": 6, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.base.DictLikeGetSet": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 1}}, "df": 2}}}}}}}}}}}}, "m": {"docs": {"geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dim": {"tf": 1}}, "df": 2}}, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}}, "df": 2}}}}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dup_oppositor": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}}, "df": 21, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}}, "df": 17}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}}, "df": 1}}}}}}}}}}, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}}, "df": 4}}}}}}}}}}}}}, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}}, "df": 1}}}, "n": {"docs": {"geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}}, "df": 4, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}}, "df": 9, "s": {"docs": {"geneticalgorithm2.mutations": {"tf": 1}, "geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}, "geneticalgorithm2.mutations.Mutations": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"tf": 1.4142135623730951}}, "df": 12}, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1}}, "df": 1}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.mutations.MutationFunc": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 1}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "x": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_max": {"tf": 1}}, "df": 4}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {"geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 4}}}}}, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}}, "df": 2}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}}, "df": 1}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.result": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.score": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.function": {"tf": 1}}, "df": 7, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}}, "df": 1}}}}}, "v": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.revolution_oppositor": {"tf": 1}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 2}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 2}}}, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.selections.Selection.ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}}, "df": 2}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.selections.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 1}}, "df": 2}}}}}}}}, "t": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 2, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.selections.Selection.tournament": {"tf": 1}}, "df": 1}}}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {"geneticalgorithm2.utils.files.touch": {"tf": 1}}, "df": 1}}}}, "w": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 1}}, "df": 1}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}}, "df": 5, "s": {"docs": {"geneticalgorithm2.data_types": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}, "geneticalgorithm2.data_types.aliases": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.base": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 1}, "geneticalgorithm2.data_types.generation": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}, "geneticalgorithm2.data_types.result": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.score": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.function": {"tf": 1}}, "df": 46}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}}, "df": 2}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.selections.Selection.stochastic": {"tf": 1}}, "df": 1}}}}}}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1}}, "df": 2}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.progress_stream": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.selections.Selection": {"tf": 1}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection.stochastic": {"tf": 1}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}, "geneticalgorithm2.selections.Selection.ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.tournament": {"tf": 1}}, "df": 11, "s": {"docs": {"geneticalgorithm2.selections": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1}, "geneticalgorithm2.selections.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection": {"tf": 1}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection.stochastic": {"tf": 1}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}, "geneticalgorithm2.selections.Selection.ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.tournament": {"tf": 1}}, "df": 13}, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.selections.SelectionFunc": {"tf": 1}}, "df": 1}}}}}}}}}}}, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 5, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "g": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}}, "df": 1}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.simple": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.NoneCallback": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 5, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "z": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size": {"tf": 1}}, "df": 4}}, "g": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}}, "df": 1, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "h": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 1}}, "df": 1}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.result.GAResult.score": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 4}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}}, "df": 1}}, "s": {"docs": {"geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "u": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 2}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}}, "df": 1}}}}}}}, "f": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1}}, "df": 1, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 6, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.utils.funcs": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_max": {"tf": 1}, "geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_numpy": {"tf": 1}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 10}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.funtimeout": {"tf": 1}}, "df": 1}}}}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}}, "df": 3}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 1}, "e": {"docs": {"geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.utils.files": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1}}, "df": 4}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_max": {"tf": 1}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}}, "df": 9}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}}, "df": 6}}}}}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}}, "df": 1}, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.data_types.algorithm_params": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}}, "df": 19, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}}, "df": 18}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.aliases": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.utils.aliases": {"tf": 1}, "geneticalgorithm2.utils.aliases.Number": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}, "geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}}, "df": 8}}}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"1": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.utils.aliases.array1D": {"tf": 1}}, "df": 1}}, "2": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.utils.aliases.array2D": {"tf": 1}}, "df": 1}}, "docs": {}, "df": 0}}}}, "s": {"docs": {"geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"tf": 1}}, "df": 5}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.utils": {"tf": 1}, "geneticalgorithm2.utils.aliases": {"tf": 1}, "geneticalgorithm2.utils.aliases.Number": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}, "geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}, "geneticalgorithm2.utils.cache": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}, "geneticalgorithm2.utils.files": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1}, "geneticalgorithm2.utils.funcs": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_max": {"tf": 1}, "geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_numpy": {"tf": 1}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}, "geneticalgorithm2.utils.plotting": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 24}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.NoneCallback": {"tf": 1}}, "df": 1}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 1, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.utils.aliases.Number": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}}, "df": 2}}}, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.utils.funcs.is_numpy": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 1}}, "df": 1}}, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.output_dict": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.revolution_oppositor": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dup_oppositor": {"tf": 1}}, "df": 2, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.init_oppositors": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}}}}}}}}}, "f": {"docs": {"geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}}, "df": 1}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}}, "df": 2, "s": {"docs": {"geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}}, "df": 1}}}}}}}}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.base": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 1}}, "df": 3}}, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"tf": 1}}, "df": 1}}}}}, "y": {"docs": {"geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 4}, "e": {"docs": {"geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}}, "df": 1}}, "x": {"docs": {"geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}}, "df": 2}}}, "annotation": {"root": {"docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.score": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.funtimeout": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}, "geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.utils.aliases.Number": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}, "geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}}, "df": 62, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.utils.aliases.Number": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}, "geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}}, "df": 20}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.utils.aliases.Number": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}, "geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}}, "df": 20}}}}}, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}}, "df": 2}}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}}, "df": 2}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.utils.aliases.Number": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}, "geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}}, "df": 20}}}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}}, "df": 5}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"tf": 1}}, "df": 3}}}, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}}, "df": 2}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1}}, "df": 2}}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1.4142135623730951}}, "df": 9}}}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 2}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 2}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 12}}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1}}, "df": 7}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"2": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1}}, "df": 2}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.size": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 12}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.result.GAResult.score": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.funtimeout": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"tf": 1.4142135623730951}}, "df": 13}}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}}, "df": 2}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}}, "df": 8}}}}}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}}, "df": 1}}}}}}, "default_value": {"root": {"0": {"4": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 2}, "docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1.7320508075688772}}, "df": 4}, "1": {"0": {"0": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 2}, "2": {"0": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "3": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 2}, "docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1.4142135623730951}}, "df": 11, "l": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}}, "df": 3}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 3}}}}}}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}}, "df": 3}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}}, "df": 3}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"2": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}}, "df": 3}, "docs": {}, "df": 0}}}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}}, "df": 5}}}}}, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}}, "df": 2}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.4142135623730951}}, "df": 3}}}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 2}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}, "x": {"2": {"7": {"docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 2.449489742783178}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 2.449489742783178}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 2.8284271247461903}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 2.449489742783178}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1.4142135623730951}}, "df": 11}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"2": {"docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1}}}}}}}}}, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}}, "df": 3}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.utils.aliases.Number": {"tf": 1}, "geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}}, "df": 17}}}, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 2}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"2": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}}}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}}, "df": 2}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}}, "df": 8}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 2}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 2}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 2}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}}, "df": 9}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 2}}, "df": 7, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.4142135623730951}}, "df": 3}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1.7320508075688772}}, "df": 2}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.4142135623730951}}, "df": 3}}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "x": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1.4142135623730951}}, "df": 1}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 2}}, "df": 1}}}}}}}}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}}, "df": 3}}}, "y": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 2}, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1.7320508075688772}}, "df": 4}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1}}}}}}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.mutations.MutationFunc": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.utils.aliases.Number": {"tf": 1}}, "df": 1}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 2}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1}}}}}, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.aliases.Number": {"tf": 1}}, "df": 4}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1.4142135623730951}}, "df": 1, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1}}}}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 2}}}}}}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1.7320508075688772}}, "df": 1}}}}}}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}}, "df": 1}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1.7320508075688772}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}}, "df": 4}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1}}}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}}, "df": 1}}}}, "signature": {"root": {"0": {"0": {"5": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "1": {"docs": {"geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}}, "df": 1}, "4": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}, "docs": {"geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1.4142135623730951}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}}, "df": 10}, "1": {"0": {"0": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}, "docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}}, "df": 2}, "docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}}, "df": 5, "d": {"docs": {"geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 1}}, "2": {"0": {"0": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "docs": {"geneticalgorithm2.selections.Selection.tournament": {"tf": 1}}, "df": 1, "d": {"docs": {"geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 1}}, "3": {"9": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 2.8284271247461903}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 2}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2.8284271247461903}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 4.69041575982343}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.449489742783178}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 2.8284271247461903}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 2.449489742783178}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1.4142135623730951}}, "df": 13}, "docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 5}, "4": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}, "5": {"0": {"0": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}}, "df": 1}, "docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 4}, "docs": {"geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}}, "df": 2}, "6": {"docs": {"geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}}, "df": 1}, "7": {"docs": {"geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}}, "df": 1}, "9": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}}, "df": 2}, "docs": {"geneticalgorithm2.Population_initializer": {"tf": 12.727922061357855}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 16.911534525287763}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 7.681145747868608}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 7.54983443527075}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 9.643650760992955}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 8.774964387392123}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 10}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 12.569805089976535}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 7.483314773547883}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 11.661903789690601}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 6.708203932499369}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 5.5677643628300215}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 6.708203932499369}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 8}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 8}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 11.789826122551595}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 10.488088481701515}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 8.06225774829855}, "geneticalgorithm2.callbacks.simple.Callbacks.NoneCallback": {"tf": 2.6457513110645907}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 9.9498743710662}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 11.445523142259598}, "geneticalgorithm2.crossovers.get_copies": {"tf": 7.211102550927978}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 7.483314773547883}, "geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 6.928203230275509}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 6.928203230275509}, "geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 6.928203230275509}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 7.874007874011811}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 6.928203230275509}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 7.874007874011811}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 6.928203230275509}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 7.874007874011811}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 19.131126469708992}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 3.4641016151377544}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 11.269427669584644}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 5.291502622129181}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 4.898979485566356}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 3.7416573867739413}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 7.874007874011811}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 4}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 5.656854249492381}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 5.291502622129181}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 11}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 4.242640687119285}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 4.898979485566356}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 18.920887928424502}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 30.066592756745816}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 9.219544457292887}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 7.280109889280518}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 4.69041575982343}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 6.782329983125268}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 5.291502622129181}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 5.291502622129181}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 6.708203932499369}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"tf": 6.082762530298219}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 6.082762530298219}, "geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 5.385164807134504}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 5.385164807134504}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 6.48074069840786}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 6.48074069840786}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"tf": 5.385164807134504}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 12.727922061357855}, "geneticalgorithm2.selections.inverse_scores": {"tf": 4.898979485566356}, "geneticalgorithm2.selections.roulette": {"tf": 5.656854249492381}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 6.324555320336759}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 5.656854249492381}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 5.656854249492381}, "geneticalgorithm2.selections.Selection.stochastic": {"tf": 5.656854249492381}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 7.810249675906654}, "geneticalgorithm2.selections.Selection.ranking": {"tf": 5.656854249492381}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 6.782329983125268}, "geneticalgorithm2.selections.Selection.tournament": {"tf": 6.708203932499369}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 4.242640687119285}, "geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 5.291502622129181}, "geneticalgorithm2.utils.files.mkdir": {"tf": 5.291502622129181}, "geneticalgorithm2.utils.files.touch": {"tf": 5.291502622129181}, "geneticalgorithm2.utils.funcs.fast_min": {"tf": 3.7416573867739413}, "geneticalgorithm2.utils.funcs.fast_max": {"tf": 3.7416573867739413}, "geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 4}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 4.898979485566356}, "geneticalgorithm2.utils.funcs.is_numpy": {"tf": 3.7416573867739413}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 6.164414002968976}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 6}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 5.0990195135927845}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 13.892443989449804}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 7.874007874011811}}, "df": 85, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.7320508075688772}}, "df": 2, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}}, "df": 4, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}}, "df": 1}}}}}}}, "f": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}}, "df": 11}}, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 6}, "q": {"docs": {"geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 1, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 2.23606797749979}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 10}}}}}}, "c": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 7}}, "o": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1.7320508075688772}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 1}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 2.449489742783178}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1.4142135623730951}}, "df": 24, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3}}}}}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 8}}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1}, "geneticalgorithm2.selections.roulette": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1.4142135623730951}}, "df": 8}}}}}, "d": {"docs": {"geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 2}}, "b": {"docs": {"geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_max": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}}}}}, "y": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 4}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.449489742783178}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}, "geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}}, "df": 13}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1}}, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "f": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 8}, "b": {"docs": {}, "df": 0, "j": {"docs": {"geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 2.8284271247461903}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 2}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1.4142135623730951}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2.8284271247461903}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 2.23606797749979}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.449489742783178}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 2}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"tf": 2}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection.stochastic": {"tf": 1}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}, "geneticalgorithm2.selections.Selection.ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.tournament": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1.4142135623730951}}, "df": 35}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 2}}}}, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}, "m": {"docs": {"geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}}}}}, "s": {"docs": {"geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 2, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 5}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 4}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 1}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}}, "df": 4}}, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}}, "df": 1}}}}, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2}, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 1}}}, "a": {"docs": {"geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_max": {"tf": 1}}, "df": 2, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 4}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}}, "df": 3}}}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 6}, "l": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}}, "df": 1}}}, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}}, "df": 2, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_numpy": {"tf": 1}}, "df": 4}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.utils.funcs.is_numpy": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 2}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 2.449489742783178}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 2.8284271247461903}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 2}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 2.23606797749979}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1.4142135623730951}, "geneticalgorithm2.crossovers.get_copies": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 2}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2.449489742783178}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 2.449489742783178}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 2}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 4.47213595499958}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 2.449489742783178}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.roulette": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.stochastic": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.ranking": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.tournament": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1.7320508075688772}}, "df": 43}}, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 2.449489742783178}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 2.8284271247461903}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 2}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 2.23606797749979}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1.4142135623730951}, "geneticalgorithm2.crossovers.get_copies": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 2}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2.449489742783178}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 2.449489742783178}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 2}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 4.47213595499958}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 2.449489742783178}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.roulette": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.stochastic": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.ranking": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.tournament": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1.7320508075688772}}, "df": 43}}}}}}, "o": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "n": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2.8284271247461903}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 4.242640687119285}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 13, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 4.242640687119285}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 17}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}}, "df": 2}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2.8284271247461903}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 4.242640687119285}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 23}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}}, "df": 2}}}}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 2.23606797749979}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 2}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection.stochastic": {"tf": 1}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}, "geneticalgorithm2.selections.Selection.ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}, "geneticalgorithm2.selections.Selection.tournament": {"tf": 1}}, "df": 52}}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}}, "df": 2, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 2}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 2.23606797749979}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}}, "df": 17}}}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 3, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}}}}, "o": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}}, "df": 2}}, "n": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}}, "df": 1}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}}, "df": 2}}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}}, "df": 2, "s": {"docs": {"geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}}}}}}, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 3}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 2}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.449489742783178}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"tf": 2}, "geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 2}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 2}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 2.23606797749979}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 2.23606797749979}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}, "geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 26}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.23606797749979}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 8}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 4}, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}}, "df": 3}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.23606797749979}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}}, "df": 3}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}, "geneticalgorithm2.crossovers.get_copies": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 24}}}}, "o": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2.449489742783178}}, "df": 2, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 5}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 5}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "u": {"docs": {"geneticalgorithm2.selections.Selection.tournament": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}}, "df": 2}}}, "l": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 1}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 2}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1.4142135623730951}}, "df": 2}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 3}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}}}}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 2}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.449489742783178}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 8, "s": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}}, "df": 2}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"2": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 2}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 2.23606797749979}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}}, "df": 21}, "docs": {}, "df": 0}}}}}}}}}}}}}}, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "t": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 2}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 2.449489742783178}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}}, "df": 21}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}}, "df": 3}}}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 1}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1}}, "df": 9}}, "m": {"docs": {"geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1}}, "df": 2}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}, "p": {"docs": {}, "df": 0, "i": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 2}}}, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 2}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 5, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}}, "df": 1}}}}}}}}, "a": {"docs": {}, "df": 0, "x": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 3}, "i": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}}, "df": 2}}, "t": {"docs": {"geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 2}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 2.23606797749979}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 17}}}}}}}}}}}}}}}}, "n": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 1}}}}}}}, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}, "p": {"1": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}}, "df": 1}, "2": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1}}, "df": 2, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}}, "df": 2}}}}}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 2}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 5}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1.4142135623730951}}, "df": 1}}}}, "h": {"docs": {"geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1}}, "df": 5, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 8}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 3}}}}}, "p": {"docs": {"geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1}}, "df": 1, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 6}}}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 3}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1.4142135623730951}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1}}, "df": 1}}}}}}}, "x": {"docs": {"geneticalgorithm2.crossovers.get_copies": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}}, "df": 3, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 1}}}}}}, "y": {"docs": {"geneticalgorithm2.crossovers.get_copies": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 1}}}}}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}}, "df": 1, "s": {"docs": {"geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 3}}}}}}}, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1}}, "df": 1}}}}}, "j": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 1}}}}, "k": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}}}}}}}, "bases": {"root": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"2": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult": {"tf": 1}}, "df": 4}, "docs": {}, "df": 0}}}}}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult": {"tf": 1}}, "df": 4}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult": {"tf": 1}}, "df": 4}}}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.data_types.result.GAResult": {"tf": 1}}, "df": 4}}}}}}, "doc": {"root": {"0": {"1": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 1}, "docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 4}, "1": {"0": {"0": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 2}, "docs": {}, "df": 0}, "docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}}, "df": 4, "/": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}}}}}}}, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "2": {"0": {"0": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 1}, "docs": {}, "df": 0}, "docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 5, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "3": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 2}, "4": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 3}, "5": {"docs": {"geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}}, "df": 1, "n": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 3}}, "8": {"docs": {"geneticalgorithm2": {"tf": 1}}, "df": 1}, "docs": {"geneticalgorithm2": {"tf": 3.605551275463989}, "geneticalgorithm2.geneticalgorithm2": {"tf": 1.7320508075688772}, "geneticalgorithm2.Population_initializer": {"tf": 5.385164807134504}, "geneticalgorithm2.callbacks": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.reason_to_stop": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.last_generation": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_generation": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.report_list": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_prob": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete_prob": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.mutation_discrete": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.current_stagnation": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.max_stagnation": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.parents_portion": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.elit_ratio": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 2.23606797749979}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 2}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 2}, "geneticalgorithm2.callbacks.middle": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.Actions": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 4.69041575982343}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.EachGen": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.AfterStagnation": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 4.898979485566356}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.ReduceMutationGen": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.GeneDiversityStats": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.simple": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.NoneCallback": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 5.916079783099616}, "geneticalgorithm2.crossovers": {"tf": 1.7320508075688772}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 2}, "geneticalgorithm2.crossovers.get_copies": {"tf": 1.7320508075688772}, "geneticalgorithm2.crossovers.Crossover": {"tf": 2}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 1.7320508075688772}, "geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 1.7320508075688772}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 1.7320508075688772}, "geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 1.7320508075688772}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 1.7320508075688772}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 1.7320508075688772}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 1.7320508075688772}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 1.7320508075688772}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 3.1622776601683795}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 2.449489742783178}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_probability": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 3.3166247903554}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_probability": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 2.8284271247461903}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.update": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.from_dict": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.aliases": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 3}, "geneticalgorithm2.data_types.base": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.base.DictLikeGetSet": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.base.DictLikeGetSet.get": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 3.1622776601683795}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation.variables": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation.scores": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation.size": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation.dim_size": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation.as_wide_matrix": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation.save": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation.load": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation.from_pop_matrix": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.result": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.result.GAResult": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.result.GAResult.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.result.GAResult.last_generation": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.result.GAResult.score": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.result.GAResult.function": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 7.416198487095663}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.output_dict": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.revolution_oppositor": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dup_oppositor": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.creator": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.init_oppositors": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.funtimeout": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.var_bounds": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.population_size": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.progress_stream": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.param": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.dim": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.prob_mut_discrete": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 11.832159566199232}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations.MutationFloatFunc": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations.MutationIntFunc": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 2.449489742783178}, "geneticalgorithm2.mutations.Mutations": {"tf": 2}, "geneticalgorithm2.mutations.Mutations.mutations_dict": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations.Mutations.mutations_discrete_dict": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations.Mutations.uniform_by_x": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations.Mutations.uniform_by_center": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.uniform_discrete": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 2.23606797749979}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 5.385164807134504}, "geneticalgorithm2.selections": {"tf": 1.7320508075688772}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1.7320508075688772}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1.7320508075688772}, "geneticalgorithm2.selections.roulette": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection": {"tf": 2}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 1.7320508075688772}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1.7320508075688772}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 1.7320508075688772}, "geneticalgorithm2.selections.Selection.stochastic": {"tf": 1.7320508075688772}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 1.7320508075688772}, "geneticalgorithm2.selections.Selection.ranking": {"tf": 1.7320508075688772}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 1.7320508075688772}, "geneticalgorithm2.selections.Selection.tournament": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.aliases": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.aliases.Number": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.aliases.PathLike": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.cache": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 2}, "geneticalgorithm2.utils.files": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.files.mkdir_of_file": {"tf": 3.4641016151377544}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.files.touch": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.funcs": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.funcs.fast_min": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.funcs.fast_max": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.funcs.can_be_prob": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.funcs.is_current_gen_number": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.funcs.is_numpy": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 2.23606797749979}, "geneticalgorithm2.utils.plotting": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.plotting.plot_several_lines": {"tf": 1.7320508075688772}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1.4142135623730951}}, "df": 194, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2": {"tf": 1}}, "df": 3, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"2": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.8284271247461903}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.7320508075688772}}, "df": 8, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}}}}}, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "b": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 2}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}}, "df": 3}}}}, "a": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 3, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 2}}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}}, "df": 8, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 6, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "l": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 6}, "s": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3, "d": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2.6457513110645907}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}, "geneticalgorithm2.selections.Selection": {"tf": 1}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 22}, "y": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 5}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 7}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 5}}}, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1.4142135623730951}}, "df": 1}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 4, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3}}}}, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}}, "df": 1}}}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.mutations.MutationFunc": {"tf": 1}, "geneticalgorithm2.selections.Selection": {"tf": 1}}, "df": 2}}}}}}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}}, "df": 1}}}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 4}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1}}, "df": 2}}}}}}}}}}}}, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 7, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}}, "df": 1}}}}}}}, "k": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}}, "df": 1}}, "b": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 1}}}, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 1}}}}}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 2}}}, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "x": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 6, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "c": {"docs": {}, "df": 0, "h": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}}, "df": 5}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}}}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1}}, "df": 2}}}}, "v": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.mutations.Mutations": {"tf": 1}}, "df": 1}}}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 2}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}}, "df": 5, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2.8284271247461903}}, "df": 3, "s": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 7}}}}}}}, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1.4142135623730951}}, "df": 8, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 4}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2": {"tf": 1.4142135623730951}, "geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 3.3166247903554}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 3.1622776601683795}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1}}, "df": 24, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}}, "df": 1}}, "s": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1}}, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 10}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 3.7416573867739413}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.selections.Selection": {"tf": 1}}, "df": 27, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations": {"tf": 1}, "geneticalgorithm2.selections.Selection": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 7}}}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.7320508075688772}}, "df": 1}}, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.files.touch": {"tf": 1.4142135623730951}}, "df": 4}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 3}}}}}}, "p": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"3": {"docs": {"geneticalgorithm2": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 4, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 1}}}}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}}, "df": 3}}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.mutations.Mutations": {"tf": 1}}, "df": 1}}}}}}}, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}}, "df": 1}}}}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 1}}}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"geneticalgorithm2": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3}}, "r": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 3}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"1": {"docs": {"geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}}, "df": 1}, "2": {"docs": {"geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.crossovers.Crossover": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}}, "df": 7}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 6, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}}, "df": 2}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 4, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 2}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 2}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.6457513110645907}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 2}, "geneticalgorithm2.selections.Selection": {"tf": 1}}, "df": 20, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}}, "df": 1}}}}}}}}, "[": {"docs": {}, "df": 0, ":": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 1}}}}}}}}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 3, "s": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 2}}}}}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 2}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}}, "df": 3}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}}, "df": 2, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 4}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 3}}}}}, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}}, "df": 12, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"geneticalgorithm2": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.4142135623730951}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2}, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}}, "df": 3}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}}}, "o": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.selections.inverse_scores": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"2": {"docs": {"geneticalgorithm2": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}}}}}}}}}}}}}}}}}}, "f": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.23606797749979}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 11}, "s": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 2}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 11}, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 5, "s": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.Selection": {"tf": 1}}, "df": 4}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}}, "df": 2, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 2}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}}}, "o": {"docs": {}, "df": 0, "f": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.Population_initializer": {"tf": 2.23606797749979}, "geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 2}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2.8284271247461903}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 3.1622776601683795}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 2.23606797749979}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}}, "df": 24}, "r": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 5, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}}, "df": 1}}}}}}}, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 8, "s": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.7320508075688772}}, "df": 3}, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3}}}}}}}}, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}, "geneticalgorithm2.mutations.Mutations": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 2}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.7320508075688772}}, "df": 11}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}}, "df": 1}}}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}}, "df": 2, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}}, "df": 1}}}}}}}}}}}, "n": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 5, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}}, "df": 2}}, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 2}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}}, "df": 1, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}}}, "w": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.selections.Selection": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2, "o": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 2, "l": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}}, "df": 1}}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.crossovers.Crossover": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 2}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 2}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}}, "df": 4, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}}, "df": 4}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.selections.Selection": {"tf": 1}}, "df": 5, "s": {"docs": {"geneticalgorithm2.selections.Selection": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.selections.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}}, "df": 2}}, "s": {"docs": {"geneticalgorithm2.selections.Selection": {"tf": 1}}, "df": 1}}}}, "f": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 6, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 1}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1}}, "df": 1}}}}}, "q": {"docs": {"geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 1, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2}}}}, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 4}}, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}}, "df": 3, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 2}}, "df": 3}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover": {"tf": 1}, "geneticalgorithm2.mutations.Mutations": {"tf": 1}, "geneticalgorithm2.selections.Selection": {"tf": 1}}, "df": 7}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 1}}}}}, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 4}}, "o": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 2}}}, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}, "d": {"docs": {"geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 2, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 4, "s": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1}, "geneticalgorithm2.selections.Selection": {"tf": 1}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}, "geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 14}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}}, "df": 1}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 3, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 5}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2, "s": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 2}, "d": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1}}}}}}}}, "b": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.selections.Selection": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}}, "df": 1}}}}}, "y": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "*": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 2}}}}}}}}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}, "geneticalgorithm2.utils.files.mkdir": {"tf": 1}}, "df": 9, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 5}}, "d": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 3}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 6}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 5}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 8}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 2}, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 3}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.data_types.generation.Generation": {"tf": 1}}, "df": 1}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}}, "df": 1}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}}, "df": 1}}, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1}}}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}}, "df": 1}, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": null}}, "df": 1}}}}}}}}}, "m": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "m": {"2": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}}}}}}}}}}}}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "/": {"6": {"1": {"docs": {}, "df": 0, "f": {"4": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"0": {"1": {"1": {"5": {"0": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"1": {"docs": {}, "df": 0, "e": {"1": {"0": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "c": {"5": {"docs": {}, "df": 0, "f": {"0": {"0": {"5": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "b": {"7": {"5": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}, "docs": {}, "df": 0}}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}, "docs": {}, "df": 0}}}}}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}}}, "docs": {}, "df": 0}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}}}}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.mutations.Mutations": {"tf": 1}}, "df": 1}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}}, "df": 1}}}}}}}}}, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}}, "df": 5}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 2, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 9, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 3}}}}}}, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}}}}}}}}, "n": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 3, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}}, "df": 1}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}}, "df": 1}, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}, "geneticalgorithm2.mutations.Mutations": {"tf": 1}}, "df": 5}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 3}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"1": {"docs": {"geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}}, "df": 1}, "2": {"docs": {"geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.crossovers.Crossover": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation.from_object": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.mutations.Mutations": {"tf": 1}, "geneticalgorithm2.selections.Selection": {"tf": 1}}, "df": 9}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 4}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2}}, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}, "geneticalgorithm2.crossovers.Crossover": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 3}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 2}}}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 2}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.crossovers.Crossover": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 9, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "n": {"docs": {"geneticalgorithm2.selections.inverse_scores": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 2, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}, "r": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 3}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 6}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 2}, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.ActionConditions.Always": {"tf": 1}, "geneticalgorithm2.utils.files.touch": {"tf": 1.4142135623730951}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}}, "x": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1}}, "df": 4, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 6}}}, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks": {"tf": 1}}, "df": 1}}}}}, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 4}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}, "geneticalgorithm2.mutations.Mutations": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 13, "s": {"docs": {"geneticalgorithm2.mutations.Mutations": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.mutations.MutationFunc": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}}, "k": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.utils.files.mkdir": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2": {"tf": 1}}, "df": 1, "r": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}}, "df": 4}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.All": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}}, "df": 9}}}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}}, "df": 1}, "l": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}}, "df": 1}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 1}}}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 2}}}}}, "v": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.23606797749979}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 4, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 1}, "geneticalgorithm2.mutations.Mutations": {"tf": 1}}, "df": 4}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.selections.Selection": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "w": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}}, "df": 3}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.mutations.MutationFunc": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, ":": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "b": {"docs": {"geneticalgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1.7320508075688772}}, "df": 2, "c": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1}}}, "n": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 2}, "u": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 7}, "d": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 3}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}}, "df": 3}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}}}}}}, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 4}}}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2}}, "df": 3, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}, "s": {"docs": {}, "df": 0, "k": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 2}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 4}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.utils.files.touch": {"tf": 1}}, "df": 1}}}}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 2}, "geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1.7320508075688772}}, "df": 6}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}}, "df": 2}}}}}}}}, "e": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}, "b": {"docs": {"geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}}, "df": 1, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.23606797749979}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 12, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 2.6457513110645907}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 2.6457513110645907}}, "df": 7, "s": {"docs": {"geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}}, "df": 1}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1.4142135623730951}}, "df": 5}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.selections.inverse_scores": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 3}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 2}}}, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}}, "df": 1}}}, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}}, "df": 2, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {"geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 1}}}, "y": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 3}}, "df": 7}, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.middle.Actions": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions": {"tf": 1}}, "df": 2}}}, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 4}}, "i": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}}, "df": 1}}}, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 3, "o": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.MiddleCallbackConditionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 2}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 3.1622776601683795}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1}, "geneticalgorithm2.selections.Selection": {"tf": 1}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 28}, "h": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 2}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}, "geneticalgorithm2.crossovers.Crossover": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 2.449489742783178}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 2.23606797749979}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 3.872983346207417}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.6457513110645907}, "geneticalgorithm2.mutations.Mutations": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}, "geneticalgorithm2.selections.roulette": {"tf": 1}, "geneticalgorithm2.selections.Selection": {"tf": 1}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}}, "df": 25, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 5}}, "y": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 1}, "m": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3}}, "i": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.files.touch": {"tf": 1}}, "df": 7}}, "a": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1.4142135623730951}}, "df": 1}, "n": {"docs": {"geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}}, "df": 1}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}}, "df": 2, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}}, "df": 2}}}, "s": {"docs": {"geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}, "geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 2}}}, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_type": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_type": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2.23606797749979}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 5, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}, "w": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.selections.Selection.fully_random": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.7320508075688772}}, "df": 4, "o": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2.23606797749979}}, "df": 1, "n": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 7}}, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 7, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 2, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 8, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 2}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.utils.plotting.plot_pop_scores": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "w": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1.4142135623730951}}, "df": 2}, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "d": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}}, "df": 1}}}}}}}, "x": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 1}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "z": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 2}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 2}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 2}}, "df": 4}}}, "g": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}, "w": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2}}, "k": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 6}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1.4142135623730951}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}}, "df": 3}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}, "n": {"docs": {"geneticalgorithm2.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 1, "g": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 1}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.mutations.MutationFunc": {"tf": 1.4142135623730951}}, "df": 1, "+": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {"geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 1}}}, "u": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}}, "df": 2}}}, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 3, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 2}, "r": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1.4142135623730951}}, "df": 1}, "d": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 4, "l": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.crossovers.Crossover": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}}}}}, "p": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1.4142135623730951}}, "df": 2}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.callbacks.middle.MiddleCallbacks.UniversalCallback": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 1}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 1}}}}}, "j": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.mutation_discrete_probability": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}}, "df": 7}}}, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 1}}}}, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.elit_ratio": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}, "geneticalgorithm2.mutations.Mutations.gauss_by_center": {"tf": 1}}, "df": 2}}}}, "x": {"docs": {"geneticalgorithm2.mutations.MutationFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}}, "df": 2}}}}, "pipeline": ["trimmer"], "_isPrebuiltIndex": true};
 
     // mirrored in build-search-index.js (part 1)
     // Also split on html tags. this is a cheap heuristic, but good enough.