From 768f4ec986bc66fbc0f2c8624f47a2d041447020 Mon Sep 17 00:00:00 2001 From: github-actions <41898282+github-actions[bot]@users.noreply.github.com> Date: Sat, 13 Apr 2024 16:49:13 +0000 Subject: [PATCH] CI: Update docs for refs/heads/main (b47254c9474514fcab2fa8096b050539d1a12284) --- docs/geneticalgorithm2.html | 138 +- docs/geneticalgorithm2/geneticalgorithm2.html | 2120 ++++++++--------- .../population_initializer.html | 315 +-- docs/search.js | 2 +- 4 files changed, 1296 insertions(+), 1279 deletions(-) diff --git a/docs/geneticalgorithm2.html b/docs/geneticalgorithm2.html index 4096ef1..4461463 100644 --- a/docs/geneticalgorithm2.html +++ b/docs/geneticalgorithm2.html @@ -135,76 +135,76 @@

- 
20def get_population_initializer(
-21    select_best_of: int = 4,
-22    local_optimization_step: LOCAL_OPTIMIZATION_STEP_CASE = 'never',
-23    local_optimizer: Optional[
-24        Callable[
-25            [array1D, float],
-26            Tuple[array1D, float]
-27        ]
-28    ] = None
-29) -> Tuple[int, Callable[[array2D, array1D], Tuple[array2D, array1D]]]:
-30    """
-31    Args:
-32        select_best_of: determines population size to select 1/select_best_of best part of start population.
-33            For example, for select_best_of = 4 and population_size = N there will be selected N best objects
-34                from 5N generated objects (if start_generation=None dictionary).
-35            If start_generation is not None dictionary, there will be selected best (start_generation) / N objects
-36        local_optimization_step: when to perform local optimization
-37        local_optimizer: the local optimization function (object array, its score) -> (modified array, its score)
-38
-39    Returns:
-40        select_best_of, function which will perform the selection and local optimization
-41    """
-42    
-43    assert select_best_of > 0 and isinstance(select_best_of, int), (select_best_of, type(select_best_of))
+            
26def get_population_initializer(
+27    select_best_of: int = 4,
+28    local_optimization_step: LOCAL_OPTIMIZATION_STEP_CASE = 'never',
+29    local_optimizer: Optional[
+30        Callable[
+31            [array1D, float],
+32            Tuple[array1D, float]
+33        ]
+34    ] = None
+35) -> Tuple[int, PopulationModifier]:
+36    """
+37    Args:
+38        select_best_of: determines population size to select 1/select_best_of best part of start population.
+39            For example, for select_best_of = 4 and population_size = N there will be selected N best objects
+40                from 5N generated objects (if start_generation=None dictionary).
+41            If start_generation is not None dictionary, there will be selected best (start_generation) / N objects
+42        local_optimization_step: when to perform local optimization
+43        local_optimizer: the local optimization function (object array, its score) -> (modified array, its score)
 44
-45    assert local_optimization_step in LOCAL_OPTIMIZATION_STEP_CASE.__args__, (
-46        local_optimization_step, LOCAL_OPTIMIZATION_STEP_CASE.__args__
-47    )
-48
-49    if local_optimizer is None and local_optimization_step in LOCAL_OPTIMIZATION_STEP_CASE.__args__[:2]:
-50        raise Exception(
-51            f"for local_optimization_step from {LOCAL_OPTIMIZATION_STEP_CASE.__args__[:2]} "
-52            f"local_optimizer function mustn't be None"
-53        )
+45    Returns:
+46        select_best_of, population modifier
+47    """
+48    
+49    assert select_best_of > 0 and isinstance(select_best_of, int), (select_best_of, type(select_best_of))
+50
+51    assert local_optimization_step in LOCAL_OPTIMIZATION_STEP_CASE.__args__, (
+52        local_optimization_step, LOCAL_OPTIMIZATION_STEP_CASE.__args__
+53    )
 54
-55    def select_best(population: array2D, scores: array1D) -> Tuple[array2D, array1D]:
-56        args = np.argsort(scores)
-57        args = args[:round(args.size/select_best_of)]
-58        return population[args], scores[args]
-59
-60    def local_opt(population: array2D, scores: array1D):
-61        _pop, _score = zip(
-62            *[
-63                local_optimizer(population[i], scores[i]) for i in range(scores.size)
-64            ]
-65        )
-66        return np.array(_pop), np.array(_score)
-67
-68    #def Create_population(func, start_generation, expected_size, #variable_boundaries):
-69    #    
-70    #    if not (start_generation['variables'] is None):
-71    #        pop = start_generation['variables']
-72    #        scores = start_generation['scores']
-73    #        if scores is None:
-74    #            scores = np.array([func(pop[i, :]) for i in range(pop.shape[0])])
-75    #        return pop, scores
-76
-77    def process_population(population: array2D, scores: array1D):
-78        if local_optimization_step == 'before_select':
-79            pop, s = local_opt(population, scores)
-80            return select_best(pop, s)
-81
-82        if local_optimization_step == 'after_select':
-83            pop, s = select_best(population, scores)
-84            return local_opt(pop, s)
-85
-86        #if local_optimization_step == 'never':
-87        return select_best(population, scores)
-88
-89    return select_best_of, process_population
+55    if local_optimizer is None and local_optimization_step in LOCAL_OPTIMIZATION_STEP_CASE.__args__[:2]:
+56        raise Exception(
+57            f"for local_optimization_step from {LOCAL_OPTIMIZATION_STEP_CASE.__args__[:2]} "
+58            f"local_optimizer function mustn't be None"
+59        )
+60
+61    def select_best(population: array2D, scores: array1D) -> Tuple[array2D, array1D]:
+62        args = np.argsort(scores)
+63        args = args[:round(args.size/select_best_of)]
+64        return population[args], scores[args]
+65
+66    def local_opt(population: array2D, scores: array1D):
+67        _pop, _score = zip(
+68            *[
+69                local_optimizer(population[i], scores[i]) for i in range(scores.size)
+70            ]
+71        )
+72        return np.array(_pop), np.array(_score)
+73
+74    #def Create_population(func, start_generation, expected_size, #variable_boundaries):
+75    #    
+76    #    if not (start_generation['variables'] is None):
+77    #        pop = start_generation['variables']
+78    #        scores = start_generation['scores']
+79    #        if scores is None:
+80    #            scores = np.array([func(pop[i, :]) for i in range(pop.shape[0])])
+81    #        return pop, scores
+82
+83    def process_population(population: array2D, scores: array1D):
+84        if local_optimization_step == 'before_select':
+85            pop, s = local_opt(population, scores)
+86            return select_best(pop, s)
+87
+88        if local_optimization_step == 'after_select':
+89            pop, s = select_best(population, scores)
+90            return local_opt(pop, s)
+91
+92        #if local_optimization_step == 'never':
+93        return select_best(population, scores)
+94
+95    return select_best_of, process_population
 

 
 
@@ -222,7 +222,7 @@ 

 
Returns:

 
 

-  
select_best_of, function which will perform the selection and local optimization

+  
select_best_of, population modifier
diff --git a/docs/geneticalgorithm2/geneticalgorithm2.html b/docs/geneticalgorithm2/geneticalgorithm2.html index 72fb73c..191307d 100644 --- a/docs/geneticalgorithm2/geneticalgorithm2.html +++ b/docs/geneticalgorithm2/geneticalgorithm2.html @@ -138,490 +138,490 @@

- 
   1from typing import Callable, List, Tuple, Optional, Dict, Any, Union, Sequence, Set, Literal
+                        
   1from typing import Callable, List, Tuple, Optional, Dict, Any, Union, Sequence, Literal, Iterable
    2from typing_extensions import TypeAlias
    3
    4import collections
    5import warnings
    6import operator
    7
-   8
-   9import sys
-  10import time
-  11import random
-  12import math
-  13
-  14import numpy as np
-  15
-  16#region INTERNAL IMPORTS
+   8import sys
+   9import time
+  10import random
+  11import math
+  12
+  13import numpy as np
+  14
+  15from OppOpPopInit.initialiser import CreatorFunc
+  16from OppOpPopInit.oppositor import OppositorFunc
   17
-  18from .utils.aliases import array1D, array2D
+  18#region INTERNAL IMPORTS
   19
-  20from .data_types.aliases import FunctionToMinimize, SetFunctionToMinimize
-  21from .data_types.algorithm_params import AlgorithmParams
-  22from .data_types.generation import GenerationConvertible, Generation
-  23from .data_types.result import GAResult
-  24
-  25from .population_initializer import get_population_initializer
-  26from .utils.plotting import plot_pop_scores, plot_several_lines
-  27
-  28from .utils.funcs import can_be_prob, is_numpy, is_current_gen_number, fast_min, random_indexes_pair
+  20from .utils.aliases import array1D, array2D
+  21
+  22from .data_types.aliases import FunctionToMinimize, SetFunctionToMinimize
+  23from .data_types.algorithm_params import AlgorithmParams
+  24from .data_types.generation import GenerationConvertible, Generation
+  25from .data_types.result import GAResult
+  26
+  27from .population_initializer import get_population_initializer, PopulationModifier
+  28from .utils.plotting import plot_pop_scores, plot_several_lines
   29
-  30from .callbacks.data import MiddleCallbackData
-  31from .callbacks import MiddleCallbackFunc, SimpleCallbackFunc
-  32
-  33#endregion
+  30from .utils.funcs import can_be_prob, is_numpy, is_current_gen_number, fast_min, random_indexes_pair
+  31
+  32from .callbacks.data import MiddleCallbackData
+  33from .callbacks import MiddleCallbackFunc, SimpleCallbackFunc
   34
-  35#region ALIASES
+  35#endregion
   36
-  37VARIABLE_TYPE: TypeAlias = Literal['int', 'real', 'bool']
-  38"""
-  39the variable type for a given or all dimension, determines the values discretion:
-  40    real: double numbers
-  41    int: integer number only
-  42    bool: in the fact is integer with bounds [0, 1]
-  43"""
-  44
-  45#endregion
+  37#region ALIASES
+  38
+  39VARIABLE_TYPE: TypeAlias = Literal['int', 'real', 'bool']
+  40"""
+  41the variable type for a given or all dimension, determines the values discretion:
+  42    real: double numbers
+  43    int: integer number only
+  44    bool: in the fact is integer with bounds [0, 1]
+  45"""
   46
-  47
-  48class GeneticAlgorithm2:
-  49    """
-  50    Genetic algorithm optimization process
-  51    """
-  52    
-  53    default_params = AlgorithmParams()
-  54    PROGRESS_BAR_LEN = 20
-  55    """max count of symbols in the progress bar"""
-  56
-  57    @property
-  58    def output_dict(self):
-  59        warnings.warn(
-  60            "'output_dict' is deprecated and will be removed at version 7 \n"
-  61            "use 'result' instead"
-  62        )
-  63        return self.result
-  64
-  65    @property
-  66    def needs_mutation(self) -> bool:
-  67        """whether the mutation is required"""
-  68        return self.prob_mut > 0 or self.prob_mut_discrete > 0
-  69
-  70    #region INIT
+  47#endregion
+  48
+  49
+  50class GeneticAlgorithm2:
+  51    """
+  52    Genetic algorithm optimization process
+  53    """
+  54    
+  55    default_params = AlgorithmParams()
+  56    PROGRESS_BAR_LEN = 20
+  57    """max count of symbols in the progress bar"""
+  58
+  59    @property
+  60    def output_dict(self):
+  61        warnings.warn(
+  62            "'output_dict' is deprecated and will be removed at version 7 \n"
+  63            "use 'result' instead"
+  64        )
+  65        return self.result
+  66
+  67    @property
+  68    def needs_mutation(self) -> bool:
+  69        """whether the mutation is required"""
+  70        return self.prob_mut > 0 or self.prob_mut_discrete > 0
   71
-  72    def __init__(
-  73        self,
-  74        function: FunctionToMinimize,
-  75
-  76        dimension: int,
-  77        variable_type: Union[VARIABLE_TYPE, Sequence[VARIABLE_TYPE]] = 'bool',
-  78        variable_boundaries: Optional[Union[array2D, Sequence[Tuple[float, float]]]] = None,
-  79
-  80        variable_type_mixed=None,
+  72    #region INIT
+  73
+  74    def __init__(
+  75        self,
+  76        function: FunctionToMinimize,
+  77
+  78        dimension: int,
+  79        variable_type: Union[VARIABLE_TYPE, Sequence[VARIABLE_TYPE]] = 'bool',
+  80        variable_boundaries: Optional[Union[array2D, Sequence[Tuple[float, float]]]] = None,
   81
-  82        function_timeout: Optional[float] = None,
-  83        algorithm_parameters: Union[AlgorithmParams, Dict[str, Any]] = default_params
-  84    ):
-  85        """
-  86        initializes the GA object and performs main checks
-  87
-  88        Args:
-  89            function: the given objective function to be minimized
-  90            dimension: the number of decision variables, the population samples dimention
-  91
-  92            variable_type: string means the variable type for all variables,
-  93                for mixed types use sequence of strings of type for each variable
-  94
-  95            variable_boundaries: leave it None if variable_type is 'bool';
-  96                otherwise provide a sequence of tuples of length two as boundaries for each variable;
-  97                the length of the array must be equal dimension.
-  98                For example, ([0,100], [0,200]) determines
-  99                    lower boundary 0 and upper boundary 100 for first
- 100                    and upper boundary 200 for second variable
- 101                    and dimension must be 2.
- 102
- 103            variable_type_mixed -- deprecated
+  82        variable_type_mixed=None,
+  83
+  84        function_timeout: Optional[float] = None,
+  85        algorithm_parameters: Union[AlgorithmParams, Dict[str, Any]] = default_params
+  86    ):
+  87        """
+  88        initializes the GA object and performs main checks
+  89
+  90        Args:
+  91            function: the given objective function to be minimized
+  92            dimension: the number of decision variables, the population samples dimention
+  93
+  94            variable_type: string means the variable type for all variables,
+  95                for mixed types use sequence of strings of type for each variable
+  96
+  97            variable_boundaries: leave it None if variable_type is 'bool';
+  98                otherwise provide a sequence of tuples of length two as boundaries for each variable;
+  99                the length of the array must be equal dimension.
+ 100                For example, ([0,100], [0,200]) determines
+ 101                    lower boundary 0 and upper boundary 100 for first
+ 102                    and upper boundary 200 for second variable
+ 103                    and dimension must be 2.
  104
- 105            function_timeout: if the given function does not provide
- 106                output before function_timeout (unit is seconds) the algorithm raises error.
- 107                For example, when there is an infinite loop in the given function.
- 108                `None` means disabling
- 109
- 110            algorithm_parameters: AlgorithmParams object or usual dictionary with algorithm parameter;
- 111                it is not mandatory to provide all possible parameters
- 112
- 113        Notes:
- 114            - This implementation minimizes the given objective function.
- 115            For maximization u can multiply the function by -1 (for instance): the absolute
- 116                value of the output would be the actual objective function
- 117
- 118        for more details and examples of implementation please visit:
- 119            https://github.com/PasaOpasen/geneticalgorithm2
- 120  
- 121        """
- 122
- 123        # all default fields
+ 105            variable_type_mixed -- deprecated
+ 106
+ 107            function_timeout: if the given function does not provide
+ 108                output before function_timeout (unit is seconds) the algorithm raises error.
+ 109                For example, when there is an infinite loop in the given function.
+ 110                `None` means disabling
+ 111
+ 112            algorithm_parameters: AlgorithmParams object or usual dictionary with algorithm parameter;
+ 113                it is not mandatory to provide all possible parameters
+ 114
+ 115        Notes:
+ 116            - This implementation minimizes the given objective function.
+ 117            For maximization u can multiply the function by -1 (for instance): the absolute
+ 118                value of the output would be the actual objective function
+ 119
+ 120        for more details and examples of implementation please visit:
+ 121            https://github.com/PasaOpasen/geneticalgorithm2
+ 122  
+ 123        """
  124
- 125        # self.crossover: Callable[[np.ndarray, np.ndarray], Tuple[np.ndarray, np.ndarray]] = None
- 126        # self.real_mutation: Callable[[float, float, float], float] = None
- 127        # self.discrete_mutation: Callable[[int, int, int], int] = None
- 128        # self.selection: Callable[[np.ndarray, int], np.ndarray] = None
- 129
- 130        self.f: Callable[[array1D], float] = None
- 131        self.funtimeout: float = None
- 132        self.set_function: Callable[[np.ndarray], np.ndarray] = None
- 133
- 134        # self.dim: int = None
- 135        self.var_bounds: List[Tuple[Union[int, float], Union[int, float]]] = None
- 136        # self.indexes_int: np.ndarray = None
- 137        # self.indexes_float: np.ndarray = None
- 138
- 139        self.checked_reports: List[Tuple[str, Callable[[array1D], None]]] = None
+ 125        # all default fields
+ 126
+ 127        # self.crossover: Callable[[np.ndarray, np.ndarray], Tuple[np.ndarray, np.ndarray]] = None
+ 128        # self.real_mutation: Callable[[float, float, float], float] = None
+ 129        # self.discrete_mutation: Callable[[int, int, int], int] = None
+ 130        # self.selection: Callable[[np.ndarray, int], np.ndarray] = None
+ 131
+ 132        self.f: Callable[[array1D], float] = None
+ 133        self.funtimeout: float = None
+ 134        self.set_function: Callable[[np.ndarray], np.ndarray] = None
+ 135
+ 136        # self.dim: int = None
+ 137        self.var_bounds: List[Tuple[Union[int, float], Union[int, float]]] = None
+ 138        # self.indexes_int: np.ndarray = None
+ 139        # self.indexes_float: np.ndarray = None
  140
- 141        self.population_size: int = None
- 142        self.progress_stream = None
- 143
- 144        # input algorithm's parameters
+ 141        self.checked_reports: List[Tuple[str, Callable[[array1D], None]]] = None
+ 142
+ 143        self.population_size: int = None
+ 144        self.progress_stream = None
  145
- 146        assert isinstance(algorithm_parameters, (dict, AlgorithmParams)), (
- 147            "algorithm_parameters must be dict or AlgorithmParams object"
- 148        )
- 149        if not isinstance(algorithm_parameters, AlgorithmParams):
- 150            algorithm_parameters = AlgorithmParams.from_dict(algorithm_parameters)
- 151        algorithm_parameters.validate()
- 152        self.param = algorithm_parameters
- 153
- 154        self.crossover, self.real_mutation, self.discrete_mutation, self.selection = algorithm_parameters.get_CMS_funcs()
+ 146        # input algorithm's parameters
+ 147
+ 148        assert isinstance(algorithm_parameters, (dict, AlgorithmParams)), (
+ 149            "algorithm_parameters must be dict or AlgorithmParams object"
+ 150        )
+ 151        if not isinstance(algorithm_parameters, AlgorithmParams):
+ 152            algorithm_parameters = AlgorithmParams.from_dict(algorithm_parameters)
+ 153        algorithm_parameters.validate()
+ 154        self.param = algorithm_parameters
  155
- 156        # dimension and area bounds
- 157        self.dim = int(dimension)
- 158        assert self.dim > 0, f"dimension count must be int and >0, gotten {dimension}"
- 159
- 160        if variable_type_mixed is not None:
- 161            warnings.warn(
- 162                f"argument variable_type_mixed is deprecated and will be removed at version 7\n "
- 163                f"use variable_type={tuple(variable_type_mixed)} instead"
- 164            )
- 165            variable_type = variable_type_mixed
- 166        self._set_types_indexes(variable_type)  # types indexes
- 167        self._set_var_boundaries(variable_type, variable_boundaries)  # input variables' boundaries
- 168
- 169        # fix mutation probs
+ 156        self.crossover, self.real_mutation, self.discrete_mutation, self.selection = algorithm_parameters.get_CMS_funcs()
+ 157
+ 158        # dimension and area bounds
+ 159        self.dim = int(dimension)
+ 160        assert self.dim > 0, f"dimension count must be int and >0, gotten {dimension}"
+ 161
+ 162        if variable_type_mixed is not None:
+ 163            warnings.warn(
+ 164                f"argument variable_type_mixed is deprecated and will be removed at version 7\n "
+ 165                f"use variable_type={tuple(variable_type_mixed)} instead"
+ 166            )
+ 167            variable_type = variable_type_mixed
+ 168        self._set_types_indexes(variable_type)  # types indexes
+ 169        self._set_var_boundaries(variable_type, variable_boundaries)  # input variables' boundaries
  170
- 171        assert can_be_prob(self.param.mutation_probability)
- 172        self.prob_mut = self.param.mutation_probability
- 173        assert self.param.mutation_discrete_probability is None or can_be_prob(self.param.mutation_discrete_probability)
- 174        self.prob_mut_discrete = self.param.mutation_discrete_probability or self.prob_mut
- 175
- 176        if self.param.crossover_probability is not None:
- 177            warnings.warn(
- 178                f"crossover_probability is deprecated and will be removed in version 7. "
- 179                f"Reason: it's old and has no sense"
- 180            )
- 181
- 182        #############################################################
- 183        # input function
- 184        assert (callable(function)), "function must be callable!"
- 185        self.f = function
- 186
- 187        if function_timeout is not None and function_timeout > 0:
- 188            try:
- 189                from func_timeout import func_timeout, FunctionTimedOut
- 190            except ModuleNotFoundError:
- 191                raise ModuleNotFoundError(
- 192                    "function_timeout > 0 needs additional package func_timeout\n"
- 193                    "run `python -m pip install func_timeout`\n"
- 194                    "or disable this parameter: function_timeout=None"
- 195                )
- 196
- 197        self.funtimeout = None if function_timeout is None else float(function_timeout)
+ 171        # fix mutation probs
+ 172
+ 173        assert can_be_prob(self.param.mutation_probability)
+ 174        self.prob_mut = self.param.mutation_probability
+ 175        assert self.param.mutation_discrete_probability is None or can_be_prob(self.param.mutation_discrete_probability)
+ 176        self.prob_mut_discrete = self.param.mutation_discrete_probability or self.prob_mut
+ 177
+ 178        if self.param.crossover_probability is not None:
+ 179            warnings.warn(
+ 180                f"crossover_probability is deprecated and will be removed in version 7. "
+ 181                f"Reason: it's old and has no sense"
+ 182            )
+ 183
+ 184        #############################################################
+ 185        # input function
+ 186        assert (callable(function)), "function must be callable!"
+ 187        self.f = function
+ 188
+ 189        if function_timeout is not None and function_timeout > 0:
+ 190            try:
+ 191                from func_timeout import func_timeout, FunctionTimedOut
+ 192            except ModuleNotFoundError:
+ 193                raise ModuleNotFoundError(
+ 194                    "function_timeout > 0 needs additional package func_timeout\n"
+ 195                    "run `python -m pip install func_timeout`\n"
+ 196                    "or disable this parameter: function_timeout=None"
+ 197                )
  198
- 199        #############################################################
- 200        
- 201        self.population_size = int(self.param.population_size)
- 202        self._set_parents_count(self.param.parents_portion)
- 203        self._set_elit_count(self.population_size, self.param.elit_ratio)
- 204        assert self.parents_count >= self.elit_count, (
- 205            f"\n number of parents ({self.parents_count}) "
- 206            f"must be greater than number of elits ({self.elit_count})"
- 207        )
- 208
- 209        self._set_max_iterations()
+ 199        self.funtimeout = None if function_timeout is None else float(function_timeout)
+ 200
+ 201        #############################################################
+ 202        
+ 203        self.population_size = int(self.param.population_size)
+ 204        self._set_parents_count(self.param.parents_portion)
+ 205        self._set_elit_count(self.population_size, self.param.elit_ratio)
+ 206        assert self.parents_count >= self.elit_count, (
+ 207            f"\n number of parents ({self.parents_count}) "
+ 208            f"must be greater than number of elits ({self.elit_count})"
+ 209        )
  210
- 211        self._set_report()
+ 211        self._set_max_iterations()
  212
- 213        # specify this function to speed up or change default behaviour
- 214        self.fill_children: Optional[Callable[[array2D, int], None]] = None
- 215        """
- 216        custom function which adds children for population POP 
- 217            where POP[:parents_count] are parents lines and next lines are for children
- 218        """
- 219
- 220    def _set_types_indexes(self, variable_type: Union[str, Sequence[str]]):
+ 213        self._set_report()
+ 214
+ 215        # specify this function to speed up or change default behaviour
+ 216        self.fill_children: Optional[Callable[[array2D, int], None]] = None
+ 217        """
+ 218        custom function which adds children for population POP 
+ 219            where POP[:parents_count] are parents lines and next lines are for children
+ 220        """
  221
- 222        indexes = np.arange(self.dim)
- 223        self.indexes_int = np.array([])
- 224        self.indexes_float = np.array([])
- 225
- 226        assert_message = (
- 227            f"\n variable_type must be 'bool', 'int', 'real' or a sequence with 'int' and 'real', got {variable_type}"
- 228        )
- 229
- 230        if isinstance(variable_type, str):
- 231            assert (variable_type in VARIABLE_TYPE.__args__), assert_message
- 232            if variable_type == 'real':
- 233                self.indexes_float = indexes
- 234            else:
- 235                self.indexes_int = indexes
- 236
- 237        else:  # sequence case
+ 222    def _set_types_indexes(self, variable_type: Union[str, Sequence[str]]):
+ 223
+ 224        indexes = np.arange(self.dim)
+ 225        self.indexes_int = np.array([])
+ 226        self.indexes_float = np.array([])
+ 227
+ 228        assert_message = (
+ 229            f"\n variable_type must be 'bool', 'int', 'real' or a sequence with 'int' and 'real', got {variable_type}"
+ 230        )
+ 231
+ 232        if isinstance(variable_type, str):
+ 233            assert (variable_type in VARIABLE_TYPE.__args__), assert_message
+ 234            if variable_type == 'real':
+ 235                self.indexes_float = indexes
+ 236            else:
+ 237                self.indexes_int = indexes
  238
- 239            assert len(variable_type) == self.dim, (
- 240                f"\n variable_type must have a length equal dimension. "
- 241                f"Should be {self.dim}, got {len(variable_type)}"
- 242            )
- 243            assert 'bool' not in variable_type, (
- 244                "don't use 'bool' if variable_type is a sequence, "
- 245                "for 'boolean' case use 'int' and specify boundary as (0,1)"
- 246            )
- 247            assert all(v in VARIABLE_TYPE.__args__ for v in variable_type), assert_message
- 248
- 249            vartypes = np.array(variable_type)
- 250            self.indexes_int = indexes[vartypes == 'int']
- 251            self.indexes_float = indexes[vartypes == 'real']
- 252
- 253    def _set_var_boundaries(
- 254        self,
- 255        variable_type: Union[str, Sequence[str]],
- 256        variable_boundaries
- 257    ):
- 258        if isinstance(variable_type, str) and variable_type == 'bool':
- 259            self.var_bounds = [(0, 1)] * self.dim
- 260        else:
- 261
- 262            if is_numpy(variable_boundaries):
- 263                assert variable_boundaries.shape == (self.dim, 2), (
- 264                    f"\n if variable_boundaries is numpy array, it must be with shape (dim, 2)"
- 265                )
- 266            else:
- 267                assert len(variable_boundaries) == self.dim and all((len(t) == 2 for t in variable_boundaries)), (
- 268                    "\n if variable_boundaries is sequence, "
- 269                    "it must be with len dim and boundary for each variable must be a tuple of length two"
- 270                )
- 271
- 272            for i in variable_boundaries:
- 273                assert i[0] <= i[1], "\n lower_boundaries must be smaller than upper_boundaries [lower,upper]"
- 274
- 275            self.var_bounds = [(i[0], i[1]) for i in variable_boundaries]
+ 239        else:  # sequence case
+ 240
+ 241            assert len(variable_type) == self.dim, (
+ 242                f"\n variable_type must have a length equal dimension. "
+ 243                f"Should be {self.dim}, got {len(variable_type)}"
+ 244            )
+ 245            assert 'bool' not in variable_type, (
+ 246                "don't use 'bool' if variable_type is a sequence, "
+ 247                "for 'boolean' case use 'int' and specify boundary as (0,1)"
+ 248            )
+ 249            assert all(v in VARIABLE_TYPE.__args__ for v in variable_type), assert_message
+ 250
+ 251            vartypes = np.array(variable_type)
+ 252            self.indexes_int = indexes[vartypes == 'int']
+ 253            self.indexes_float = indexes[vartypes == 'real']
+ 254
+ 255    def _set_var_boundaries(
+ 256        self,
+ 257        variable_type: Union[str, Sequence[str]],
+ 258        variable_boundaries
+ 259    ):
+ 260        if isinstance(variable_type, str) and variable_type == 'bool':
+ 261            self.var_bounds = [(0, 1)] * self.dim
+ 262        else:
+ 263
+ 264            if is_numpy(variable_boundaries):
+ 265                assert variable_boundaries.shape == (self.dim, 2), (
+ 266                    f"\n if variable_boundaries is numpy array, it must be with shape (dim, 2)"
+ 267                )
+ 268            else:
+ 269                assert len(variable_boundaries) == self.dim and all((len(t) == 2 for t in variable_boundaries)), (
+ 270                    "\n if variable_boundaries is sequence, "
+ 271                    "it must be with len dim and boundary for each variable must be a tuple of length two"
+ 272                )
+ 273
+ 274            for i in variable_boundaries:
+ 275                assert i[0] <= i[1], "\n lower_boundaries must be smaller than upper_boundaries [lower,upper]"
  276
- 277    def _set_parents_count(self, parents_portion: float):
+ 277            self.var_bounds = [(i[0], i[1]) for i in variable_boundaries]
  278
- 279        self.parents_count = int(parents_portion * self.population_size)
- 280        assert self.population_size >= self.parents_count > 1, (
- 281            f'parents count {self.parents_count} cannot be less than population size {self.population_size}'
- 282        )
- 283        trl = self.population_size - self.parents_count
- 284        if trl % 2 != 0:
- 285            self.parents_count += 1
- 286
- 287    def _set_elit_count(self, pop_size: int, elit_ratio: Union[float, int]):
+ 279    def _set_parents_count(self, parents_portion: float):
+ 280
+ 281        self.parents_count = int(parents_portion * self.population_size)
+ 282        assert self.population_size >= self.parents_count > 1, (
+ 283            f'parents count {self.parents_count} cannot be less than population size {self.population_size}'
+ 284        )
+ 285        trl = self.population_size - self.parents_count
+ 286        if trl % 2 != 0:
+ 287            self.parents_count += 1
  288
- 289        assert elit_ratio >= 0
- 290        self.elit_count = elit_ratio if isinstance(elit_ratio, str) else math.ceil(pop_size*elit_ratio)
- 291
- 292    def _set_max_iterations(self):
+ 289    def _set_elit_count(self, pop_size: int, elit_ratio: Union[float, int]):
+ 290
+ 291        assert elit_ratio >= 0
+ 292        self.elit_count = elit_ratio if isinstance(elit_ratio, str) else math.ceil(pop_size*elit_ratio)
  293
- 294        if self.param.max_num_iteration is None:
- 295            iterate = 0
- 296            for i in range(0, self.dim):
- 297                bound_min, bound_max = self.var_bounds[i]
- 298                var_space = bound_max - bound_min
- 299                if i in self.indexes_int:
- 300                    iterate += var_space * self.dim * (100 / self.population_size)
- 301                else:
- 302                    iterate += var_space * 50 * (100 / self.population_size)
- 303            iterate = int(iterate)
- 304            if (iterate * self.population_size) > 10000000:
- 305                iterate = 10000000 / self.population_size
- 306
- 307            self.max_iterations = fast_min(iterate, 8000)
- 308        else:
- 309            assert self.param.max_num_iteration > 0
- 310            self.max_iterations = math.ceil(self.param.max_num_iteration)
- 311
- 312        max_it = self.param.max_iteration_without_improv
- 313        if max_it is None:
- 314            self.max_stagnations = self.max_iterations + 1
- 315        else:
- 316            self.max_stagnations = math.ceil(max_it)
- 317
- 318    #endregion
+ 294    def _set_max_iterations(self):
+ 295
+ 296        if self.param.max_num_iteration is None:
+ 297            iterate = 0
+ 298            for i in range(0, self.dim):
+ 299                bound_min, bound_max = self.var_bounds[i]
+ 300                var_space = bound_max - bound_min
+ 301                if i in self.indexes_int:
+ 302                    iterate += var_space * self.dim * (100 / self.population_size)
+ 303                else:
+ 304                    iterate += var_space * 50 * (100 / self.population_size)
+ 305            iterate = int(iterate)
+ 306            if (iterate * self.population_size) > 10000000:
+ 307                iterate = 10000000 / self.population_size
+ 308
+ 309            self.max_iterations = fast_min(iterate, 8000)
+ 310        else:
+ 311            assert self.param.max_num_iteration > 0
+ 312            self.max_iterations = math.ceil(self.param.max_num_iteration)
+ 313
+ 314        max_it = self.param.max_iteration_without_improv
+ 315        if max_it is None:
+ 316            self.max_stagnations = self.max_iterations + 1
+ 317        else:
+ 318            self.max_stagnations = math.ceil(max_it)
  319
- 320    #region REPORT
+ 320    #endregion
  321
- 322    def _set_report(self):
- 323        """
- 324        creates default report checker
- 325        """
- 326        self.checked_reports = [
- 327            # item 0 cuz scores will be sorted and min item is items[0]
- 328            ('report', operator.itemgetter(0))
- 329        ]
- 330
- 331    def _clear_report(self):
- 332        """
- 333        removes all report objects
- 334        """
- 335        fields = [f for f in vars(self).keys() if f.startswith('report')]
- 336        for attr in fields:
- 337            delattr(self, attr)
- 338
- 339    def _init_report(self):
- 340        """
- 341        makes empty report fields
- 342        """
- 343        for name, _ in self.checked_reports:
- 344            setattr(self, name, [])
- 345
- 346    def _update_report(self, scores: array1D):
- 347        """
- 348        append report value to the end of field
- 349        """
- 350        for name, func in self.checked_reports:
- 351            getattr(self, name).append(
- 352                func(scores)
- 353            )
- 354
- 355    #endregion
+ 322    #region REPORT
+ 323
+ 324    def _set_report(self):
+ 325        """
+ 326        creates default report checker
+ 327        """
+ 328        self.checked_reports = [
+ 329            # item 0 cuz scores will be sorted and min item is items[0]
+ 330            ('report', operator.itemgetter(0))
+ 331        ]
+ 332
+ 333    def _clear_report(self):
+ 334        """
+ 335        removes all report objects
+ 336        """
+ 337        fields = [f for f in vars(self).keys() if f.startswith('report')]
+ 338        for attr in fields:
+ 339            delattr(self, attr)
+ 340
+ 341    def _init_report(self):
+ 342        """
+ 343        makes empty report fields
+ 344        """
+ 345        for name, _ in self.checked_reports:
+ 346            setattr(self, name, [])
+ 347
+ 348    def _update_report(self, scores: array1D):
+ 349        """
+ 350        append report value to the end of field
+ 351        """
+ 352        for name, func in self.checked_reports:
+ 353            getattr(self, name).append(
+ 354                func(scores)
+ 355            )
  356
- 357    #region RUN METHODS
+ 357    #endregion
  358
- 359    def _progress(self, count: int, total: int, status: str = ''):
+ 359    #region RUN METHODS
  360
- 361        part = count / total
+ 361    def _progress(self, count: int, total: int, status: str = ''):
  362
- 363        filled_len = round(GeneticAlgorithm2.PROGRESS_BAR_LEN * part)
- 364        percents = round(100.0 * part, 1)
- 365        bar = '|' * filled_len + '_' * (GeneticAlgorithm2.PROGRESS_BAR_LEN - filled_len)
- 366
- 367        self.progress_stream.write('\r%s %s%s %s' % (bar, percents, '%', status))
- 368        self.progress_stream.flush()
- 369
- 370    def __str__(self):
- 371        return f"Genetic algorithm object with parameters {self.param}"
- 372
- 373    def __repr__(self):
- 374        return self.__str__()
- 375
- 376    def _simulate(self, sample: array1D):
+ 363        part = count / total
+ 364
+ 365        filled_len = round(GeneticAlgorithm2.PROGRESS_BAR_LEN * part)
+ 366        percents = round(100.0 * part, 1)
+ 367        bar = '|' * filled_len + '_' * (GeneticAlgorithm2.PROGRESS_BAR_LEN - filled_len)
+ 368
+ 369        self.progress_stream.write('\r%s %s%s %s' % (bar, percents, '%', status))
+ 370        self.progress_stream.flush()
+ 371
+ 372    def __str__(self):
+ 373        return f"Genetic algorithm object with parameters {self.param}"
+ 374
+ 375    def __repr__(self):
+ 376        return self.__str__()
  377
- 378        from func_timeout import func_timeout, FunctionTimedOut
+ 378    def _simulate(self, sample: array1D):
  379
- 380        obj = None
- 381        eval_time = time.time()
- 382        try:
- 383            obj = func_timeout(
- 384                self.funtimeout,
- 385                lambda: self.f(sample)
- 386            )
- 387        except FunctionTimedOut:
- 388            print("given function is not applicable")
- 389        eval_time = time.time() - eval_time
- 390
- 391        assert obj is not None, (
- 392            f"the given function was running like {eval_time} seconds and does not provide any output"
- 393        )
- 394
- 395        tp = type(obj)
- 396        assert (
- 397            tp in (int, float) or np.issubdtype(tp, np.floating) or np.issubdtype(tp, np.integer)
- 398        ), f"Minimized function should return a number, but got '{obj}' object with type {tp}"
- 399
- 400        return obj, eval_time
+ 380        from func_timeout import func_timeout, FunctionTimedOut
+ 381
+ 382        obj = None
+ 383        eval_time = time.time()
+ 384        try:
+ 385            obj = func_timeout(
+ 386                self.funtimeout,
+ 387                lambda: self.f(sample)
+ 388            )
+ 389        except FunctionTimedOut:
+ 390            print("given function is not applicable")
+ 391        eval_time = time.time() - eval_time
+ 392
+ 393        assert obj is not None, (
+ 394            f"the given function was running like {eval_time} seconds and does not provide any output"
+ 395        )
+ 396
+ 397        tp = type(obj)
+ 398        assert (
+ 399            tp in (int, float) or np.issubdtype(tp, np.floating) or np.issubdtype(tp, np.integer)
+ 400        ), f"Minimized function should return a number, but got '{obj}' object with type {tp}"
  401
- 402    def _set_mutation_indexes(self, mutation_indexes: Optional[Sequence[int]]):
+ 402        return obj, eval_time
  403
- 404        if mutation_indexes is None:
- 405            self.indexes_float_mut = self.indexes_float
- 406            self.indexes_int_mut = self.indexes_int
- 407        else:
- 408            tmp_indexes = set(mutation_indexes)
- 409            self.indexes_int_mut = np.array(list(tmp_indexes.intersection(self.indexes_int)))
- 410            self.indexes_float_mut = np.array(list(tmp_indexes.intersection(self.indexes_float)))
- 411
- 412            if self.indexes_float_mut.size == 0 and self.indexes_int_mut.size == 0:
- 413                warnings.warn(f"No mutation dimensions!!! Check ur mutation indexes!!")
- 414
- 415    #@profile
- 416    def run(
- 417        self,
- 418        no_plot: bool = False,
- 419        disable_printing: bool = False,
- 420        progress_bar_stream: Optional[str] = 'stdout',
- 421
- 422        # deprecated
- 423        disable_progress_bar: bool = False,
- 424
- 425        set_function: SetFunctionToMinimize = None,
- 426        apply_function_to_parents: bool = False,
- 427        start_generation: GenerationConvertible = Generation(),
- 428        studEA: bool = False,
- 429        mutation_indexes: Optional[Union[Sequence[int], Set[int]]] = None,
- 430
- 431        init_creator: Optional[Callable[[], array1D]] = None,
- 432        init_oppositors: Optional[Sequence[Callable[[array1D], array1D]]] = None,
- 433
- 434        duplicates_oppositor: Optional[Callable[[array1D], array1D]] = None,
- 435        remove_duplicates_generation_step: Optional[int] = None,
- 436
- 437        revolution_oppositor: Optional[Callable[[array1D], array1D]] = None,
- 438        revolution_after_stagnation_step: Optional[int] = None,
- 439        revolution_part: float = 0.3,
- 440
- 441        population_initializer: Tuple[
- 442            int, Callable[[array2D, array1D], Tuple[array2D, array1D]]
- 443        ] = get_population_initializer(select_best_of=1, local_optimization_step='never', local_optimizer=None),
- 444
- 445        stop_when_reached: Optional[float] = None,
- 446        callbacks: Optional[Sequence[SimpleCallbackFunc]] = None,
- 447        middle_callbacks: Optional[Sequence[MiddleCallbackFunc]] = None,  #+
- 448        time_limit_secs: Optional[float] = None,
- 449        save_last_generation_as: Optional[str] = None,
- 450        seed: Optional[int] = None
- 451    ):
- 452        """
- 453        runs optimization process
- 454
- 455        Args:
- 456            no_plot: do not plot results using matplotlib by default
- 457
- 458            disable_printing: do not print log info of optimization process
+ 404    def _set_mutation_indexes(self, mutation_indexes: Optional[Iterable[int]]):
+ 405
+ 406        if mutation_indexes is None:
+ 407            self.indexes_float_mut = self.indexes_float
+ 408            self.indexes_int_mut = self.indexes_int
+ 409        else:
+ 410            tmp_indexes = set(mutation_indexes)
+ 411            self.indexes_int_mut = np.array(list(tmp_indexes.intersection(self.indexes_int)))
+ 412            self.indexes_float_mut = np.array(list(tmp_indexes.intersection(self.indexes_float)))
+ 413
+ 414            if self.indexes_float_mut.size == 0 and self.indexes_int_mut.size == 0:
+ 415                warnings.warn(f"No mutation dimensions!!! Check ur mutation indexes!!")
+ 416
+ 417    #@profile
+ 418    def run(
+ 419        self,
+ 420        no_plot: bool = False,
+ 421        disable_printing: bool = False,
+ 422        progress_bar_stream: Optional[str] = 'stdout',
+ 423
+ 424        # deprecated
+ 425        disable_progress_bar: bool = False,
+ 426
+ 427        set_function: SetFunctionToMinimize = None,
+ 428        apply_function_to_parents: bool = False,
+ 429        start_generation: GenerationConvertible = Generation(),
+ 430        studEA: bool = False,
+ 431        mutation_indexes: Optional[Iterable[int]] = None,
+ 432
+ 433        init_creator: Optional[CreatorFunc] = None,
+ 434        init_oppositors: Optional[Sequence[OppositorFunc]] = None,
+ 435
+ 436        duplicates_oppositor: Optional[OppositorFunc] = None,
+ 437        remove_duplicates_generation_step: Optional[int] = None,
+ 438
+ 439        revolution_oppositor: Optional[OppositorFunc] = None,
+ 440        revolution_after_stagnation_step: Optional[int] = None,
+ 441        revolution_part: float = 0.3,
+ 442
+ 443        population_initializer: Tuple[
+ 444            int, PopulationModifier
+ 445        ] = get_population_initializer(select_best_of=1, local_optimization_step='never', local_optimizer=None),
+ 446
+ 447        stop_when_reached: Optional[float] = None,
+ 448        callbacks: Optional[Sequence[SimpleCallbackFunc]] = None,
+ 449        middle_callbacks: Optional[Sequence[MiddleCallbackFunc]] = None,  #+
+ 450        time_limit_secs: Optional[float] = None,
+ 451        save_last_generation_as: Optional[str] = None,
+ 452        seed: Optional[int] = None
+ 453    ):
+ 454        """
+ 455        runs optimization process
+ 456
+ 457        Args:
+ 458            no_plot: do not plot results using matplotlib by default
  459
- 460            progress_bar_stream: 'stdout', 'stderr' or None to disable progress bar
+ 460            disable_printing: do not print log info of optimization process
  461
- 462            disable_progress_bar:
+ 462            progress_bar_stream: 'stdout', 'stderr' or None to disable progress bar
  463
- 464            set_function : 2D-array -> 1D-array function,
- 465                which applyes to matrix of population (size (samples, dimention))
- 466                    to estimate their values
+ 464            disable_progress_bar: deprecated
+ 465
+ 466            set_function: set function to be used instead of usual function
  467
- 468            apply_function_to_parents: apply function to parents from previous generation (if it's needed)
+ 468            apply_function_to_parents: whether to apply function to parents from previous generation (if it's needed)
  469
- 470            start_generation: Generation object or a dictionary with structure
- 471                {'variables':2D-array of samples, 'scores': function values on samples}
- 472                or path to .npz file (str) with saved generation; if 'scores' value is None the scores will be compute
+ 470            start_generation: initial generation object of any `GenerationConvertible` type
+ 471
+ 472            studEA: using stud EA strategy (crossover with best object always)
  473
- 474            studEA: using stud EA strategy (crossover with best object always)
+ 474            mutation_indexes: indexes of dimensions where mutation can be performed (all dimensions by default)
  475
- 476            mutation_indexes: indexes of dimensions where mutation can be performed (all dimensions by default)
- 477
- 478            init_creator: the function creates population samples.
- 479                By default -- random uniform for real variables and random uniform for int
- 480            init_oppositors: the list of oppositors creates oppositions for base population. No by default
- 481            duplicates_oppositor: oppositor for applying after duplicates removing.
- 482                By default -- using just random initializer from creator
- 483            remove_duplicates_generation_step: step for removing duplicates (have a sense with discrete tasks).
- 484                No by default
+ 476            init_creator: the function creates population samples.
+ 477                By default -- random uniform for real variables and random uniform for int
+ 478            init_oppositors: the list of oppositors creates oppositions for base population. No by default
+ 479
+ 480            duplicates_oppositor: oppositor for applying after duplicates removing.
+ 481                By default -- using just random initializer from creator
+ 482            remove_duplicates_generation_step: step for removing duplicates (have a sense with discrete tasks).
+ 483                No by default
+ 484
  485            revolution_oppositor: oppositor for revolution time. No by default
  486            revolution_after_stagnation_step: create revolution after this generations of stagnation. No by default
  487            revolution_part: float, the part of generation to being oppose. By default is 0.3
@@ -634,7 +634,7 @@ 

  494            callbacks: sequence of callback functions with structure:
  495                (generation_number, report_list, last_population, last_scores) -> do some action
  496
- 497            middle_callbacks: sequence of functions made MiddleCallbacks class
+ 497            middle_callbacks: sequence of functions made `MiddleCallback` class
  498
  499            time_limit_secs: limit time of working (in seconds)
  500
@@ -1369,443 +1369,441 @@ 

 
     

     
-            
  50class GeneticAlgorithm2:
-  51    """
-  52    Genetic algorithm optimization process
-  53    """
-  54    
-  55    default_params = AlgorithmParams()
-  56    PROGRESS_BAR_LEN = 20
-  57    """max count of symbols in the progress bar"""
-  58
-  59    @property
-  60    def output_dict(self):
-  61        warnings.warn(
-  62            "'output_dict' is deprecated and will be removed at version 7 \n"
-  63            "use 'result' instead"
-  64        )
-  65        return self.result
-  66
-  67    @property
-  68    def needs_mutation(self) -> bool:
-  69        """whether the mutation is required"""
-  70        return self.prob_mut > 0 or self.prob_mut_discrete > 0
-  71
-  72    #region INIT
+            
  52class GeneticAlgorithm2:
+  53    """
+  54    Genetic algorithm optimization process
+  55    """
+  56    
+  57    default_params = AlgorithmParams()
+  58    PROGRESS_BAR_LEN = 20
+  59    """max count of symbols in the progress bar"""
+  60
+  61    @property
+  62    def output_dict(self):
+  63        warnings.warn(
+  64            "'output_dict' is deprecated and will be removed at version 7 \n"
+  65            "use 'result' instead"
+  66        )
+  67        return self.result
+  68
+  69    @property
+  70    def needs_mutation(self) -> bool:
+  71        """whether the mutation is required"""
+  72        return self.prob_mut > 0 or self.prob_mut_discrete > 0
   73
-  74    def __init__(
-  75        self,
-  76        function: FunctionToMinimize,
-  77
-  78        dimension: int,
-  79        variable_type: Union[VARIABLE_TYPE, Sequence[VARIABLE_TYPE]] = 'bool',
-  80        variable_boundaries: Optional[Union[array2D, Sequence[Tuple[float, float]]]] = None,
-  81
-  82        variable_type_mixed=None,
+  74    #region INIT
+  75
+  76    def __init__(
+  77        self,
+  78        function: FunctionToMinimize,
+  79
+  80        dimension: int,
+  81        variable_type: Union[VARIABLE_TYPE, Sequence[VARIABLE_TYPE]] = 'bool',
+  82        variable_boundaries: Optional[Union[array2D, Sequence[Tuple[float, float]]]] = None,
   83
-  84        function_timeout: Optional[float] = None,
-  85        algorithm_parameters: Union[AlgorithmParams, Dict[str, Any]] = default_params
-  86    ):
-  87        """
-  88        initializes the GA object and performs main checks
-  89
-  90        Args:
-  91            function: the given objective function to be minimized
-  92            dimension: the number of decision variables, the population samples dimention
-  93
-  94            variable_type: string means the variable type for all variables,
-  95                for mixed types use sequence of strings of type for each variable
-  96
-  97            variable_boundaries: leave it None if variable_type is 'bool';
-  98                otherwise provide a sequence of tuples of length two as boundaries for each variable;
-  99                the length of the array must be equal dimension.
- 100                For example, ([0,100], [0,200]) determines
- 101                    lower boundary 0 and upper boundary 100 for first
- 102                    and upper boundary 200 for second variable
- 103                    and dimension must be 2.
- 104
- 105            variable_type_mixed -- deprecated
+  84        variable_type_mixed=None,
+  85
+  86        function_timeout: Optional[float] = None,
+  87        algorithm_parameters: Union[AlgorithmParams, Dict[str, Any]] = default_params
+  88    ):
+  89        """
+  90        initializes the GA object and performs main checks
+  91
+  92        Args:
+  93            function: the given objective function to be minimized
+  94            dimension: the number of decision variables, the population samples dimention
+  95
+  96            variable_type: string means the variable type for all variables,
+  97                for mixed types use sequence of strings of type for each variable
+  98
+  99            variable_boundaries: leave it None if variable_type is 'bool';
+ 100                otherwise provide a sequence of tuples of length two as boundaries for each variable;
+ 101                the length of the array must be equal dimension.
+ 102                For example, ([0,100], [0,200]) determines
+ 103                    lower boundary 0 and upper boundary 100 for first
+ 104                    and upper boundary 200 for second variable
+ 105                    and dimension must be 2.
  106
- 107            function_timeout: if the given function does not provide
- 108                output before function_timeout (unit is seconds) the algorithm raises error.
- 109                For example, when there is an infinite loop in the given function.
- 110                `None` means disabling
- 111
- 112            algorithm_parameters: AlgorithmParams object or usual dictionary with algorithm parameter;
- 113                it is not mandatory to provide all possible parameters
- 114
- 115        Notes:
- 116            - This implementation minimizes the given objective function.
- 117            For maximization u can multiply the function by -1 (for instance): the absolute
- 118                value of the output would be the actual objective function
- 119
- 120        for more details and examples of implementation please visit:
- 121            https://github.com/PasaOpasen/geneticalgorithm2
- 122  
- 123        """
- 124
- 125        # all default fields
+ 107            variable_type_mixed -- deprecated
+ 108
+ 109            function_timeout: if the given function does not provide
+ 110                output before function_timeout (unit is seconds) the algorithm raises error.
+ 111                For example, when there is an infinite loop in the given function.
+ 112                `None` means disabling
+ 113
+ 114            algorithm_parameters: AlgorithmParams object or usual dictionary with algorithm parameter;
+ 115                it is not mandatory to provide all possible parameters
+ 116
+ 117        Notes:
+ 118            - This implementation minimizes the given objective function.
+ 119            For maximization u can multiply the function by -1 (for instance): the absolute
+ 120                value of the output would be the actual objective function
+ 121
+ 122        for more details and examples of implementation please visit:
+ 123            https://github.com/PasaOpasen/geneticalgorithm2
+ 124  
+ 125        """
  126
- 127        # self.crossover: Callable[[np.ndarray, np.ndarray], Tuple[np.ndarray, np.ndarray]] = None
- 128        # self.real_mutation: Callable[[float, float, float], float] = None
- 129        # self.discrete_mutation: Callable[[int, int, int], int] = None
- 130        # self.selection: Callable[[np.ndarray, int], np.ndarray] = None
- 131
- 132        self.f: Callable[[array1D], float] = None
- 133        self.funtimeout: float = None
- 134        self.set_function: Callable[[np.ndarray], np.ndarray] = None
- 135
- 136        # self.dim: int = None
- 137        self.var_bounds: List[Tuple[Union[int, float], Union[int, float]]] = None
- 138        # self.indexes_int: np.ndarray = None
- 139        # self.indexes_float: np.ndarray = None
- 140
- 141        self.checked_reports: List[Tuple[str, Callable[[array1D], None]]] = None
+ 127        # all default fields
+ 128
+ 129        # self.crossover: Callable[[np.ndarray, np.ndarray], Tuple[np.ndarray, np.ndarray]] = None
+ 130        # self.real_mutation: Callable[[float, float, float], float] = None
+ 131        # self.discrete_mutation: Callable[[int, int, int], int] = None
+ 132        # self.selection: Callable[[np.ndarray, int], np.ndarray] = None
+ 133
+ 134        self.f: Callable[[array1D], float] = None
+ 135        self.funtimeout: float = None
+ 136        self.set_function: Callable[[np.ndarray], np.ndarray] = None
+ 137
+ 138        # self.dim: int = None
+ 139        self.var_bounds: List[Tuple[Union[int, float], Union[int, float]]] = None
+ 140        # self.indexes_int: np.ndarray = None
+ 141        # self.indexes_float: np.ndarray = None
  142
- 143        self.population_size: int = None
- 144        self.progress_stream = None
- 145
- 146        # input algorithm's parameters
+ 143        self.checked_reports: List[Tuple[str, Callable[[array1D], None]]] = None
+ 144
+ 145        self.population_size: int = None
+ 146        self.progress_stream = None
  147
- 148        assert isinstance(algorithm_parameters, (dict, AlgorithmParams)), (
- 149            "algorithm_parameters must be dict or AlgorithmParams object"
- 150        )
- 151        if not isinstance(algorithm_parameters, AlgorithmParams):
- 152            algorithm_parameters = AlgorithmParams.from_dict(algorithm_parameters)
- 153        algorithm_parameters.validate()
- 154        self.param = algorithm_parameters
- 155
- 156        self.crossover, self.real_mutation, self.discrete_mutation, self.selection = algorithm_parameters.get_CMS_funcs()
+ 148        # input algorithm's parameters
+ 149
+ 150        assert isinstance(algorithm_parameters, (dict, AlgorithmParams)), (
+ 151            "algorithm_parameters must be dict or AlgorithmParams object"
+ 152        )
+ 153        if not isinstance(algorithm_parameters, AlgorithmParams):
+ 154            algorithm_parameters = AlgorithmParams.from_dict(algorithm_parameters)
+ 155        algorithm_parameters.validate()
+ 156        self.param = algorithm_parameters
  157
- 158        # dimension and area bounds
- 159        self.dim = int(dimension)
- 160        assert self.dim > 0, f"dimension count must be int and >0, gotten {dimension}"
- 161
- 162        if variable_type_mixed is not None:
- 163            warnings.warn(
- 164                f"argument variable_type_mixed is deprecated and will be removed at version 7\n "
- 165                f"use variable_type={tuple(variable_type_mixed)} instead"
- 166            )
- 167            variable_type = variable_type_mixed
- 168        self._set_types_indexes(variable_type)  # types indexes
- 169        self._set_var_boundaries(variable_type, variable_boundaries)  # input variables' boundaries
- 170
- 171        # fix mutation probs
+ 158        self.crossover, self.real_mutation, self.discrete_mutation, self.selection = algorithm_parameters.get_CMS_funcs()
+ 159
+ 160        # dimension and area bounds
+ 161        self.dim = int(dimension)
+ 162        assert self.dim > 0, f"dimension count must be int and >0, gotten {dimension}"
+ 163
+ 164        if variable_type_mixed is not None:
+ 165            warnings.warn(
+ 166                f"argument variable_type_mixed is deprecated and will be removed at version 7\n "
+ 167                f"use variable_type={tuple(variable_type_mixed)} instead"
+ 168            )
+ 169            variable_type = variable_type_mixed
+ 170        self._set_types_indexes(variable_type)  # types indexes
+ 171        self._set_var_boundaries(variable_type, variable_boundaries)  # input variables' boundaries
  172
- 173        assert can_be_prob(self.param.mutation_probability)
- 174        self.prob_mut = self.param.mutation_probability
- 175        assert self.param.mutation_discrete_probability is None or can_be_prob(self.param.mutation_discrete_probability)
- 176        self.prob_mut_discrete = self.param.mutation_discrete_probability or self.prob_mut
- 177
- 178        if self.param.crossover_probability is not None:
- 179            warnings.warn(
- 180                f"crossover_probability is deprecated and will be removed in version 7. "
- 181                f"Reason: it's old and has no sense"
- 182            )
- 183
- 184        #############################################################
- 185        # input function
- 186        assert (callable(function)), "function must be callable!"
- 187        self.f = function
- 188
- 189        if function_timeout is not None and function_timeout > 0:
- 190            try:
- 191                from func_timeout import func_timeout, FunctionTimedOut
- 192            except ModuleNotFoundError:
- 193                raise ModuleNotFoundError(
- 194                    "function_timeout > 0 needs additional package func_timeout\n"
- 195                    "run `python -m pip install func_timeout`\n"
- 196                    "or disable this parameter: function_timeout=None"
- 197                )
- 198
- 199        self.funtimeout = None if function_timeout is None else float(function_timeout)
+ 173        # fix mutation probs
+ 174
+ 175        assert can_be_prob(self.param.mutation_probability)
+ 176        self.prob_mut = self.param.mutation_probability
+ 177        assert self.param.mutation_discrete_probability is None or can_be_prob(self.param.mutation_discrete_probability)
+ 178        self.prob_mut_discrete = self.param.mutation_discrete_probability or self.prob_mut
+ 179
+ 180        if self.param.crossover_probability is not None:
+ 181            warnings.warn(
+ 182                f"crossover_probability is deprecated and will be removed in version 7. "
+ 183                f"Reason: it's old and has no sense"
+ 184            )
+ 185
+ 186        #############################################################
+ 187        # input function
+ 188        assert (callable(function)), "function must be callable!"
+ 189        self.f = function
+ 190
+ 191        if function_timeout is not None and function_timeout > 0:
+ 192            try:
+ 193                from func_timeout import func_timeout, FunctionTimedOut
+ 194            except ModuleNotFoundError:
+ 195                raise ModuleNotFoundError(
+ 196                    "function_timeout > 0 needs additional package func_timeout\n"
+ 197                    "run `python -m pip install func_timeout`\n"
+ 198                    "or disable this parameter: function_timeout=None"
+ 199                )
  200
- 201        #############################################################
- 202        
- 203        self.population_size = int(self.param.population_size)
- 204        self._set_parents_count(self.param.parents_portion)
- 205        self._set_elit_count(self.population_size, self.param.elit_ratio)
- 206        assert self.parents_count >= self.elit_count, (
- 207            f"\n number of parents ({self.parents_count}) "
- 208            f"must be greater than number of elits ({self.elit_count})"
- 209        )
- 210
- 211        self._set_max_iterations()
+ 201        self.funtimeout = None if function_timeout is None else float(function_timeout)
+ 202
+ 203        #############################################################
+ 204        
+ 205        self.population_size = int(self.param.population_size)
+ 206        self._set_parents_count(self.param.parents_portion)
+ 207        self._set_elit_count(self.population_size, self.param.elit_ratio)
+ 208        assert self.parents_count >= self.elit_count, (
+ 209            f"\n number of parents ({self.parents_count}) "
+ 210            f"must be greater than number of elits ({self.elit_count})"
+ 211        )
  212
- 213        self._set_report()
+ 213        self._set_max_iterations()
  214
- 215        # specify this function to speed up or change default behaviour
- 216        self.fill_children: Optional[Callable[[array2D, int], None]] = None
- 217        """
- 218        custom function which adds children for population POP 
- 219            where POP[:parents_count] are parents lines and next lines are for children
- 220        """
- 221
- 222    def _set_types_indexes(self, variable_type: Union[str, Sequence[str]]):
+ 215        self._set_report()
+ 216
+ 217        # specify this function to speed up or change default behaviour
+ 218        self.fill_children: Optional[Callable[[array2D, int], None]] = None
+ 219        """
+ 220        custom function which adds children for population POP 
+ 221            where POP[:parents_count] are parents lines and next lines are for children
+ 222        """
  223
- 224        indexes = np.arange(self.dim)
- 225        self.indexes_int = np.array([])
- 226        self.indexes_float = np.array([])
- 227
- 228        assert_message = (
- 229            f"\n variable_type must be 'bool', 'int', 'real' or a sequence with 'int' and 'real', got {variable_type}"
- 230        )
- 231
- 232        if isinstance(variable_type, str):
- 233            assert (variable_type in VARIABLE_TYPE.__args__), assert_message
- 234            if variable_type == 'real':
- 235                self.indexes_float = indexes
- 236            else:
- 237                self.indexes_int = indexes
- 238
- 239        else:  # sequence case
+ 224    def _set_types_indexes(self, variable_type: Union[str, Sequence[str]]):
+ 225
+ 226        indexes = np.arange(self.dim)
+ 227        self.indexes_int = np.array([])
+ 228        self.indexes_float = np.array([])
+ 229
+ 230        assert_message = (
+ 231            f"\n variable_type must be 'bool', 'int', 'real' or a sequence with 'int' and 'real', got {variable_type}"
+ 232        )
+ 233
+ 234        if isinstance(variable_type, str):
+ 235            assert (variable_type in VARIABLE_TYPE.__args__), assert_message
+ 236            if variable_type == 'real':
+ 237                self.indexes_float = indexes
+ 238            else:
+ 239                self.indexes_int = indexes
  240
- 241            assert len(variable_type) == self.dim, (
- 242                f"\n variable_type must have a length equal dimension. "
- 243                f"Should be {self.dim}, got {len(variable_type)}"
- 244            )
- 245            assert 'bool' not in variable_type, (
- 246                "don't use 'bool' if variable_type is a sequence, "
- 247                "for 'boolean' case use 'int' and specify boundary as (0,1)"
- 248            )
- 249            assert all(v in VARIABLE_TYPE.__args__ for v in variable_type), assert_message
- 250
- 251            vartypes = np.array(variable_type)
- 252            self.indexes_int = indexes[vartypes == 'int']
- 253            self.indexes_float = indexes[vartypes == 'real']
- 254
- 255    def _set_var_boundaries(
- 256        self,
- 257        variable_type: Union[str, Sequence[str]],
- 258        variable_boundaries
- 259    ):
- 260        if isinstance(variable_type, str) and variable_type == 'bool':
- 261            self.var_bounds = [(0, 1)] * self.dim
- 262        else:
- 263
- 264            if is_numpy(variable_boundaries):
- 265                assert variable_boundaries.shape == (self.dim, 2), (
- 266                    f"\n if variable_boundaries is numpy array, it must be with shape (dim, 2)"
- 267                )
- 268            else:
- 269                assert len(variable_boundaries) == self.dim and all((len(t) == 2 for t in variable_boundaries)), (
- 270                    "\n if variable_boundaries is sequence, "
- 271                    "it must be with len dim and boundary for each variable must be a tuple of length two"
- 272                )
- 273
- 274            for i in variable_boundaries:
- 275                assert i[0] <= i[1], "\n lower_boundaries must be smaller than upper_boundaries [lower,upper]"
- 276
- 277            self.var_bounds = [(i[0], i[1]) for i in variable_boundaries]
+ 241        else:  # sequence case
+ 242
+ 243            assert len(variable_type) == self.dim, (
+ 244                f"\n variable_type must have a length equal dimension. "
+ 245                f"Should be {self.dim}, got {len(variable_type)}"
+ 246            )
+ 247            assert 'bool' not in variable_type, (
+ 248                "don't use 'bool' if variable_type is a sequence, "
+ 249                "for 'boolean' case use 'int' and specify boundary as (0,1)"
+ 250            )
+ 251            assert all(v in VARIABLE_TYPE.__args__ for v in variable_type), assert_message
+ 252
+ 253            vartypes = np.array(variable_type)
+ 254            self.indexes_int = indexes[vartypes == 'int']
+ 255            self.indexes_float = indexes[vartypes == 'real']
+ 256
+ 257    def _set_var_boundaries(
+ 258        self,
+ 259        variable_type: Union[str, Sequence[str]],
+ 260        variable_boundaries
+ 261    ):
+ 262        if isinstance(variable_type, str) and variable_type == 'bool':
+ 263            self.var_bounds = [(0, 1)] * self.dim
+ 264        else:
+ 265
+ 266            if is_numpy(variable_boundaries):
+ 267                assert variable_boundaries.shape == (self.dim, 2), (
+ 268                    f"\n if variable_boundaries is numpy array, it must be with shape (dim, 2)"
+ 269                )
+ 270            else:
+ 271                assert len(variable_boundaries) == self.dim and all((len(t) == 2 for t in variable_boundaries)), (
+ 272                    "\n if variable_boundaries is sequence, "
+ 273                    "it must be with len dim and boundary for each variable must be a tuple of length two"
+ 274                )
+ 275
+ 276            for i in variable_boundaries:
+ 277                assert i[0] <= i[1], "\n lower_boundaries must be smaller than upper_boundaries [lower,upper]"
  278
- 279    def _set_parents_count(self, parents_portion: float):
+ 279            self.var_bounds = [(i[0], i[1]) for i in variable_boundaries]
  280
- 281        self.parents_count = int(parents_portion * self.population_size)
- 282        assert self.population_size >= self.parents_count > 1, (
- 283            f'parents count {self.parents_count} cannot be less than population size {self.population_size}'
- 284        )
- 285        trl = self.population_size - self.parents_count
- 286        if trl % 2 != 0:
- 287            self.parents_count += 1
- 288
- 289    def _set_elit_count(self, pop_size: int, elit_ratio: Union[float, int]):
+ 281    def _set_parents_count(self, parents_portion: float):
+ 282
+ 283        self.parents_count = int(parents_portion * self.population_size)
+ 284        assert self.population_size >= self.parents_count > 1, (
+ 285            f'parents count {self.parents_count} cannot be less than population size {self.population_size}'
+ 286        )
+ 287        trl = self.population_size - self.parents_count
+ 288        if trl % 2 != 0:
+ 289            self.parents_count += 1
  290
- 291        assert elit_ratio >= 0
- 292        self.elit_count = elit_ratio if isinstance(elit_ratio, str) else math.ceil(pop_size*elit_ratio)
- 293
- 294    def _set_max_iterations(self):
+ 291    def _set_elit_count(self, pop_size: int, elit_ratio: Union[float, int]):
+ 292
+ 293        assert elit_ratio >= 0
+ 294        self.elit_count = elit_ratio if isinstance(elit_ratio, str) else math.ceil(pop_size*elit_ratio)
  295
- 296        if self.param.max_num_iteration is None:
- 297            iterate = 0
- 298            for i in range(0, self.dim):
- 299                bound_min, bound_max = self.var_bounds[i]
- 300                var_space = bound_max - bound_min
- 301                if i in self.indexes_int:
- 302                    iterate += var_space * self.dim * (100 / self.population_size)
- 303                else:
- 304                    iterate += var_space * 50 * (100 / self.population_size)
- 305            iterate = int(iterate)
- 306            if (iterate * self.population_size) > 10000000:
- 307                iterate = 10000000 / self.population_size
- 308
- 309            self.max_iterations = fast_min(iterate, 8000)
- 310        else:
- 311            assert self.param.max_num_iteration > 0
- 312            self.max_iterations = math.ceil(self.param.max_num_iteration)
- 313
- 314        max_it = self.param.max_iteration_without_improv
- 315        if max_it is None:
- 316            self.max_stagnations = self.max_iterations + 1
- 317        else:
- 318            self.max_stagnations = math.ceil(max_it)
- 319
- 320    #endregion
+ 296    def _set_max_iterations(self):
+ 297
+ 298        if self.param.max_num_iteration is None:
+ 299            iterate = 0
+ 300            for i in range(0, self.dim):
+ 301                bound_min, bound_max = self.var_bounds[i]
+ 302                var_space = bound_max - bound_min
+ 303                if i in self.indexes_int:
+ 304                    iterate += var_space * self.dim * (100 / self.population_size)
+ 305                else:
+ 306                    iterate += var_space * 50 * (100 / self.population_size)
+ 307            iterate = int(iterate)
+ 308            if (iterate * self.population_size) > 10000000:
+ 309                iterate = 10000000 / self.population_size
+ 310
+ 311            self.max_iterations = fast_min(iterate, 8000)
+ 312        else:
+ 313            assert self.param.max_num_iteration > 0
+ 314            self.max_iterations = math.ceil(self.param.max_num_iteration)
+ 315
+ 316        max_it = self.param.max_iteration_without_improv
+ 317        if max_it is None:
+ 318            self.max_stagnations = self.max_iterations + 1
+ 319        else:
+ 320            self.max_stagnations = math.ceil(max_it)
  321
- 322    #region REPORT
+ 322    #endregion
  323
- 324    def _set_report(self):
- 325        """
- 326        creates default report checker
- 327        """
- 328        self.checked_reports = [
- 329            # item 0 cuz scores will be sorted and min item is items[0]
- 330            ('report', operator.itemgetter(0))
- 331        ]
- 332
- 333    def _clear_report(self):
- 334        """
- 335        removes all report objects
- 336        """
- 337        fields = [f for f in vars(self).keys() if f.startswith('report')]
- 338        for attr in fields:
- 339            delattr(self, attr)
- 340
- 341    def _init_report(self):
- 342        """
- 343        makes empty report fields
- 344        """
- 345        for name, _ in self.checked_reports:
- 346            setattr(self, name, [])
- 347
- 348    def _update_report(self, scores: array1D):
- 349        """
- 350        append report value to the end of field
- 351        """
- 352        for name, func in self.checked_reports:
- 353            getattr(self, name).append(
- 354                func(scores)
- 355            )
- 356
- 357    #endregion
+ 324    #region REPORT
+ 325
+ 326    def _set_report(self):
+ 327        """
+ 328        creates default report checker
+ 329        """
+ 330        self.checked_reports = [
+ 331            # item 0 cuz scores will be sorted and min item is items[0]
+ 332            ('report', operator.itemgetter(0))
+ 333        ]
+ 334
+ 335    def _clear_report(self):
+ 336        """
+ 337        removes all report objects
+ 338        """
+ 339        fields = [f for f in vars(self).keys() if f.startswith('report')]
+ 340        for attr in fields:
+ 341            delattr(self, attr)
+ 342
+ 343    def _init_report(self):
+ 344        """
+ 345        makes empty report fields
+ 346        """
+ 347        for name, _ in self.checked_reports:
+ 348            setattr(self, name, [])
+ 349
+ 350    def _update_report(self, scores: array1D):
+ 351        """
+ 352        append report value to the end of field
+ 353        """
+ 354        for name, func in self.checked_reports:
+ 355            getattr(self, name).append(
+ 356                func(scores)
+ 357            )
  358
- 359    #region RUN METHODS
+ 359    #endregion
  360
- 361    def _progress(self, count: int, total: int, status: str = ''):
+ 361    #region RUN METHODS
  362
- 363        part = count / total
+ 363    def _progress(self, count: int, total: int, status: str = ''):
  364
- 365        filled_len = round(GeneticAlgorithm2.PROGRESS_BAR_LEN * part)
- 366        percents = round(100.0 * part, 1)
- 367        bar = '|' * filled_len + '_' * (GeneticAlgorithm2.PROGRESS_BAR_LEN - filled_len)
- 368
- 369        self.progress_stream.write('\r%s %s%s %s' % (bar, percents, '%', status))
- 370        self.progress_stream.flush()
- 371
- 372    def __str__(self):
- 373        return f"Genetic algorithm object with parameters {self.param}"
- 374
- 375    def __repr__(self):
- 376        return self.__str__()
- 377
- 378    def _simulate(self, sample: array1D):
+ 365        part = count / total
+ 366
+ 367        filled_len = round(GeneticAlgorithm2.PROGRESS_BAR_LEN * part)
+ 368        percents = round(100.0 * part, 1)
+ 369        bar = '|' * filled_len + '_' * (GeneticAlgorithm2.PROGRESS_BAR_LEN - filled_len)
+ 370
+ 371        self.progress_stream.write('\r%s %s%s %s' % (bar, percents, '%', status))
+ 372        self.progress_stream.flush()
+ 373
+ 374    def __str__(self):
+ 375        return f"Genetic algorithm object with parameters {self.param}"
+ 376
+ 377    def __repr__(self):
+ 378        return self.__str__()
  379
- 380        from func_timeout import func_timeout, FunctionTimedOut
+ 380    def _simulate(self, sample: array1D):
  381
- 382        obj = None
- 383        eval_time = time.time()
- 384        try:
- 385            obj = func_timeout(
- 386                self.funtimeout,
- 387                lambda: self.f(sample)
- 388            )
- 389        except FunctionTimedOut:
- 390            print("given function is not applicable")
- 391        eval_time = time.time() - eval_time
- 392
- 393        assert obj is not None, (
- 394            f"the given function was running like {eval_time} seconds and does not provide any output"
- 395        )
- 396
- 397        tp = type(obj)
- 398        assert (
- 399            tp in (int, float) or np.issubdtype(tp, np.floating) or np.issubdtype(tp, np.integer)
- 400        ), f"Minimized function should return a number, but got '{obj}' object with type {tp}"
- 401
- 402        return obj, eval_time
+ 382        from func_timeout import func_timeout, FunctionTimedOut
+ 383
+ 384        obj = None
+ 385        eval_time = time.time()
+ 386        try:
+ 387            obj = func_timeout(
+ 388                self.funtimeout,
+ 389                lambda: self.f(sample)
+ 390            )
+ 391        except FunctionTimedOut:
+ 392            print("given function is not applicable")
+ 393        eval_time = time.time() - eval_time
+ 394
+ 395        assert obj is not None, (
+ 396            f"the given function was running like {eval_time} seconds and does not provide any output"
+ 397        )
+ 398
+ 399        tp = type(obj)
+ 400        assert (
+ 401            tp in (int, float) or np.issubdtype(tp, np.floating) or np.issubdtype(tp, np.integer)
+ 402        ), f"Minimized function should return a number, but got '{obj}' object with type {tp}"
  403
- 404    def _set_mutation_indexes(self, mutation_indexes: Optional[Sequence[int]]):
+ 404        return obj, eval_time
  405
- 406        if mutation_indexes is None:
- 407            self.indexes_float_mut = self.indexes_float
- 408            self.indexes_int_mut = self.indexes_int
- 409        else:
- 410            tmp_indexes = set(mutation_indexes)
- 411            self.indexes_int_mut = np.array(list(tmp_indexes.intersection(self.indexes_int)))
- 412            self.indexes_float_mut = np.array(list(tmp_indexes.intersection(self.indexes_float)))
- 413
- 414            if self.indexes_float_mut.size == 0 and self.indexes_int_mut.size == 0:
- 415                warnings.warn(f"No mutation dimensions!!! Check ur mutation indexes!!")
- 416
- 417    #@profile
- 418    def run(
- 419        self,
- 420        no_plot: bool = False,
- 421        disable_printing: bool = False,
- 422        progress_bar_stream: Optional[str] = 'stdout',
- 423
- 424        # deprecated
- 425        disable_progress_bar: bool = False,
- 426
- 427        set_function: SetFunctionToMinimize = None,
- 428        apply_function_to_parents: bool = False,
- 429        start_generation: GenerationConvertible = Generation(),
- 430        studEA: bool = False,
- 431        mutation_indexes: Optional[Union[Sequence[int], Set[int]]] = None,
- 432
- 433        init_creator: Optional[Callable[[], array1D]] = None,
- 434        init_oppositors: Optional[Sequence[Callable[[array1D], array1D]]] = None,
- 435
- 436        duplicates_oppositor: Optional[Callable[[array1D], array1D]] = None,
- 437        remove_duplicates_generation_step: Optional[int] = None,
- 438
- 439        revolution_oppositor: Optional[Callable[[array1D], array1D]] = None,
- 440        revolution_after_stagnation_step: Optional[int] = None,
- 441        revolution_part: float = 0.3,
- 442
- 443        population_initializer: Tuple[
- 444            int, Callable[[array2D, array1D], Tuple[array2D, array1D]]
- 445        ] = get_population_initializer(select_best_of=1, local_optimization_step='never', local_optimizer=None),
- 446
- 447        stop_when_reached: Optional[float] = None,
- 448        callbacks: Optional[Sequence[SimpleCallbackFunc]] = None,
- 449        middle_callbacks: Optional[Sequence[MiddleCallbackFunc]] = None,  #+
- 450        time_limit_secs: Optional[float] = None,
- 451        save_last_generation_as: Optional[str] = None,
- 452        seed: Optional[int] = None
- 453    ):
- 454        """
- 455        runs optimization process
- 456
- 457        Args:
- 458            no_plot: do not plot results using matplotlib by default
- 459
- 460            disable_printing: do not print log info of optimization process
+ 406    def _set_mutation_indexes(self, mutation_indexes: Optional[Iterable[int]]):
+ 407
+ 408        if mutation_indexes is None:
+ 409            self.indexes_float_mut = self.indexes_float
+ 410            self.indexes_int_mut = self.indexes_int
+ 411        else:
+ 412            tmp_indexes = set(mutation_indexes)
+ 413            self.indexes_int_mut = np.array(list(tmp_indexes.intersection(self.indexes_int)))
+ 414            self.indexes_float_mut = np.array(list(tmp_indexes.intersection(self.indexes_float)))
+ 415
+ 416            if self.indexes_float_mut.size == 0 and self.indexes_int_mut.size == 0:
+ 417                warnings.warn(f"No mutation dimensions!!! Check ur mutation indexes!!")
+ 418
+ 419    #@profile
+ 420    def run(
+ 421        self,
+ 422        no_plot: bool = False,
+ 423        disable_printing: bool = False,
+ 424        progress_bar_stream: Optional[str] = 'stdout',
+ 425
+ 426        # deprecated
+ 427        disable_progress_bar: bool = False,
+ 428
+ 429        set_function: SetFunctionToMinimize = None,
+ 430        apply_function_to_parents: bool = False,
+ 431        start_generation: GenerationConvertible = Generation(),
+ 432        studEA: bool = False,
+ 433        mutation_indexes: Optional[Iterable[int]] = None,
+ 434
+ 435        init_creator: Optional[CreatorFunc] = None,
+ 436        init_oppositors: Optional[Sequence[OppositorFunc]] = None,
+ 437
+ 438        duplicates_oppositor: Optional[OppositorFunc] = None,
+ 439        remove_duplicates_generation_step: Optional[int] = None,
+ 440
+ 441        revolution_oppositor: Optional[OppositorFunc] = None,
+ 442        revolution_after_stagnation_step: Optional[int] = None,
+ 443        revolution_part: float = 0.3,
+ 444
+ 445        population_initializer: Tuple[
+ 446            int, PopulationModifier
+ 447        ] = get_population_initializer(select_best_of=1, local_optimization_step='never', local_optimizer=None),
+ 448
+ 449        stop_when_reached: Optional[float] = None,
+ 450        callbacks: Optional[Sequence[SimpleCallbackFunc]] = None,
+ 451        middle_callbacks: Optional[Sequence[MiddleCallbackFunc]] = None,  #+
+ 452        time_limit_secs: Optional[float] = None,
+ 453        save_last_generation_as: Optional[str] = None,
+ 454        seed: Optional[int] = None
+ 455    ):
+ 456        """
+ 457        runs optimization process
+ 458
+ 459        Args:
+ 460            no_plot: do not plot results using matplotlib by default
  461
- 462            progress_bar_stream: 'stdout', 'stderr' or None to disable progress bar
+ 462            disable_printing: do not print log info of optimization process
  463
- 464            disable_progress_bar:
+ 464            progress_bar_stream: 'stdout', 'stderr' or None to disable progress bar
  465
- 466            set_function : 2D-array -> 1D-array function,
- 467                which applyes to matrix of population (size (samples, dimention))
- 468                    to estimate their values
+ 466            disable_progress_bar: deprecated
+ 467
+ 468            set_function: set function to be used instead of usual function
  469
- 470            apply_function_to_parents: apply function to parents from previous generation (if it's needed)
+ 470            apply_function_to_parents: whether to apply function to parents from previous generation (if it's needed)
  471
- 472            start_generation: Generation object or a dictionary with structure
- 473                {'variables':2D-array of samples, 'scores': function values on samples}
- 474                or path to .npz file (str) with saved generation; if 'scores' value is None the scores will be compute
+ 472            start_generation: initial generation object of any `GenerationConvertible` type
+ 473
+ 474            studEA: using stud EA strategy (crossover with best object always)
  475
- 476            studEA: using stud EA strategy (crossover with best object always)
+ 476            mutation_indexes: indexes of dimensions where mutation can be performed (all dimensions by default)
  477
- 478            mutation_indexes: indexes of dimensions where mutation can be performed (all dimensions by default)
- 479
- 480            init_creator: the function creates population samples.
- 481                By default -- random uniform for real variables and random uniform for int
- 482            init_oppositors: the list of oppositors creates oppositions for base population. No by default
- 483            duplicates_oppositor: oppositor for applying after duplicates removing.
- 484                By default -- using just random initializer from creator
- 485            remove_duplicates_generation_step: step for removing duplicates (have a sense with discrete tasks).
- 486                No by default
+ 478            init_creator: the function creates population samples.
+ 479                By default -- random uniform for real variables and random uniform for int
+ 480            init_oppositors: the list of oppositors creates oppositions for base population. No by default
+ 481
+ 482            duplicates_oppositor: oppositor for applying after duplicates removing.
+ 483                By default -- using just random initializer from creator
+ 484            remove_duplicates_generation_step: step for removing duplicates (have a sense with discrete tasks).
+ 485                No by default
+ 486
  487            revolution_oppositor: oppositor for revolution time. No by default
  488            revolution_after_stagnation_step: create revolution after this generations of stagnation. No by default
  489            revolution_part: float, the part of generation to being oppose. By default is 0.3
@@ -1818,7 +1816,7 @@ 

  496            callbacks: sequence of callback functions with structure:
  497                (generation_number, report_list, last_population, last_scores) -> do some action
  498
- 499            middle_callbacks: sequence of functions made MiddleCallbacks class
+ 499            middle_callbacks: sequence of functions made `MiddleCallback` class
  500
  501            time_limit_secs: limit time of working (in seconds)
  502
@@ -2523,153 +2521,153 @@ 

 
     

     
-            
 74    def __init__(
- 75        self,
- 76        function: FunctionToMinimize,
- 77
- 78        dimension: int,
- 79        variable_type: Union[VARIABLE_TYPE, Sequence[VARIABLE_TYPE]] = 'bool',
- 80        variable_boundaries: Optional[Union[array2D, Sequence[Tuple[float, float]]]] = None,
- 81
- 82        variable_type_mixed=None,
+            
 76    def __init__(
+ 77        self,
+ 78        function: FunctionToMinimize,
+ 79
+ 80        dimension: int,
+ 81        variable_type: Union[VARIABLE_TYPE, Sequence[VARIABLE_TYPE]] = 'bool',
+ 82        variable_boundaries: Optional[Union[array2D, Sequence[Tuple[float, float]]]] = None,
  83
- 84        function_timeout: Optional[float] = None,
- 85        algorithm_parameters: Union[AlgorithmParams, Dict[str, Any]] = default_params
- 86    ):
- 87        """
- 88        initializes the GA object and performs main checks
- 89
- 90        Args:
- 91            function: the given objective function to be minimized
- 92            dimension: the number of decision variables, the population samples dimention
- 93
- 94            variable_type: string means the variable type for all variables,
- 95                for mixed types use sequence of strings of type for each variable
- 96
- 97            variable_boundaries: leave it None if variable_type is 'bool';
- 98                otherwise provide a sequence of tuples of length two as boundaries for each variable;
- 99                the length of the array must be equal dimension.
-100                For example, ([0,100], [0,200]) determines
-101                    lower boundary 0 and upper boundary 100 for first
-102                    and upper boundary 200 for second variable
-103                    and dimension must be 2.
-104
-105            variable_type_mixed -- deprecated
+ 84        variable_type_mixed=None,
+ 85
+ 86        function_timeout: Optional[float] = None,
+ 87        algorithm_parameters: Union[AlgorithmParams, Dict[str, Any]] = default_params
+ 88    ):
+ 89        """
+ 90        initializes the GA object and performs main checks
+ 91
+ 92        Args:
+ 93            function: the given objective function to be minimized
+ 94            dimension: the number of decision variables, the population samples dimention
+ 95
+ 96            variable_type: string means the variable type for all variables,
+ 97                for mixed types use sequence of strings of type for each variable
+ 98
+ 99            variable_boundaries: leave it None if variable_type is 'bool';
+100                otherwise provide a sequence of tuples of length two as boundaries for each variable;
+101                the length of the array must be equal dimension.
+102                For example, ([0,100], [0,200]) determines
+103                    lower boundary 0 and upper boundary 100 for first
+104                    and upper boundary 200 for second variable
+105                    and dimension must be 2.
 106
-107            function_timeout: if the given function does not provide
-108                output before function_timeout (unit is seconds) the algorithm raises error.
-109                For example, when there is an infinite loop in the given function.
-110                `None` means disabling
-111
-112            algorithm_parameters: AlgorithmParams object or usual dictionary with algorithm parameter;
-113                it is not mandatory to provide all possible parameters
-114
-115        Notes:
-116            - This implementation minimizes the given objective function.
-117            For maximization u can multiply the function by -1 (for instance): the absolute
-118                value of the output would be the actual objective function
-119
-120        for more details and examples of implementation please visit:
-121            https://github.com/PasaOpasen/geneticalgorithm2
-122  
-123        """
-124
-125        # all default fields
+107            variable_type_mixed -- deprecated
+108
+109            function_timeout: if the given function does not provide
+110                output before function_timeout (unit is seconds) the algorithm raises error.
+111                For example, when there is an infinite loop in the given function.
+112                `None` means disabling
+113
+114            algorithm_parameters: AlgorithmParams object or usual dictionary with algorithm parameter;
+115                it is not mandatory to provide all possible parameters
+116
+117        Notes:
+118            - This implementation minimizes the given objective function.
+119            For maximization u can multiply the function by -1 (for instance): the absolute
+120                value of the output would be the actual objective function
+121
+122        for more details and examples of implementation please visit:
+123            https://github.com/PasaOpasen/geneticalgorithm2
+124  
+125        """
 126
-127        # self.crossover: Callable[[np.ndarray, np.ndarray], Tuple[np.ndarray, np.ndarray]] = None
-128        # self.real_mutation: Callable[[float, float, float], float] = None
-129        # self.discrete_mutation: Callable[[int, int, int], int] = None
-130        # self.selection: Callable[[np.ndarray, int], np.ndarray] = None
-131
-132        self.f: Callable[[array1D], float] = None
-133        self.funtimeout: float = None
-134        self.set_function: Callable[[np.ndarray], np.ndarray] = None
-135
-136        # self.dim: int = None
-137        self.var_bounds: List[Tuple[Union[int, float], Union[int, float]]] = None
-138        # self.indexes_int: np.ndarray = None
-139        # self.indexes_float: np.ndarray = None
-140
-141        self.checked_reports: List[Tuple[str, Callable[[array1D], None]]] = None
+127        # all default fields
+128
+129        # self.crossover: Callable[[np.ndarray, np.ndarray], Tuple[np.ndarray, np.ndarray]] = None
+130        # self.real_mutation: Callable[[float, float, float], float] = None
+131        # self.discrete_mutation: Callable[[int, int, int], int] = None
+132        # self.selection: Callable[[np.ndarray, int], np.ndarray] = None
+133
+134        self.f: Callable[[array1D], float] = None
+135        self.funtimeout: float = None
+136        self.set_function: Callable[[np.ndarray], np.ndarray] = None
+137
+138        # self.dim: int = None
+139        self.var_bounds: List[Tuple[Union[int, float], Union[int, float]]] = None
+140        # self.indexes_int: np.ndarray = None
+141        # self.indexes_float: np.ndarray = None
 142
-143        self.population_size: int = None
-144        self.progress_stream = None
-145
-146        # input algorithm's parameters
+143        self.checked_reports: List[Tuple[str, Callable[[array1D], None]]] = None
+144
+145        self.population_size: int = None
+146        self.progress_stream = None
 147
-148        assert isinstance(algorithm_parameters, (dict, AlgorithmParams)), (
-149            "algorithm_parameters must be dict or AlgorithmParams object"
-150        )
-151        if not isinstance(algorithm_parameters, AlgorithmParams):
-152            algorithm_parameters = AlgorithmParams.from_dict(algorithm_parameters)
-153        algorithm_parameters.validate()
-154        self.param = algorithm_parameters
-155
-156        self.crossover, self.real_mutation, self.discrete_mutation, self.selection = algorithm_parameters.get_CMS_funcs()
+148        # input algorithm's parameters
+149
+150        assert isinstance(algorithm_parameters, (dict, AlgorithmParams)), (
+151            "algorithm_parameters must be dict or AlgorithmParams object"
+152        )
+153        if not isinstance(algorithm_parameters, AlgorithmParams):
+154            algorithm_parameters = AlgorithmParams.from_dict(algorithm_parameters)
+155        algorithm_parameters.validate()
+156        self.param = algorithm_parameters
 157
-158        # dimension and area bounds
-159        self.dim = int(dimension)
-160        assert self.dim > 0, f"dimension count must be int and >0, gotten {dimension}"
-161
-162        if variable_type_mixed is not None:
-163            warnings.warn(
-164                f"argument variable_type_mixed is deprecated and will be removed at version 7\n "
-165                f"use variable_type={tuple(variable_type_mixed)} instead"
-166            )
-167            variable_type = variable_type_mixed
-168        self._set_types_indexes(variable_type)  # types indexes
-169        self._set_var_boundaries(variable_type, variable_boundaries)  # input variables' boundaries
-170
-171        # fix mutation probs
+158        self.crossover, self.real_mutation, self.discrete_mutation, self.selection = algorithm_parameters.get_CMS_funcs()
+159
+160        # dimension and area bounds
+161        self.dim = int(dimension)
+162        assert self.dim > 0, f"dimension count must be int and >0, gotten {dimension}"
+163
+164        if variable_type_mixed is not None:
+165            warnings.warn(
+166                f"argument variable_type_mixed is deprecated and will be removed at version 7\n "
+167                f"use variable_type={tuple(variable_type_mixed)} instead"
+168            )
+169            variable_type = variable_type_mixed
+170        self._set_types_indexes(variable_type)  # types indexes
+171        self._set_var_boundaries(variable_type, variable_boundaries)  # input variables' boundaries
 172
-173        assert can_be_prob(self.param.mutation_probability)
-174        self.prob_mut = self.param.mutation_probability
-175        assert self.param.mutation_discrete_probability is None or can_be_prob(self.param.mutation_discrete_probability)
-176        self.prob_mut_discrete = self.param.mutation_discrete_probability or self.prob_mut
-177
-178        if self.param.crossover_probability is not None:
-179            warnings.warn(
-180                f"crossover_probability is deprecated and will be removed in version 7. "
-181                f"Reason: it's old and has no sense"
-182            )
-183
-184        #############################################################
-185        # input function
-186        assert (callable(function)), "function must be callable!"
-187        self.f = function
-188
-189        if function_timeout is not None and function_timeout > 0:
-190            try:
-191                from func_timeout import func_timeout, FunctionTimedOut
-192            except ModuleNotFoundError:
-193                raise ModuleNotFoundError(
-194                    "function_timeout > 0 needs additional package func_timeout\n"
-195                    "run `python -m pip install func_timeout`\n"
-196                    "or disable this parameter: function_timeout=None"
-197                )
-198
-199        self.funtimeout = None if function_timeout is None else float(function_timeout)
+173        # fix mutation probs
+174
+175        assert can_be_prob(self.param.mutation_probability)
+176        self.prob_mut = self.param.mutation_probability
+177        assert self.param.mutation_discrete_probability is None or can_be_prob(self.param.mutation_discrete_probability)
+178        self.prob_mut_discrete = self.param.mutation_discrete_probability or self.prob_mut
+179
+180        if self.param.crossover_probability is not None:
+181            warnings.warn(
+182                f"crossover_probability is deprecated and will be removed in version 7. "
+183                f"Reason: it's old and has no sense"
+184            )
+185
+186        #############################################################
+187        # input function
+188        assert (callable(function)), "function must be callable!"
+189        self.f = function
+190
+191        if function_timeout is not None and function_timeout > 0:
+192            try:
+193                from func_timeout import func_timeout, FunctionTimedOut
+194            except ModuleNotFoundError:
+195                raise ModuleNotFoundError(
+196                    "function_timeout > 0 needs additional package func_timeout\n"
+197                    "run `python -m pip install func_timeout`\n"
+198                    "or disable this parameter: function_timeout=None"
+199                )
 200
-201        #############################################################
-202        
-203        self.population_size = int(self.param.population_size)
-204        self._set_parents_count(self.param.parents_portion)
-205        self._set_elit_count(self.population_size, self.param.elit_ratio)
-206        assert self.parents_count >= self.elit_count, (
-207            f"\n number of parents ({self.parents_count}) "
-208            f"must be greater than number of elits ({self.elit_count})"
-209        )
-210
-211        self._set_max_iterations()
+201        self.funtimeout = None if function_timeout is None else float(function_timeout)
+202
+203        #############################################################
+204        
+205        self.population_size = int(self.param.population_size)
+206        self._set_parents_count(self.param.parents_portion)
+207        self._set_elit_count(self.population_size, self.param.elit_ratio)
+208        assert self.parents_count >= self.elit_count, (
+209            f"\n number of parents ({self.parents_count}) "
+210            f"must be greater than number of elits ({self.elit_count})"
+211        )
 212
-213        self._set_report()
+213        self._set_max_iterations()
 214
-215        # specify this function to speed up or change default behaviour
-216        self.fill_children: Optional[Callable[[array2D, int], None]] = None
-217        """
-218        custom function which adds children for population POP 
-219            where POP[:parents_count] are parents lines and next lines are for children
-220        """
+215        self._set_report()
+216
+217        # specify this function to speed up or change default behaviour
+218        self.fill_children: Optional[Callable[[array2D, int], None]] = None
+219        """
+220        custom function which adds children for population POP 
+221            where POP[:parents_count] are parents lines and next lines are for children
+222        """
 

 
 
@@ -2750,13 +2748,13 @@ 
Notes:

 
     

     
-            
59    @property
-60    def output_dict(self):
-61        warnings.warn(
-62            "'output_dict' is deprecated and will be removed at version 7 \n"
-63            "use 'result' instead"
-64        )
-65        return self.result
+            
61    @property
+62    def output_dict(self):
+63        warnings.warn(
+64            "'output_dict' is deprecated and will be removed at version 7 \n"
+65            "use 'result' instead"
+66        )
+67        return self.result
 

 
 
@@ -2772,10 +2770,10 @@ 
Notes:

 
     

     
-            
67    @property
-68    def needs_mutation(self) -> bool:
-69        """whether the mutation is required"""
-70        return self.prob_mut > 0 or self.prob_mut_discrete > 0
+            
69    @property
+70    def needs_mutation(self) -> bool:
+71        """whether the mutation is required"""
+72        return self.prob_mut > 0 or self.prob_mut_discrete > 0
 

 
 
@@ -2924,81 +2922,79 @@ 
Notes:

 

             
         def
-        run(	self,	no_plot: bool = False,	disable_printing: bool = False,	progress_bar_stream: Union[str, NoneType] = 'stdout',	disable_progress_bar: bool = False,	set_function: collections.abc.Callable[numpy.ndarray, numpy.ndarray] = None,	apply_function_to_parents: bool = False,	start_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),	studEA: bool = False,	mutation_indexes: Union[Sequence[int], Set[int], NoneType] = None,	init_creator: Union[collections.abc.Callable[numpy.ndarray], NoneType] = None,	init_oppositors: Union[collections.abc.Sequence[collections.abc.Callable[numpy.ndarray, numpy.ndarray]], NoneType] = None,	duplicates_oppositor: Union[collections.abc.Callable[numpy.ndarray, numpy.ndarray], NoneType] = None,	remove_duplicates_generation_step: Union[int, NoneType] = None,	revolution_oppositor: Union[collections.abc.Callable[numpy.ndarray, numpy.ndarray], NoneType] = None,	revolution_after_stagnation_step: Union[int, NoneType] = None,	revolution_part: float = 0.3,	population_initializer: tuple[int, collections.abc.Callable[numpy.ndarray, numpy.ndarray, tuple[numpy.ndarray, numpy.ndarray]]] = (1, <function get_population_initializer.<locals>.process_population>),	stop_when_reached: Union[float, NoneType] = None,	callbacks: Union[collections.abc.Sequence[collections.abc.Callable[int, List[float], numpy.ndarray, numpy.ndarray, NoneType]], NoneType] = None,	middle_callbacks: Union[Sequence[Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], Tuple[geneticalgorithm2.callbacks.data.MiddleCallbackData, bool]]], NoneType] = None,	time_limit_secs: Union[float, NoneType] = None,	save_last_generation_as: Union[str, NoneType] = None,	seed: Union[int, NoneType] = None):
+        run(	self,	no_plot: bool = False,	disable_printing: bool = False,	progress_bar_stream: Union[str, NoneType] = 'stdout',	disable_progress_bar: bool = False,	set_function: collections.abc.Callable[numpy.ndarray, numpy.ndarray] = None,	apply_function_to_parents: bool = False,	start_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),	studEA: bool = False,	mutation_indexes: Union[Iterable[int], NoneType] = None,	init_creator: Union[Callable[[], numpy.ndarray], NoneType] = None,	init_oppositors: Union[Sequence[Callable[[numpy.ndarray], numpy.ndarray]], NoneType] = None,	duplicates_oppositor: Union[Callable[[numpy.ndarray], numpy.ndarray], NoneType] = None,	remove_duplicates_generation_step: Union[int, NoneType] = None,	revolution_oppositor: Union[Callable[[numpy.ndarray], numpy.ndarray], NoneType] = None,	revolution_after_stagnation_step: Union[int, NoneType] = None,	revolution_part: float = 0.3,	population_initializer: tuple[int, collections.abc.Callable[numpy.ndarray, numpy.ndarray, tuple[numpy.ndarray, numpy.ndarray]]] = (1, <function get_population_initializer.<locals>.process_population>),	stop_when_reached: Union[float, NoneType] = None,	callbacks: Union[collections.abc.Sequence[collections.abc.Callable[int, List[float], numpy.ndarray, numpy.ndarray, NoneType]], NoneType] = None,	middle_callbacks: Union[Sequence[Callable[[geneticalgorithm2.callbacks.data.MiddleCallbackData], Tuple[geneticalgorithm2.callbacks.data.MiddleCallbackData, bool]]], NoneType] = None,	time_limit_secs: Union[float, NoneType] = None,	save_last_generation_as: Union[str, NoneType] = None,	seed: Union[int, NoneType] = None):
 
                 
 
     

     
-            
 418    def run(
- 419        self,
- 420        no_plot: bool = False,
- 421        disable_printing: bool = False,
- 422        progress_bar_stream: Optional[str] = 'stdout',
- 423
- 424        # deprecated
- 425        disable_progress_bar: bool = False,
- 426
- 427        set_function: SetFunctionToMinimize = None,
- 428        apply_function_to_parents: bool = False,
- 429        start_generation: GenerationConvertible = Generation(),
- 430        studEA: bool = False,
- 431        mutation_indexes: Optional[Union[Sequence[int], Set[int]]] = None,
- 432
- 433        init_creator: Optional[Callable[[], array1D]] = None,
- 434        init_oppositors: Optional[Sequence[Callable[[array1D], array1D]]] = None,
- 435
- 436        duplicates_oppositor: Optional[Callable[[array1D], array1D]] = None,
- 437        remove_duplicates_generation_step: Optional[int] = None,
- 438
- 439        revolution_oppositor: Optional[Callable[[array1D], array1D]] = None,
- 440        revolution_after_stagnation_step: Optional[int] = None,
- 441        revolution_part: float = 0.3,
- 442
- 443        population_initializer: Tuple[
- 444            int, Callable[[array2D, array1D], Tuple[array2D, array1D]]
- 445        ] = get_population_initializer(select_best_of=1, local_optimization_step='never', local_optimizer=None),
- 446
- 447        stop_when_reached: Optional[float] = None,
- 448        callbacks: Optional[Sequence[SimpleCallbackFunc]] = None,
- 449        middle_callbacks: Optional[Sequence[MiddleCallbackFunc]] = None,  #+
- 450        time_limit_secs: Optional[float] = None,
- 451        save_last_generation_as: Optional[str] = None,
- 452        seed: Optional[int] = None
- 453    ):
- 454        """
- 455        runs optimization process
- 456
- 457        Args:
- 458            no_plot: do not plot results using matplotlib by default
- 459
- 460            disable_printing: do not print log info of optimization process
+            
 420    def run(
+ 421        self,
+ 422        no_plot: bool = False,
+ 423        disable_printing: bool = False,
+ 424        progress_bar_stream: Optional[str] = 'stdout',
+ 425
+ 426        # deprecated
+ 427        disable_progress_bar: bool = False,
+ 428
+ 429        set_function: SetFunctionToMinimize = None,
+ 430        apply_function_to_parents: bool = False,
+ 431        start_generation: GenerationConvertible = Generation(),
+ 432        studEA: bool = False,
+ 433        mutation_indexes: Optional[Iterable[int]] = None,
+ 434
+ 435        init_creator: Optional[CreatorFunc] = None,
+ 436        init_oppositors: Optional[Sequence[OppositorFunc]] = None,
+ 437
+ 438        duplicates_oppositor: Optional[OppositorFunc] = None,
+ 439        remove_duplicates_generation_step: Optional[int] = None,
+ 440
+ 441        revolution_oppositor: Optional[OppositorFunc] = None,
+ 442        revolution_after_stagnation_step: Optional[int] = None,
+ 443        revolution_part: float = 0.3,
+ 444
+ 445        population_initializer: Tuple[
+ 446            int, PopulationModifier
+ 447        ] = get_population_initializer(select_best_of=1, local_optimization_step='never', local_optimizer=None),
+ 448
+ 449        stop_when_reached: Optional[float] = None,
+ 450        callbacks: Optional[Sequence[SimpleCallbackFunc]] = None,
+ 451        middle_callbacks: Optional[Sequence[MiddleCallbackFunc]] = None,  #+
+ 452        time_limit_secs: Optional[float] = None,
+ 453        save_last_generation_as: Optional[str] = None,
+ 454        seed: Optional[int] = None
+ 455    ):
+ 456        """
+ 457        runs optimization process
+ 458
+ 459        Args:
+ 460            no_plot: do not plot results using matplotlib by default
  461
- 462            progress_bar_stream: 'stdout', 'stderr' or None to disable progress bar
+ 462            disable_printing: do not print log info of optimization process
  463
- 464            disable_progress_bar:
+ 464            progress_bar_stream: 'stdout', 'stderr' or None to disable progress bar
  465
- 466            set_function : 2D-array -> 1D-array function,
- 467                which applyes to matrix of population (size (samples, dimention))
- 468                    to estimate their values
+ 466            disable_progress_bar: deprecated
+ 467
+ 468            set_function: set function to be used instead of usual function
  469
- 470            apply_function_to_parents: apply function to parents from previous generation (if it's needed)
+ 470            apply_function_to_parents: whether to apply function to parents from previous generation (if it's needed)
  471
- 472            start_generation: Generation object or a dictionary with structure
- 473                {'variables':2D-array of samples, 'scores': function values on samples}
- 474                or path to .npz file (str) with saved generation; if 'scores' value is None the scores will be compute
+ 472            start_generation: initial generation object of any `GenerationConvertible` type
+ 473
+ 474            studEA: using stud EA strategy (crossover with best object always)
  475
- 476            studEA: using stud EA strategy (crossover with best object always)
+ 476            mutation_indexes: indexes of dimensions where mutation can be performed (all dimensions by default)
  477
- 478            mutation_indexes: indexes of dimensions where mutation can be performed (all dimensions by default)
- 479
- 480            init_creator: the function creates population samples.
- 481                By default -- random uniform for real variables and random uniform for int
- 482            init_oppositors: the list of oppositors creates oppositions for base population. No by default
- 483            duplicates_oppositor: oppositor for applying after duplicates removing.
- 484                By default -- using just random initializer from creator
- 485            remove_duplicates_generation_step: step for removing duplicates (have a sense with discrete tasks).
- 486                No by default
+ 478            init_creator: the function creates population samples.
+ 479                By default -- random uniform for real variables and random uniform for int
+ 480            init_oppositors: the list of oppositors creates oppositions for base population. No by default
+ 481
+ 482            duplicates_oppositor: oppositor for applying after duplicates removing.
+ 483                By default -- using just random initializer from creator
+ 484            remove_duplicates_generation_step: step for removing duplicates (have a sense with discrete tasks).
+ 485                No by default
+ 486
  487            revolution_oppositor: oppositor for revolution time. No by default
  488            revolution_after_stagnation_step: create revolution after this generations of stagnation. No by default
  489            revolution_part: float, the part of generation to being oppose. By default is 0.3
@@ -3011,7 +3007,7 @@ 
Notes:

  496            callbacks: sequence of callback functions with structure:
  497                (generation_number, report_list, last_population, last_scores) -> do some action
  498
- 499            middle_callbacks: sequence of functions made MiddleCallbacks class
+ 499            middle_callbacks: sequence of functions made `MiddleCallback` class
  500
  501            time_limit_secs: limit time of working (in seconds)
  502
@@ -3579,14 +3575,10 @@ 
Arguments:

 
  • no_plot:  do not plot results using matplotlib by default
    • 
 
  • disable_printing:  do not print log info of optimization process
    • 
 
  • progress_bar_stream:  'stdout', 'stderr' or None to disable progress bar
    • 
-
  • disable_progress_bar: 
    • 
-
  • set_function :  2D-array -> 1D-array function,
-which applyes to matrix of population (size (samples, dimention))
-    to estimate their values
    • 
-
  • apply_function_to_parents:  apply function to parents from previous generation (if it's needed)
    • 
-
  • start_generation:  Generation object or a dictionary with structure
-{'variables':2D-array of samples, 'scores': function values on samples}
-or path to .npz file (str) with saved generation; if 'scores' value is None the scores will be compute
    • 
+
  • disable_progress_bar:  deprecated
    • 
+
  • set_function:  set function to be used instead of usual function
    • 
+
  • apply_function_to_parents:  whether to apply function to parents from previous generation (if it's needed)
    • 
+
  • start_generation:  initial generation object of any GenerationConvertible type
    • 
 
  • studEA:  using stud EA strategy (crossover with best object always)
    • 
 
  • mutation_indexes:  indexes of dimensions where mutation can be performed (all dimensions by default)
    • 
 
  • init_creator:  the function creates population samples.
@@ -3604,7 +3596,7 @@ 
    Arguments:
    
 
  • stop_when_reached:  stop searching after reaching this value (it can be potential minimum or something else)
    • 
 
  • callbacks:  sequence of callback functions with structure:
 (generation_number, report_list, last_population, last_scores) -> do some action
    • 
-
  • middle_callbacks:  sequence of functions made MiddleCallbacks class
    • 
+
  • middle_callbacks:  sequence of functions made MiddleCallback class
    • 
 
  • time_limit_secs:  limit time of working (in seconds)
    • 
 
  • save_last_generation_as:  path to .npz file for saving last_generation as numpy dictionary like
 {'population': 2D-array, 'scores': 1D-array}, None if doesn't need to save in file
    • 
diff --git a/docs/geneticalgorithm2/population_initializer.html b/docs/geneticalgorithm2/population_initializer.html
index 949a99b..6edd301 100644
--- a/docs/geneticalgorithm2/population_initializer.html
+++ b/docs/geneticalgorithm2/population_initializer.html
@@ -31,6 +31,9 @@
 
             
    API Documentation
    
                 
      
+            
    • 
+                    PopulationModifier
+            
      • 
             
    • 
                     LOCAL_OPTIMIZATION_STEP_CASE
             
      • 
@@ -67,90 +70,112 @@ 
      
  5from .utils.aliases import TypeAlias, array1D, array2D
  6
  7
- 8LOCAL_OPTIMIZATION_STEP_CASE: TypeAlias = Literal['before_select', 'after_select', 'never']
+ 8PopulationModifier: TypeAlias = Callable[[array2D, array1D], Tuple[array2D, array1D]]
  9"""
-10When the local optimization (candidates enhancing) must be performed:
-11    * 'never' -- don't do local optimization
-12    * 'before_select' -- before selection best N objects 
-13        (example: do local optimization for 5N objects and select N best results)
-14    * 'after_select' -- do local optimization on best selected N objects
+10function (population matrix, population scores) -> (new matrix, new scores)
+11which will perform the bests selection and local optimization and other population transformations
+12"""
+13
+14LOCAL_OPTIMIZATION_STEP_CASE: TypeAlias = Literal['before_select', 'after_select', 'never']
 15"""
-16
-17
-18def get_population_initializer(
-19    select_best_of: int = 4,
-20    local_optimization_step: LOCAL_OPTIMIZATION_STEP_CASE = 'never',
-21    local_optimizer: Optional[
-22        Callable[
-23            [array1D, float],
-24            Tuple[array1D, float]
-25        ]
-26    ] = None
-27) -> Tuple[int, Callable[[array2D, array1D], Tuple[array2D, array1D]]]:
-28    """
-29    Args:
-30        select_best_of: determines population size to select 1/select_best_of best part of start population.
-31            For example, for select_best_of = 4 and population_size = N there will be selected N best objects
-32                from 5N generated objects (if start_generation=None dictionary).
-33            If start_generation is not None dictionary, there will be selected best (start_generation) / N objects
-34        local_optimization_step: when to perform local optimization
-35        local_optimizer: the local optimization function (object array, its score) -> (modified array, its score)
-36
-37    Returns:
-38        select_best_of, function which will perform the selection and local optimization
-39    """
-40    
-41    assert select_best_of > 0 and isinstance(select_best_of, int), (select_best_of, type(select_best_of))
+16When the local optimization (candidates enhancing) must be performed:
+17    * 'never' -- don't do local optimization
+18    * 'before_select' -- before selection best N objects 
+19        (example: do local optimization for 5N objects and select N best results)
+20    * 'after_select' -- do local optimization on best selected N objects
+21"""
+22
+23
+24def get_population_initializer(
+25    select_best_of: int = 4,
+26    local_optimization_step: LOCAL_OPTIMIZATION_STEP_CASE = 'never',
+27    local_optimizer: Optional[
+28        Callable[
+29            [array1D, float],
+30            Tuple[array1D, float]
+31        ]
+32    ] = None
+33) -> Tuple[int, PopulationModifier]:
+34    """
+35    Args:
+36        select_best_of: determines population size to select 1/select_best_of best part of start population.
+37            For example, for select_best_of = 4 and population_size = N there will be selected N best objects
+38                from 5N generated objects (if start_generation=None dictionary).
+39            If start_generation is not None dictionary, there will be selected best (start_generation) / N objects
+40        local_optimization_step: when to perform local optimization
+41        local_optimizer: the local optimization function (object array, its score) -> (modified array, its score)
 42
-43    assert local_optimization_step in LOCAL_OPTIMIZATION_STEP_CASE.__args__, (
-44        local_optimization_step, LOCAL_OPTIMIZATION_STEP_CASE.__args__
-45    )
-46
-47    if local_optimizer is None and local_optimization_step in LOCAL_OPTIMIZATION_STEP_CASE.__args__[:2]:
-48        raise Exception(
-49            f"for local_optimization_step from {LOCAL_OPTIMIZATION_STEP_CASE.__args__[:2]} "
-50            f"local_optimizer function mustn't be None"
-51        )
+43    Returns:
+44        select_best_of, population modifier
+45    """
+46    
+47    assert select_best_of > 0 and isinstance(select_best_of, int), (select_best_of, type(select_best_of))
+48
+49    assert local_optimization_step in LOCAL_OPTIMIZATION_STEP_CASE.__args__, (
+50        local_optimization_step, LOCAL_OPTIMIZATION_STEP_CASE.__args__
+51    )
 52
-53    def select_best(population: array2D, scores: array1D) -> Tuple[array2D, array1D]:
-54        args = np.argsort(scores)
-55        args = args[:round(args.size/select_best_of)]
-56        return population[args], scores[args]
-57
-58    def local_opt(population: array2D, scores: array1D):
-59        _pop, _score = zip(
-60            *[
-61                local_optimizer(population[i], scores[i]) for i in range(scores.size)
-62            ]
-63        )
-64        return np.array(_pop), np.array(_score)
-65
-66    #def Create_population(func, start_generation, expected_size, #variable_boundaries):
-67    #    
-68    #    if not (start_generation['variables'] is None):
-69    #        pop = start_generation['variables']
-70    #        scores = start_generation['scores']
-71    #        if scores is None:
-72    #            scores = np.array([func(pop[i, :]) for i in range(pop.shape[0])])
-73    #        return pop, scores
-74
-75    def process_population(population: array2D, scores: array1D):
-76        if local_optimization_step == 'before_select':
-77            pop, s = local_opt(population, scores)
-78            return select_best(pop, s)
-79
-80        if local_optimization_step == 'after_select':
-81            pop, s = select_best(population, scores)
-82            return local_opt(pop, s)
-83
-84        #if local_optimization_step == 'never':
-85        return select_best(population, scores)
-86
-87    return select_best_of, process_population
+53    if local_optimizer is None and local_optimization_step in LOCAL_OPTIMIZATION_STEP_CASE.__args__[:2]:
+54        raise Exception(
+55            f"for local_optimization_step from {LOCAL_OPTIMIZATION_STEP_CASE.__args__[:2]} "
+56            f"local_optimizer function mustn't be None"
+57        )
+58
+59    def select_best(population: array2D, scores: array1D) -> Tuple[array2D, array1D]:
+60        args = np.argsort(scores)
+61        args = args[:round(args.size/select_best_of)]
+62        return population[args], scores[args]
+63
+64    def local_opt(population: array2D, scores: array1D):
+65        _pop, _score = zip(
+66            *[
+67                local_optimizer(population[i], scores[i]) for i in range(scores.size)
+68            ]
+69        )
+70        return np.array(_pop), np.array(_score)
+71
+72    #def Create_population(func, start_generation, expected_size, #variable_boundaries):
+73    #    
+74    #    if not (start_generation['variables'] is None):
+75    #        pop = start_generation['variables']
+76    #        scores = start_generation['scores']
+77    #        if scores is None:
+78    #            scores = np.array([func(pop[i, :]) for i in range(pop.shape[0])])
+79    #        return pop, scores
+80
+81    def process_population(population: array2D, scores: array1D):
+82        if local_optimization_step == 'before_select':
+83            pop, s = local_opt(population, scores)
+84            return select_best(pop, s)
+85
+86        if local_optimization_step == 'after_select':
+87            pop, s = select_best(population, scores)
+88            return local_opt(pop, s)
+89
+90        #if local_optimization_step == 'never':
+91        return select_best(population, scores)
+92
+93    return select_best_of, process_population
 
    
 
 
             
+                
    
+                    
    
+            PopulationModifier: typing_extensions.TypeAlias        =
+
+            typing.Callable[[ForwardRef('np.ndarray'), ForwardRef('np.ndarray')], typing.Tuple[ForwardRef('np.ndarray'), ForwardRef('np.ndarray')]]
+
+        
+    
    
+    
+    
+            
    function (population matrix, population scores) -> (new matrix, new scores)
+which will perform the bests selection and local optimization and other population transformations
    
+
    
+
+
+                
    
                 
    
                     
    
             LOCAL_OPTIMIZATION_STEP_CASE: typing_extensions.TypeAlias        =
@@ -180,76 +205,76 @@ 
    
 
     
    
     
-            
    20def get_population_initializer(
-21    select_best_of: int = 4,
-22    local_optimization_step: LOCAL_OPTIMIZATION_STEP_CASE = 'never',
-23    local_optimizer: Optional[
-24        Callable[
-25            [array1D, float],
-26            Tuple[array1D, float]
-27        ]
-28    ] = None
-29) -> Tuple[int, Callable[[array2D, array1D], Tuple[array2D, array1D]]]:
-30    """
-31    Args:
-32        select_best_of: determines population size to select 1/select_best_of best part of start population.
-33            For example, for select_best_of = 4 and population_size = N there will be selected N best objects
-34                from 5N generated objects (if start_generation=None dictionary).
-35            If start_generation is not None dictionary, there will be selected best (start_generation) / N objects
-36        local_optimization_step: when to perform local optimization
-37        local_optimizer: the local optimization function (object array, its score) -> (modified array, its score)
-38
-39    Returns:
-40        select_best_of, function which will perform the selection and local optimization
-41    """
-42    
-43    assert select_best_of > 0 and isinstance(select_best_of, int), (select_best_of, type(select_best_of))
+            
    26def get_population_initializer(
+27    select_best_of: int = 4,
+28    local_optimization_step: LOCAL_OPTIMIZATION_STEP_CASE = 'never',
+29    local_optimizer: Optional[
+30        Callable[
+31            [array1D, float],
+32            Tuple[array1D, float]
+33        ]
+34    ] = None
+35) -> Tuple[int, PopulationModifier]:
+36    """
+37    Args:
+38        select_best_of: determines population size to select 1/select_best_of best part of start population.
+39            For example, for select_best_of = 4 and population_size = N there will be selected N best objects
+40                from 5N generated objects (if start_generation=None dictionary).
+41            If start_generation is not None dictionary, there will be selected best (start_generation) / N objects
+42        local_optimization_step: when to perform local optimization
+43        local_optimizer: the local optimization function (object array, its score) -> (modified array, its score)
 44
-45    assert local_optimization_step in LOCAL_OPTIMIZATION_STEP_CASE.__args__, (
-46        local_optimization_step, LOCAL_OPTIMIZATION_STEP_CASE.__args__
-47    )
-48
-49    if local_optimizer is None and local_optimization_step in LOCAL_OPTIMIZATION_STEP_CASE.__args__[:2]:
-50        raise Exception(
-51            f"for local_optimization_step from {LOCAL_OPTIMIZATION_STEP_CASE.__args__[:2]} "
-52            f"local_optimizer function mustn't be None"
-53        )
+45    Returns:
+46        select_best_of, population modifier
+47    """
+48    
+49    assert select_best_of > 0 and isinstance(select_best_of, int), (select_best_of, type(select_best_of))
+50
+51    assert local_optimization_step in LOCAL_OPTIMIZATION_STEP_CASE.__args__, (
+52        local_optimization_step, LOCAL_OPTIMIZATION_STEP_CASE.__args__
+53    )
 54
-55    def select_best(population: array2D, scores: array1D) -> Tuple[array2D, array1D]:
-56        args = np.argsort(scores)
-57        args = args[:round(args.size/select_best_of)]
-58        return population[args], scores[args]
-59
-60    def local_opt(population: array2D, scores: array1D):
-61        _pop, _score = zip(
-62            *[
-63                local_optimizer(population[i], scores[i]) for i in range(scores.size)
-64            ]
-65        )
-66        return np.array(_pop), np.array(_score)
-67
-68    #def Create_population(func, start_generation, expected_size, #variable_boundaries):
-69    #    
-70    #    if not (start_generation['variables'] is None):
-71    #        pop = start_generation['variables']
-72    #        scores = start_generation['scores']
-73    #        if scores is None:
-74    #            scores = np.array([func(pop[i, :]) for i in range(pop.shape[0])])
-75    #        return pop, scores
-76
-77    def process_population(population: array2D, scores: array1D):
-78        if local_optimization_step == 'before_select':
-79            pop, s = local_opt(population, scores)
-80            return select_best(pop, s)
-81
-82        if local_optimization_step == 'after_select':
-83            pop, s = select_best(population, scores)
-84            return local_opt(pop, s)
-85
-86        #if local_optimization_step == 'never':
-87        return select_best(population, scores)
-88
-89    return select_best_of, process_population
+55    if local_optimizer is None and local_optimization_step in LOCAL_OPTIMIZATION_STEP_CASE.__args__[:2]:
+56        raise Exception(
+57            f"for local_optimization_step from {LOCAL_OPTIMIZATION_STEP_CASE.__args__[:2]} "
+58            f"local_optimizer function mustn't be None"
+59        )
+60
+61    def select_best(population: array2D, scores: array1D) -> Tuple[array2D, array1D]:
+62        args = np.argsort(scores)
+63        args = args[:round(args.size/select_best_of)]
+64        return population[args], scores[args]
+65
+66    def local_opt(population: array2D, scores: array1D):
+67        _pop, _score = zip(
+68            *[
+69                local_optimizer(population[i], scores[i]) for i in range(scores.size)
+70            ]
+71        )
+72        return np.array(_pop), np.array(_score)
+73
+74    #def Create_population(func, start_generation, expected_size, #variable_boundaries):
+75    #    
+76    #    if not (start_generation['variables'] is None):
+77    #        pop = start_generation['variables']
+78    #        scores = start_generation['scores']
+79    #        if scores is None:
+80    #            scores = np.array([func(pop[i, :]) for i in range(pop.shape[0])])
+81    #        return pop, scores
+82
+83    def process_population(population: array2D, scores: array1D):
+84        if local_optimization_step == 'before_select':
+85            pop, s = local_opt(population, scores)
+86            return select_best(pop, s)
+87
+88        if local_optimization_step == 'after_select':
+89            pop, s = select_best(population, scores)
+90            return local_opt(pop, s)
+91
+92        #if local_optimization_step == 'never':
+93        return select_best(population, scores)
+94
+95    return select_best_of, process_population
 
    
 
 
@@ -267,7 +292,7 @@ 
    
 
    Returns:
    
 
 
    
-  
    select_best_of, function which will perform the selection and local optimization
    
+  
    select_best_of, population modifier
    
 
    
 
    
 
diff --git a/docs/search.js b/docs/search.js
index 250ec80..9eabe84 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\ncode 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, function which will perform the selection and local optimization
    \n
    \n", "signature": "(\tselect_best_of: int = 4,\tlocal_optimization_step: Literal['before_select', 'after_select', 'never'] = 'never',\tlocal_optimizer: Union[collections.abc.Callable[numpy.ndarray, float, tuple[numpy.ndarray, float]], NoneType] = None) -> tuple[int, collections.abc.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[[ForwardRef('np.ndarray'), ForwardRef('np.ndarray')], Tuple[ForwardRef('np.ndarray'), ForwardRef('np.ndarray')]],\tselection: Callable[[ForwardRef('np.ndarray'), int], ForwardRef('np.ndarray')],\tcurrent_stagnation: int,\tmax_stagnation: int,\tparents_portion: float,\telit_ratio: float,\tset_function: Callable[[ForwardRef('np.ndarray')], ForwardRef('np.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[[ForwardRef('np.ndarray'), ForwardRef('np.ndarray')], Tuple[ForwardRef('np.ndarray'), ForwardRef('np.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[[ForwardRef('np.ndarray'), int], ForwardRef('np.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[[ForwardRef('np.ndarray')], ForwardRef('np.ndarray')]"}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"fullname": "geneticalgorithm2.callbacks.data.SimpleCallbackFunc", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "SimpleCallbackFunc", "kind": "variable", "doc": "
    Callback function perform 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], ForwardRef('np.ndarray'), ForwardRef('np.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: collections.abc.Sequence[collections.abc.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: collections.abc.Sequence[collections.abc.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[collections.abc.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') -> collections.abc.Callable[int, typing.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') -> collections.abc.Callable[int, typing.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[[ForwardRef('np.ndarray'), ForwardRef('np.ndarray')], typing.Tuple[ForwardRef('np.ndarray'), ForwardRef('np.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, collections.abc.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": "() -> collections.abc.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": "() -> collections.abc.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": "() -> collections.abc.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) -> collections.abc.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": "() -> collections.abc.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) -> collections.abc.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": "() -> collections.abc.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) -> collections.abc.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[[ForwardRef('np.ndarray'), ForwardRef('np.ndarray')], Tuple[ForwardRef('np.ndarray'), ForwardRef('np.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[[ForwardRef('np.ndarray'), int], ForwardRef('np.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", "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", "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": "
    \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": "
    \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": "
    \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[[ForwardRef('np.ndarray'), ForwardRef('np.ndarray')], Tuple[ForwardRef('np.ndarray'), ForwardRef('np.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[[ForwardRef('np.ndarray'), int], ForwardRef('np.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[[ForwardRef('np.ndarray'), ForwardRef('np.ndarray')], Tuple[ForwardRef('np.ndarray'), ForwardRef('np.ndarray')]], Callable[[float, float, float], float], Callable[[int, int, int], int], Callable[[ForwardRef('np.ndarray'), int], ForwardRef('np.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[[ForwardRef('np.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[[ForwardRef('np.ndarray')], ForwardRef('np.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'], ForwardRef('np.ndarray')], ForwardRef('np.ndarray'), typing.Tuple[typing.Union[ForwardRef('np.ndarray'), NoneType], typing.Union[ForwardRef('np.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": ": 'np.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
      • \n
    • dimension:  the number of decision variables, the population samples dimention
      • \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
      • \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: collections.abc.Callable[numpy.ndarray, float],\tdimension: int,\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.f": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.f", "kind": "variable", "doc": "
    \n", "annotation": ": collections.abc.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, collections.abc.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[collections.abc.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: 
      • \n
    • set_function :  2D-array -> 1D-array function,\nwhich applyes to matrix of population (size (samples, dimention))\n    to estimate their values
      • \n
    • apply_function_to_parents:  apply function to parents from previous generation (if it's needed)
      • \n
    • start_generation:  Generation object or a dictionary with structure\n{'variables':2D-array of samples, 'scores': function values on samples}\nor path to .npz file (str) with saved generation; if 'scores' value is None the scores will be compute
      • \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 MiddleCallbacks 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", "signature": "(\tself,\tno_plot: bool = False,\tdisable_printing: bool = False,\tprogress_bar_stream: Union[str, NoneType] = 'stdout',\tdisable_progress_bar: bool = False,\tset_function: collections.abc.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[Sequence[int], Set[int], NoneType] = None,\tinit_creator: Union[collections.abc.Callable[numpy.ndarray], NoneType] = None,\tinit_oppositors: Union[collections.abc.Sequence[collections.abc.Callable[numpy.ndarray, numpy.ndarray]], NoneType] = None,\tduplicates_oppositor: Union[collections.abc.Callable[numpy.ndarray, numpy.ndarray], NoneType] = None,\tremove_duplicates_generation_step: Union[int, NoneType] = None,\trevolution_oppositor: Union[collections.abc.Callable[numpy.ndarray, numpy.ndarray], NoneType] = None,\trevolution_after_stagnation_step: Union[int, NoneType] = None,\trevolution_part: float = 0.3,\tpopulation_initializer: tuple[int, collections.abc.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[collections.abc.Sequence[collections.abc.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: collections.abc.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: collections.abc.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": "(\tfunction_for_set: collections.abc.Callable[numpy.ndarray, float],\tn_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.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, function which will perform the selection and local optimization
    \n
    \n", "signature": "(\tselect_best_of: int = 4,\tlocal_optimization_step: Literal['before_select', 'after_select', 'never'] = 'never',\tlocal_optimizer: Union[collections.abc.Callable[numpy.ndarray, float, tuple[numpy.ndarray, float]], NoneType] = None) -> tuple[int, collections.abc.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[[ForwardRef('np.ndarray'), int], ForwardRef('np.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, collections.abc.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": "() -> collections.abc.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": "() -> collections.abc.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": "() -> collections.abc.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) -> collections.abc.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": "() -> collections.abc.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) -> collections.abc.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": "(\ttau: int = 2) -> collections.abc.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": "'np.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": "'np.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": 43}, "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": 230, "bases": 0, "doc": 124}, "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": 408, "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": 23, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"qualname": 2, "fullname": 5, "annotation": 13, "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": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"qualname": 1, "fullname": 4, "annotation": 4, "default_value": 16, "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": 135, "bases": 0, "doc": 5}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 115, "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": 202, "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": 139, "bases": 0, "doc": 7}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 180, "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": 24, "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": 78, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.one_point": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 68, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.two_point": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 68, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.uniform": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 68, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.segment": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 86, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 68, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 85, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 68, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.mixed": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 86, "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": 504, "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": 8}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"qualname": 5, "fullname": 10, "annotation": 3, "default_value": 1, "signature": 0, "bases": 0, "doc": 6}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "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": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 2, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"qualname": 3, "fullname": 8, "annotation": 24, "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": 14, "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": 188, "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": 8, "signature": 0, "bases": 0, "doc": 9}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"qualname": 1, "fullname": 5, "annotation": 4, "default_value": 13, "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": 42, "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": 6, "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": 479, "bases": 0, "doc": 264}, "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.f": {"qualname": 2, "fullname": 4, "annotation": 6, "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": 7, "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": 8, "default_value": 0, "signature": 0, "bases": 0, "doc": 22}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 1174, "bases": 0, "doc": 461}, "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": 45, "bases": 0, "doc": 18}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 45, "bases": 0, "doc": 24}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 68, "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.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": 230, "bases": 0, "doc": 124}, "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": 13, "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": 58, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.fully_random": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 48, "bases": 0, "doc": 13}, "geneticalgorithm2.selections.Selection.roulette": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 48, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.stochastic": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 48, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 85, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.ranking": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 48, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.linear_ranking": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 67, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.tournament": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 65, "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": 6, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.aliases.array2D": {"qualname": 1, "fullname": 4, "annotation": 4, "default_value": 6, "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": 189, "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.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": 27}, "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}}}}}}}}, "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}}, "df": 5, "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}}}}}}}}}}}}}}, "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}}}}}}}}}, "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}}}}}}}, "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, "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.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.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": 189}, "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.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 6}}}}}}}}, "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}}, "df": 5, "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.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 4}}}}}}}}}, "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}}}}}}}}}}}}, "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}}}}}}}, "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}}}}}}, "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, "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.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1.4142135623730951}, "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.7320508075688772}, "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.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.selection_type": {"tf": 1.4142135623730951}, "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.4142135623730951}, "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.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": 61, "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.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": 19}}}, "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.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": 19}}}}}, "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, "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.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.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": 19}}}}}}}}}}, "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, "o": {"docs": {}, "df": 0, "l": {"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": {}, "df": 0, "s": {"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}}}}}}}, "p": {"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.result.GAResult.variable": {"tf": 1}}, "df": 6}, "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.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1}}, "df": 1}}}}}, "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}}}}, "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.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}}, "df": 5}}}}}}}}}}, "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}}}}, "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.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}}, "df": 5}}}}}}}}}}, "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.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 3}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "l": {"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": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}}, "df": 2}}}}}}}}}}}, "x": {"2": {"7": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 2.8284271247461903}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 2}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 2}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 2.8284271247461903}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 2}, "geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1.4142135623730951}}, "df": 6}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 3}}}}}, "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.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.crossovers.CrossoverFunc": {"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.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1.4142135623730951}}, "df": 16, "l": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1}}, "df": 1}, "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}}, "df": 1}}}}, "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}}}}}}}}}}}}}}}}, "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.crossovers.CrossoverFunc": {"tf": 1}, "geneticalgorithm2.data_types.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}}, "df": 4}}}}}}}}}, "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.callbacks.data.SimpleCallbackFunc": {"tf": 2}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 2.8284271247461903}, "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.aliases.FunctionToMinimize": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 2}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 3.7416573867739413}, "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.selections.SelectionFunc": {"tf": 2}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1.4142135623730951}}, "df": 16}, "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}}, "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.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.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.utils.aliases.Number": {"tf": 1}, "geneticalgorithm2.utils.aliases.PathLike": {"tf": 1}}, "df": 16}}}, "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}}}}}}}}}}}}}}}}, "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.crossovers.CrossoverFunc": {"tf": 1}}, "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.data_types.generation.GenerationConvertible": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "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.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.selections.SelectionFunc": {"tf": 1}}, "df": 5}}}}}}}}}, "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}}}}}, "n": {"docs": {}, "df": 0, "p": {"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.selections.SelectionFunc": {"tf": 1.4142135623730951}, "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.selections.SelectionFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1}}, "df": 8}}}}}}, "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}}}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1}}, "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.7320508075688772}}, "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}}}}}, "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": 1.7320508075688772}, "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.data.MiddleCallbackData.__init__": {"tf": 4}, "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": 4.47213595499958}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 3.4641016151377544}, "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": 15}, "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": 13.341664064126334}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 17.52141546793523}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 7.681145747868608}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 7.54983443527075}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 10.44030650891055}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 9.643650760992955}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 10}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 12.884098726725126}, "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": 10.535653752852738}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 11.958260743101398}, "geneticalgorithm2.crossovers.get_copies": {"tf": 7.211102550927978}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 8}, "geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 7.483314773547883}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 7.483314773547883}, "geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 7.483314773547883}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 8.366600265340756}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 7.483314773547883}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 8.366600265340756}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 7.483314773547883}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 8.366600265340756}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 19.519221295943137}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 3.4641016151377544}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 11.916375287812984}, "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.81488772222678}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 30.463092423455635}, "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": 6}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 6}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 7.416198487095663}, "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": 13.341664064126334}, "geneticalgorithm2.selections.inverse_scores": {"tf": 4.898979485566356}, "geneticalgorithm2.selections.roulette": {"tf": 5.656854249492381}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 6.928203230275509}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 6.324555320336759}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 6.324555320336759}, "geneticalgorithm2.selections.Selection.stochastic": {"tf": 6.324555320336759}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 8.306623862918075}, "geneticalgorithm2.selections.Selection.ranking": {"tf": 6.324555320336759}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 7.3484692283495345}, "geneticalgorithm2.selections.Selection.tournament": {"tf": 7.3484692283495345}, "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.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}}, "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": 2}, "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.6457513110645907}, "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}}}}}}, "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}}}}, "b": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"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.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.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": 29}}, "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.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.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.358898943540674}, "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": 40}}, "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.358898943540674}, "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.6457513110645907}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 4}, "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.123105625617661}, "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}}}}, "p": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 2.8284271247461903}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2.449489742783178}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 2.449489742783178}}, "df": 3}, "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.123105625617661}, "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, "o": {"docs": {}, "df": 0, "l": {"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": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"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.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.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": 29}}}}}}}}, "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}}}}, "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}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 1}}}}, "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": 2.8284271247461903}, "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}}}}}}, "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}, "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}}}}, "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, "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.callbacks.data.MiddleCallbackData.__init__": {"tf": 2.8284271247461903}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2.449489742783178}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 2.449489742783178}}, "df": 3}}}}}}}}, "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}}}}}, "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": 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.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 8}}}}}}}, "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, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 2}}}}}, "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}}, "df": 1}}}}}}, "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": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3}, "1": {"0": {"0": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 1}, "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.4142135623730951}}, "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.7320508075688772}}, "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.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}, "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.3166247903554}, "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": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1.7320508075688772}, "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": 1.7320508075688772}, "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.3484692283495345}, "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.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": 10.723805294763608}, "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.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": 189, "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.geneticalgorithm2.GeneticAlgorithm2": {"tf": 1}}, "df": 2}}}, "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.generation.GenerationConvertible": {"tf": 1.7320508075688772}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 3}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.7320508075688772}}, "df": 7, "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}}, "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.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1, "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}}}}}, "a": {"docs": {"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.4142135623730951}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}, "geneticalgorithm2.utils.funcs.fast_min": {"tf": 1}}, "df": 6, "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}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}}, "df": 4, "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}}, "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}}, "df": 2, "d": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "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.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2.23606797749979}, "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.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.funcs.split_matrix": {"tf": 1}, "geneticalgorithm2.utils.funcs.union_to_matrix": {"tf": 1}}, "df": 17}, "y": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 3}}, "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": 2.23606797749979}, "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.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}}, "df": 2}}}, "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}}}}, "s": {"docs": {"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": 6}, "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}}}}}}}}, "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.utils.files.touch": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2": {"tf": 1.4142135623730951}}, "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.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 4, "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.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}}, "df": 4}}}, "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}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}}, "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}}}}, "n": {"docs": {}, "df": 0, "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}}}}}}}}}, "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.4142135623730951}, "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.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1.4142135623730951}}, "df": 6, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "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_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": 2.8284271247461903}, "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": 22, "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}}}}}, "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.4142135623730951}, "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.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": 2.449489742783178}, "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.get_population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}}, "df": 23, "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.7320508075688772}, "geneticalgorithm2.utils.files.touch": {"tf": 1.4142135623730951}}, "df": 4}}, "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}}, "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.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}, "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.4142135623730951}}, "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.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": 5}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 2, "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": 1.7320508075688772}, "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.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.8284271247461903}, "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.get_population_initializer": {"tf": 1.7320508075688772}}, "df": 15, "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}}}}}}}}}}, "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": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 3, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"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.selections.Selection.fully_random": {"tf": 1}}, "df": 2}}}}}}}, "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}}}}}}}}}}}}}, "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.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.4142135623730951}}, "df": 10, "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": {}, "df": 0, "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}}}}}, "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}}, "df": 1}}}}}, "o": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"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.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 7}, "s": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}, "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": 1.4142135623730951}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 9}, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"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": 4, "s": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "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.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 1}}}}}}}}}}, "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": 1}, "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": 20}, "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": 2}}, "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.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}}, "df": 1}}}}}}}}, "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": 2}, "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.4142135623730951}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 2}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 2}}, "df": 9}}}}}, "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.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.mut_middle": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 6, "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}}, "df": 2}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "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.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "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}}}}}, "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.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"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}}}}}, "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.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "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": 5}, "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}}, "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.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 3}}, "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}}}, "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}}, "df": 1}}}, "r": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.PlotPopulationScores": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2, "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}}}, "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.4142135623730951}}, "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}}}}}}, "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.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 3, "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": 2.23606797749979}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_generation_scores": {"tf": 1}, "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": 12}}}}}, "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.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 1, "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": 2}}, "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}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 2}}, "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}}}, "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": 2.23606797749979}, "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.7320508075688772}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.7320508075688772}}, "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.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 5}, "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}}, "df": 4}}}}, "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.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.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}, "geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 10}}}, "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}}, "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}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"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": {}, "df": 0, "s": {"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}}, "df": 1}, "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": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 3}}}, "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.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "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}}, "df": 1}, "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}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1}}, "df": 4, "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.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.selections.roulette": {"tf": 1}}, "df": 5}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks": {"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.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 3}}, "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.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}}, "df": 3}}}}, "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}}}}}}, "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}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "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}}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.selections.roulette": {"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}}, "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, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "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.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 4}}}}}}}, "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}}, "df": 1}}}}}}}}, "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.4142135623730951}, "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.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}}, "df": 2, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "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}}, "df": 1}}}, "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.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 9, "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.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": 6}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1.4142135623730951}}, "df": 3}}}}, "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, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}}, "df": 2}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 1}}}, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}}, "df": 1}}}}}}}, "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.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 3}}, "df": 5}, "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.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 2}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "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": 22}, "h": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "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": 1}, "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}, "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}}, "df": 17, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 3}}, "i": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.files.touch": {"tf": 1}}, "df": 3}}, "a": {"docs": {}, "df": 0, "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}}}}}}}}}, "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}}, "df": 1}}}, "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}}, "df": 4, "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.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 5}}, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 5, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 4, "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}}, "df": 1}, "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.4142135623730951}}, "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.23606797749979}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 2}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 2.23606797749979}}, "df": 3}}}, "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}}, "df": 1}}}, "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.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 2}}, "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}}, "df": 3}}}}, "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}}, "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}}}}, "x": {"docs": {"geneticalgorithm2.mutations.MutationFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}}, "df": 2}, "z": {"docs": {}, "df": 0, "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}}}}}}}, "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\ncode 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[collections.abc.Callable[numpy.ndarray, float, tuple[numpy.ndarray, float]], NoneType] = None) -> tuple[int, collections.abc.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[[ForwardRef('np.ndarray'), ForwardRef('np.ndarray')], Tuple[ForwardRef('np.ndarray'), ForwardRef('np.ndarray')]],\tselection: Callable[[ForwardRef('np.ndarray'), int], ForwardRef('np.ndarray')],\tcurrent_stagnation: int,\tmax_stagnation: int,\tparents_portion: float,\telit_ratio: float,\tset_function: Callable[[ForwardRef('np.ndarray')], ForwardRef('np.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[[ForwardRef('np.ndarray'), ForwardRef('np.ndarray')], Tuple[ForwardRef('np.ndarray'), ForwardRef('np.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[[ForwardRef('np.ndarray'), int], ForwardRef('np.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[[ForwardRef('np.ndarray')], ForwardRef('np.ndarray')]"}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"fullname": "geneticalgorithm2.callbacks.data.SimpleCallbackFunc", "modulename": "geneticalgorithm2.callbacks.data", "qualname": "SimpleCallbackFunc", "kind": "variable", "doc": "
    Callback function perform 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], ForwardRef('np.ndarray'), ForwardRef('np.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: collections.abc.Sequence[collections.abc.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: collections.abc.Sequence[collections.abc.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[collections.abc.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') -> collections.abc.Callable[int, typing.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') -> collections.abc.Callable[int, typing.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[[ForwardRef('np.ndarray'), ForwardRef('np.ndarray')], typing.Tuple[ForwardRef('np.ndarray'), ForwardRef('np.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, collections.abc.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": "() -> collections.abc.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": "() -> collections.abc.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": "() -> collections.abc.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) -> collections.abc.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": "() -> collections.abc.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) -> collections.abc.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": "() -> collections.abc.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) -> collections.abc.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[[ForwardRef('np.ndarray'), ForwardRef('np.ndarray')], Tuple[ForwardRef('np.ndarray'), ForwardRef('np.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[[ForwardRef('np.ndarray'), int], ForwardRef('np.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", "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", "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": "
    \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": "
    \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": "
    \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[[ForwardRef('np.ndarray'), ForwardRef('np.ndarray')], Tuple[ForwardRef('np.ndarray'), ForwardRef('np.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[[ForwardRef('np.ndarray'), int], ForwardRef('np.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[[ForwardRef('np.ndarray'), ForwardRef('np.ndarray')], Tuple[ForwardRef('np.ndarray'), ForwardRef('np.ndarray')]], Callable[[float, float, float], float], Callable[[int, int, int], int], Callable[[ForwardRef('np.ndarray'), int], ForwardRef('np.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[[ForwardRef('np.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[[ForwardRef('np.ndarray')], ForwardRef('np.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'], ForwardRef('np.ndarray')], ForwardRef('np.ndarray'), typing.Tuple[typing.Union[ForwardRef('np.ndarray'), NoneType], typing.Union[ForwardRef('np.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": ": 'np.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
      • \n
    • dimension:  the number of decision variables, the population samples dimention
      • \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
      • \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: collections.abc.Callable[numpy.ndarray, float],\tdimension: int,\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.f": {"fullname": "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f", "modulename": "geneticalgorithm2.geneticalgorithm2", "qualname": "GeneticAlgorithm2.f", "kind": "variable", "doc": "
    \n", "annotation": ": collections.abc.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, collections.abc.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[collections.abc.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
    • set_function:  set function to be used instead of usual function
      • \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", "signature": "(\tself,\tno_plot: bool = False,\tdisable_printing: bool = False,\tprogress_bar_stream: Union[str, NoneType] = 'stdout',\tdisable_progress_bar: bool = False,\tset_function: collections.abc.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, collections.abc.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[collections.abc.Sequence[collections.abc.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: collections.abc.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: collections.abc.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": "(\tfunction_for_set: collections.abc.Callable[numpy.ndarray, float],\tn_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[[ForwardRef('np.ndarray'), ForwardRef('np.ndarray')], typing.Tuple[ForwardRef('np.ndarray'), ForwardRef('np.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[collections.abc.Callable[numpy.ndarray, float, tuple[numpy.ndarray, float]], NoneType] = None) -> tuple[int, collections.abc.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[[ForwardRef('np.ndarray'), int], ForwardRef('np.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, collections.abc.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": "() -> collections.abc.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": "() -> collections.abc.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": "() -> collections.abc.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) -> collections.abc.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": "() -> collections.abc.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) -> collections.abc.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": "(\ttau: int = 2) -> collections.abc.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": "'np.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": "'np.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": 43}, "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": 230, "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": 408, "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": 23, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"qualname": 2, "fullname": 5, "annotation": 13, "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": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"qualname": 1, "fullname": 4, "annotation": 4, "default_value": 16, "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": 135, "bases": 0, "doc": 5}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 115, "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": 202, "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": 139, "bases": 0, "doc": 7}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 180, "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": 24, "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": 78, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.one_point": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 68, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.two_point": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 68, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.uniform": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 68, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.segment": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 86, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 68, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 85, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 68, "bases": 0, "doc": 3}, "geneticalgorithm2.crossovers.Crossover.mixed": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 86, "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": 504, "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": 8}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"qualname": 5, "fullname": 10, "annotation": 3, "default_value": 1, "signature": 0, "bases": 0, "doc": 6}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "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": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.parents_portion": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 2, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"qualname": 3, "fullname": 8, "annotation": 24, "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": 14, "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": 188, "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": 8, "signature": 0, "bases": 0, "doc": 9}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"qualname": 1, "fullname": 5, "annotation": 4, "default_value": 13, "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": 42, "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": 6, "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": 479, "bases": 0, "doc": 264}, "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.f": {"qualname": 2, "fullname": 4, "annotation": 6, "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": 7, "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": 8, "default_value": 0, "signature": 0, "bases": 0, "doc": 22}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 1116, "bases": 0, "doc": 425}, "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": 45, "bases": 0, "doc": 18}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 45, "bases": 0, "doc": 24}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"qualname": 4, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 68, "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": 24, "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": 230, "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": 13, "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": 58, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.fully_random": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 48, "bases": 0, "doc": 13}, "geneticalgorithm2.selections.Selection.roulette": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 48, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.stochastic": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 48, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 85, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.ranking": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 48, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.linear_ranking": {"qualname": 3, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 67, "bases": 0, "doc": 3}, "geneticalgorithm2.selections.Selection.tournament": {"qualname": 2, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 65, "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": 6, "signature": 0, "bases": 0, "doc": 3}, "geneticalgorithm2.utils.aliases.array2D": {"qualname": 1, "fullname": 4, "annotation": 4, "default_value": 6, "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": 190, "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.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": 27}, "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}}, "df": 5, "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}}}}}}}}}}}}}}, "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}}}}}}}}}, "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}}}}}}}, "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, "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.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": 190}, "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}}, "df": 5, "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}}}}}}}}}}}}, "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}}}}}}}, "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}}}}}}, "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, "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.7320508075688772}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 1.4142135623730951}, "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.7320508075688772}, "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.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.selection_type": {"tf": 1.4142135623730951}, "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.4142135623730951}, "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, "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.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, "o": {"docs": {}, "df": 0, "l": {"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": {}, "df": 0, "s": {"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}}}}}}}, "p": {"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.result.GAResult.variable": {"tf": 1}}, "df": 6}, "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.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1}}, "df": 1}}}}}, "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}}}}, "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.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}}, "df": 5}}}}}}}}}}, "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}}}}, "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.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}}, "df": 5}}}}}}}}}}, "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.geneticalgorithm2.GeneticAlgorithm2.set_function": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 3}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "l": {"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": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}}, "df": 2}}}}}}}}}}}, "x": {"2": {"7": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.crossover": {"tf": 2.8284271247461903}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.selection": {"tf": 2}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.set_function": {"tf": 2}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.crossover_type": {"tf": 2.8284271247461903}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.selection_type": {"tf": 2}, "geneticalgorithm2.data_types.result.GAResult.variable": {"tf": 1.4142135623730951}}, "df": 6}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.needs_mutation": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.f": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.checked_reports": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.fill_children": {"tf": 1}}, "df": 3}}}}}, "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.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.crossovers.CrossoverFunc": {"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.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 1}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1.4142135623730951}}, "df": 17, "l": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.geneticalgorithm2": {"tf": 1}}, "df": 1}, "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}}, "df": 1}}}}, "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}}}}}}}}}}}}}}}}, "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.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}}}}}}}}}, "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.callbacks.data.SimpleCallbackFunc": {"tf": 2}, "geneticalgorithm2.crossovers.CrossoverFunc": {"tf": 2.8284271247461903}, "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.aliases.FunctionToMinimize": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 2}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 3.7416573867739413}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 2.449489742783178}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 2.8284271247461903}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 2.8284271247461903}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 2.449489742783178}, "geneticalgorithm2.selections.SelectionFunc": {"tf": 2}, "geneticalgorithm2.utils.aliases.array1D": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.aliases.array2D": {"tf": 1.4142135623730951}}, "df": 17}, "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}}, "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.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}}}}}}}}}}}}}}}}, "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.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}}}}}}}}}}}}, "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.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}}, "df": 6}}}}}}}}}, "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}}}}}, "n": {"docs": {}, "df": 0, "p": {"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}, "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}}}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_params": {"tf": 1}}, "df": 1}}, "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.7320508075688772}}, "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}}}}}, "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": 1.7320508075688772}, "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.data.MiddleCallbackData.__init__": {"tf": 4}, "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": 4.47213595499958}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 3.4641016151377544}, "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": 15}, "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": 13.341664064126334}, "geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 17.52141546793523}, "geneticalgorithm2.callbacks.middle.Actions.Stop": {"tf": 7.681145747868608}, "geneticalgorithm2.callbacks.middle.Actions.ReduceMutationProb": {"tf": 7.54983443527075}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 10.44030650891055}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 9.643650760992955}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomMutation": {"tf": 10}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 12.884098726725126}, "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": 10.535653752852738}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 11.958260743101398}, "geneticalgorithm2.crossovers.get_copies": {"tf": 7.211102550927978}, "geneticalgorithm2.crossovers.Crossover.crossovers_dict": {"tf": 8}, "geneticalgorithm2.crossovers.Crossover.one_point": {"tf": 7.483314773547883}, "geneticalgorithm2.crossovers.Crossover.two_point": {"tf": 7.483314773547883}, "geneticalgorithm2.crossovers.Crossover.uniform": {"tf": 7.483314773547883}, "geneticalgorithm2.crossovers.Crossover.segment": {"tf": 8.366600265340756}, "geneticalgorithm2.crossovers.Crossover.shuffle": {"tf": 7.483314773547883}, "geneticalgorithm2.crossovers.Crossover.uniform_window": {"tf": 8.366600265340756}, "geneticalgorithm2.crossovers.Crossover.arithmetic": {"tf": 7.483314773547883}, "geneticalgorithm2.crossovers.Crossover.mixed": {"tf": 8.366600265340756}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 19.519221295943137}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.validate": {"tf": 3.4641016151377544}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 11.916375287812984}, "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.81488772222678}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 29.698484809834994}, "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": 6}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 6}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 7.416198487095663}, "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": 13.341664064126334}, "geneticalgorithm2.selections.inverse_scores": {"tf": 4.898979485566356}, "geneticalgorithm2.selections.roulette": {"tf": 5.656854249492381}, "geneticalgorithm2.selections.Selection.selections_dict": {"tf": 6.928203230275509}, "geneticalgorithm2.selections.Selection.fully_random": {"tf": 6.324555320336759}, "geneticalgorithm2.selections.Selection.roulette": {"tf": 6.324555320336759}, "geneticalgorithm2.selections.Selection.stochastic": {"tf": 6.324555320336759}, "geneticalgorithm2.selections.Selection.sigma_scaling": {"tf": 8.306623862918075}, "geneticalgorithm2.selections.Selection.ranking": {"tf": 6.324555320336759}, "geneticalgorithm2.selections.Selection.linear_ranking": {"tf": 7.3484692283495345}, "geneticalgorithm2.selections.Selection.tournament": {"tf": 7.3484692283495345}, "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}}}}, "b": {"docs": {}, "df": 0, "c": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"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.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}, "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": 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": 29}}, "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.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.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.358898943540674}, "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": 40}}, "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.358898943540674}, "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.6457513110645907}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 4}, "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.123105625617661}, "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}}}}, "p": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackData.__init__": {"tf": 2.8284271247461903}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2.449489742783178}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 2.449489742783178}}, "df": 3}, "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.123105625617661}, "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, "o": {"docs": {}, "df": 0, "l": {"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": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomCrossover": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.ChangeRandomSelection": {"tf": 1.4142135623730951}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"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.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 2}, "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": 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": 29}}}}}}}}, "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}}}}, "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}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 1}}}}, "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": 2.8284271247461903}, "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}}}}}}, "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}, "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}}}}, "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, "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.callbacks.data.MiddleCallbackData.__init__": {"tf": 2.8284271247461903}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.__init__": {"tf": 2.449489742783178}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.get_CMS_funcs": {"tf": 2.449489742783178}}, "df": 3}}}}}}}}, "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}}}}}, "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": 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.utils.plotting.plot_several_lines": {"tf": 1}}, "df": 8}}}}}}}, "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, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks.SavePopulation": {"tf": 1}, "geneticalgorithm2.callbacks.simple.Callbacks.PlotOptimizationProcess": {"tf": 1}}, "df": 2}}}}}, "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}}, "df": 1}}}}}}, "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": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 3}, "1": {"0": {"0": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 1}, "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.population_initializer.get_population_initializer": {"tf": 1}}, "df": 2}, "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.3166247903554}, "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": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1.4142135623730951}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.population_size": {"tf": 1.7320508075688772}, "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": 1.7320508075688772}, "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.3484692283495345}, "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.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": 10.677078252031311}, "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": 190, "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.geneticalgorithm2.GeneticAlgorithm2": {"tf": 1}}, "df": 2}}}, "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.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": 7, "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}}, "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.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1, "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}}}}}, "a": {"docs": {"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": 6, "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}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}}, "df": 4, "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}}, "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}}, "df": 2, "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.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.generation.Generation": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2.23606797749979}, "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": 18}, "y": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.callbacks.middle.ActionConditions.Any": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 4}}, "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}}}}, "s": {"docs": {"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": 6}, "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}}}}}}}}, "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.utils.files.touch": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2": {"tf": 1.4142135623730951}}, "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.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 4, "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.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.default_set_function": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.vectorized_set_function": {"tf": 1}}, "df": 4}}}, "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}}, "df": 1}}}}, "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}}}}, "n": {"docs": {}, "df": 0, "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}}}}}}}}}, "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.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": 6, "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.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": 2.8284271247461903}, "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": 22, "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}}}}}, "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.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": 2.449489742783178}, "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": 24, "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}}, "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}}, "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.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}}}}, "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.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": 5}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 2, "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.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": 16, "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}}}}}}}}}}, "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": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.population_initializer.PopulationModifier": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 4, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"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.selections.Selection.fully_random": {"tf": 1}}, "df": 2}}}}}}}, "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}}}}}}}}}}}}}, "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.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.4142135623730951}}, "df": 10, "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}}}}}, "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}}, "df": 1}}}}}, "o": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"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.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.4142135623730951}}, "df": 7}, "s": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.callbacks.middle.Actions.RemoveDuplicates": {"tf": 1.4142135623730951}, "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": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}, "geneticalgorithm2.utils.cache.np_lru_cache": {"tf": 1}}, "df": 9}, "t": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"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": 4, "s": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "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.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}}, "df": 1, "s": {"docs": {"geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_num_iteration": {"tf": 1}}, "df": 1}}}}}}}}}}, "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": 1}, "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": 20}, "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.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}}, "df": 1}}}}}}}}, "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.4142135623730951}, "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}}, "df": 2}}}}}, "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.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1, "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}}}}}, "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.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "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": 5}, "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}}, "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.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 2}}, "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}}}, "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}}, "df": 1}}}, "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.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.selections.roulette": {"tf": 1}}, "df": 3, "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.utils.funcs.random_indexes_pair": {"tf": 1}}, "df": 1, "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}}, "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}}}, "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.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 5}, "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}}, "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}}, "df": 1}, "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}}}, "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}}, "df": 1}, "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}, "geneticalgorithm2.data_types.algorithm_params.AlgorithmParams.max_iteration_without_improv": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.PROGRESS_BAR_LEN": {"tf": 1}, "geneticalgorithm2.selections.inverse_scores": {"tf": 1}}, "df": 4, "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.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.selections.roulette": {"tf": 1}}, "df": 5}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.simple.Callbacks": {"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.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}}, "df": 3}}, "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.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}}, "df": 3}}}}, "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}}}}}}, "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}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "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}}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"geneticalgorithm2.selections.roulette": {"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}}, "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, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "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.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 4}}}}}}}, "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}, "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.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}}, "df": 2, "s": {"docs": {"geneticalgorithm2.callbacks.middle.Actions.CopyBest": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}}, "df": 2}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 1}}}}}}}, "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}}, "df": 1}}}, "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.aliases.SetFunctionToMinimize": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 2}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 9, "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.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": 6, "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.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.population_initializer.LOCAL_OPTIMIZATION_STEP_CASE": {"tf": 1.4142135623730951}}, "df": 3}}}}, "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, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.mutations.MutationFunc": {"tf": 1}}, "df": 2}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}}, "df": 1}}}, "y": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.7320508075688772}}, "df": 1}}}}}}}, "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.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 3}}, "df": 5}, "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.aliases.FunctionToMinimize": {"tf": 1}, "geneticalgorithm2.data_types.aliases.SetFunctionToMinimize": {"tf": 2}, "geneticalgorithm2.data_types.generation.GenerationConvertible": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "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.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": 22}, "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": 1}, "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": 1.7320508075688772}, "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": 18, "r": {"docs": {}, "df": 0, "e": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 3}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.utils.files.touch": {"tf": 1}}, "df": 3}}, "a": {"docs": {}, "df": 0, "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, "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}}, "df": 1}}}, "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.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.7320508075688772}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1.4142135623730951}}, "df": 5}}, "t": {"docs": {"geneticalgorithm2.Population_initializer": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.plot_results": {"tf": 1}, "geneticalgorithm2.population_initializer.get_population_initializer": {"tf": 1}}, "df": 5, "e": {"docs": {}, "df": 0, "s": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"geneticalgorithm2.callbacks.data.SimpleCallbackFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.geneticalgorithm2.VARIABLE_TYPE": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.run": {"tf": 1}}, "df": 4, "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}}, "df": 1}}}, "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.geneticalgorithm2.GeneticAlgorithm2.__init__": {"tf": 1}}, "df": 2, "s": {"docs": {"geneticalgorithm2.callbacks.data.MiddleCallbackActionFunc": {"tf": 1}, "geneticalgorithm2.geneticalgorithm2.GeneticAlgorithm2.set_function_multiprocess": {"tf": 1}}, "df": 2}, "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}}}}, "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}}, "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}}}}, "x": {"docs": {"geneticalgorithm2.mutations.MutationFunc": {"tf": 1.4142135623730951}, "geneticalgorithm2.mutations.Mutations.gauss_by_x": {"tf": 1}}, "df": 2}, "z": {"docs": {}, "df": 0, "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}}}}}}}, "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.