| Chromosome::CrossoverOperations::GaAddCrossover | GaAddCrossover crossover operation creates offspring which code has values which are calculated form corresponding values of codes of both parents by summing them |
| Algorithm::GaAlgorithm | Interface for genetic algorithms |
| Algorithm::GaAlgorithmParams | Interface for parameters of genetic algorithm |
| Chromosome::Representation::GaArithmeticalCode | GaArithmeticalCode interface should be implemented by chromosomes' classes which code supports arithmetical operations over it or its values |
| Algorithm::GaBaseAlgorithm | This class implements control of algorithm's execution and its state. It also provides synchronization for multithreading control of algorithm |
| Population::CouplingOperations::GaBestAlwaysCoupling | GaBestAlwaysCoupling coupling always takes chromosome with the best fitness value from selection result set, and the second parents are sequentially taken from. If all parents are used, but more children should be produced, this coupling operation wraps-around parent counter for second the parents and starts from beginning until enough children is produced. When two parents are chosen this operation produces specified number of children using crossover operation and then it chooses child with best fitness value among produced children and the second parent is bound to it. This coupling use GaMultipleCrossoverCouplingParams class for parameters |
| Chromosome::Representation::GaBinaryChromosome | This class can be used for solutions of problems which can be encoded as array of bits |
| Chromosome::Representation::GaBinaryChromosomeParams | This class is used by GaBinaryChromosome class as chromosomes' parameters |
| Chromosome::Representation::GaBit | This class is used by GaBinaryChromosome class for extracting of single values from chromosome's code and other manipulation on chromosome's code |
| Common::GaCatalogue< T > | GaCatalogue template class stores and manages catalogue (directory) for genetic operations. Data can be accessed by its key (name). When user adds new data into catalogue, catalogue takes over responsibility for memory allocated by the data. Data must come from heap. Key/data combination is stored in GaCatalogueEntry object. Duplicates of key in catalogue are not allowed |
| Common::GaCatalogue< T >::GaCataolgueHashMapComparator | |
| Common::GaCatalogue< T >::GaStringComparator | |
| Common::GaCatalogueEntry< T > | This template class manages key and pointer to data of a catalogue entry. Catalogue entry stores key's string value and pointer to data. Entry stores copied string value of a key. After binding data to an entry, entry object takes over responsibility for memory occupied by data. Data must be located at heap |
| Chromosome::GaChromosome | GaChromosome is interface for all chromosomes types in the library. Algorithms, populations and genetic operations assume that all chromosomes obey this interface. Genetic operations over chromosomes (crossover, mutation, fitness function) may require additional interfaces to be implemented, but all other built-in parts of the library don't have additional assumptions |
| Chromosome::Representation::GaChromosomeDomainBlock< T > | This class is CCB for chromosomes which have codes with values which must bi in defined domain. This CCB stores pointer to value set |
| Chromosome::GaChromosomeOperationsBlock | This class is CCB for chromosomes which use extern genetic operations. This CCB stores pointer to those operations |
| Chromosome::GaChromosomeParams | This class is base class for all chromosomes' parameters. Built-in genetic operations (crossover, mutation, fitness function and comparator) share their parameters with chromosomes parameters |
| Chromosome::GaChromosomeParamsBlock | This class represent base for chromosome's configuration block (CCB). CCB stores entire setup of chromosome. GaChromosomeParamsBlock class stores only pointer to chromosomes' parameters |
| Chromosome::Representation::GaChromosomeValue< TYPE > | This class is used by GaMultiValueChromosome template class for extracting of single values from chromosome's code and other manipulation on chromosome's code |
| Chromosome::Representation::GaCodeValue | GaCodeValue is interface for values which are parts of chromosome's code. It is used by interfaces which manipulate chromosome's code |
| Chromosome::Representation::GaCodeValuesBuffer | This class represents buffer for storing values of chromosome's code. It is also used for building chromosomes' codes. GaCodeValuesBuffer class also keeps track of current position for filling the buffer, but interpretation of it is left to users |
| Chromosome::Representation::GaCombinedValueSet< T > | This template represents value set which is consisted of multiple value sets. Value sets can be of any kind, but must contains same type of data |
| Population::GaCouplingOperation | This class is interface for coupling operations which produce offspring from selected chromosomes |
| Population::GaCouplingParams | This class is base for parameters of coupling operation |
| Population::GaCouplingResultSet | This class is used as storage for coupling operation (result set). Result set contains pointer to selection result set which stores parent chromosomes. It also contains array of newly produced chromosomes and array of their parents' indices |
| Threading::GaCriticalSection | GaCriticalSection class is wrapper class for system synchronization object |
| Population::CouplingOperations::GaCrossCoupling | GaCrossCoupling coupling takes first parents sequentially from selection result set, and second parents are the ones who are right below the first. If all parents are used, but more children should be produced, this coupling operation wraps-around parent counter and starts from beginning until enough children is produced. When two parents are chosen this operation produces specified number of children using crossover operation and then it chooses child with best fitness value among produced children and first parent is bound to it. This coupling use GaMultipleCrossoverCouplingParams class for parameters |
| Chromosome::GaCrossoverOperation | GaCrossoverOperation class is base for crossover operations |
| Chromosome::GaDefaultChromosome | GaDefaultChromosome class implements some basic feature of chromosome such as management of fitness value, CCB and probability of crossover and mutation operations |
| Chromosome::Representation::GaDomainChromosome< T > | GaDomainChromosome class should be base for chromosomes which have codes with values which must bi in defined domain |
| Chromosome::GaDynamicOperationChromosome | This class should be base for chromosomes which use extern genetic operations |
| Population::ScalingOperations::GaExponentialScaling | GaExponentialScaling operation calculates scaled fitness value of chromosome by raising fitness value to specified power which is defined by scale factor in parameters. This scaling operation is not based on ranking of chromosome and use GaScaleFactor class for parameters |
| Chromosome::GaFitnessComparator | GaFitnessComparator class is base for fitness comparators |
| Algorithm::StopCriterias::GaFitnessCriteria | GaFitnessCriteria is used to stop genetic algorithm when specified type of fitness value reaches desired value. This stop criteria uses GaFitnessCriteriaParams class as parameters |
| Algorithm::StopCriterias::GaFitnessCriteriaParams | GaFitnessCriteriaParams class is used by GaFitnessCriteria class as parameters for the criteria. It contains desired fitness value of specified type and it also specifies type of comparison which is used to compare desired and current fitness values |
| Chromosome::GaFitnessOperation | GaFitnessOperation class is base for fitness operations |
| Algorithm::StopCriterias::GaFitnessProgressCriteria | GaFitnessProgressCriteria is used to stop genetic algorithm when specified number of generations fail to meet required progress of defined type of fitness value. This stop criteria uses GaFitnessProgressCriteriaParams class as parameters |
| Algorithm::StopCriterias::GaFitnessProgressCriteriaParams | GaFitnessProgressCriteriaParams class is used by GaFitnessProgressCriteria class as parameters for the criteria. It contains desired progress of fitness value of specified type; it also specifies type of comparison which is used to compare desired and current progresses and number of generation which should continuously fail to meet required progress before algorithm stops |
| Chromosome::MutationOperations::GaFlipMutation | GaFlipMutation mutation chooses random number of values at random positions in chromosome's code and sets them with random value from chromosome's value set. Maximum number of changed values is specified in chromosomes parameters. This mutation changes at least one of the values |
| Algorithm::StopCriterias::GaGenerationCriteria | GaGenerationCriteria is used to stop genetic algorithm when it reaches specified number of generations. This stop criteria uses GaGenerationCriteriaParams class as parameters |
| Algorithm::StopCriterias::GaGenerationCriteriaParams | GaGenerationCriteriaParams class is used by GaGenerationCriteria class as parameters for the criteria. It contains number of generation after which execution of algorithm should be stopped |
| Algorithm::SimpleAlgorithms::GaIncrementalAlgorithm | Incremental algorithm replaces only specified number of chromosomes at the end of each generation, thus allowing majority of chromosomes to survive |
| Chromosome::Representation::GaIntervalValueSet< T > | This template represents value set which has interval of values. Intervals as specified by theirs bounds. This value set uses user-specified random generator to generate values within the interval |
| Population::CouplingOperations::GaInverseCoupling | GaInverseCoupling coupling takes first parents sequentially from selection results, and second parents are the ones who are at the distance from the last chromosome in selection results which is equal to distance of first parent form first chromosome in result set. If all parents are used, but more children should be produced, this coupling operation wraps-around parent counter and starts from beginning until enough children is produced. When two parents are chosen this operation produces specified number of children using crossover operation and then it chooses child with best fitness value among produced children and first parent is bound to it. This coupling use GaMultipleCrossoverCouplingParams class for parameters |
| Chromosome::MutationOperations::GaInvertMutation | GaSapwMutation mutation chooses random number of pairs of values at random positions in chromosome's code and swaps their positions. Maximum number of swapped pairs is specified in chromosomes parameters. This mutation swaps at least on pair of values |
| Population::ScalingOperations::GaLinearScaling | GaLinearScaling operation calculates scaled fitness value of chromosome by applying linear function a * f + b fitness value, to where a and b are calculated from scale factor which is provided in operation parameters. This scaling operation is not based on ranking of chromosome and use GaScaleFactor class for parameters |
| Chromosome::FitnessComparators::GaMaxFitnessComparator | GaMaxFitnessComparator can be used when objective of evolution is to maximize fitness value |
| Chromosome::CrossoverOperations::GaMidpointCrossover | GaMidpointCrossover crossover operation creates offspring which code has values which are calculated form corresponding values of codes of both parents by midpoint algorithm |
| Chromosome::FitnessComparators::GaMinFitnessComparator | GaMinFitnessComparator can be used when objective of evolution is to minimize fitness value |
| Population::CouplingOperations::GaMulitpleCrossoverCouplingParams | This class should be used (directly or by inheritance) by coupling operations which produce more then one child per parent pair before it chooses best child |
| Algorithm::GaMultithreadingAlgorithm | This class implements features to allow parallel execution of some operations of genetic algorithm. It runs multiple threads which execute work which can be done in parallel, one control thread which controls workers and executes all operations which must be executed sequentially |
| Algorithm::GaMultithreadingAlgorithmParams | This class should be used (directly or by inheritance) by genetic algorithms which use multiple threads for parallel execution of work |
| Chromosome::Representation::GaMultiValueChromosome< TYPE > | This class can be used for chromosomes which code has multiple values. Values can be of any type, but all values must have same type, they must use same value set and must obey requirements introduced by the value set |
| Chromosome::Representation::GaMultiValueCode | GaMultiValueCode interface should be implemented by chromosomes' classes which code contains multiple values |
| Chromosome::CrossoverOperations::GaMultiValueCrossover | GaMultiValueCrossover crossover operation create offspring by choosing specified number of crossover points at random positions, then it alternately copies values from parents' codes, and at very crossover point it changes parent from which it copies values. The first parent from which copying starts is chosen randomly |
| Chromosome::Representation::GaMultiValueSet< T > | This template represents value set with multiple values and their counterpart (inverted values) |
| Chromosome::Representation::GaMutableCode | GaMutableCode interface should be implemented by chromosomes' classes which code supports random changes and inversion of its parts |
| Chromosome::GaMutationOperation | GaMutationOperation class is base for mutation operations |
| Chromosome::Representation::GaMVArithmeticChromosome< TYPE > | This class can be used for chromosomes which code has multiple values that support arithmetic operations. Values can be of any type, but all values must have same type, they must use same value set and must obey requirements introduced by the value set |
| Population::ScalingOperations::GaNormalizationScaling | GaNormalizationScaling operation calculates scaled fitness based on ranking of chromosome. This scaling operation doesn't require any parameters |
| Observing::GaObserver | GaObserver interface is base class for all algorithms' observers. This interface has defined methods to handle each event which can be raised by an algorithm |
| Observing::GaObserverAdapter | This is adapter class for GaObserver interface. It overrides all methods from the interface, so classes inherited from this class can implements only necessary methods. Detail description of the methods is given in specification of GaObserver interface |
| Observing::GaObserversList | This class manages subscriptions of observers to algorithm's events |
| Common::GaOperation | Interface for genetic operations |
| Common::GaOperationParametersPair< OTYPE, PTYPE > | This template class is used for storing genetic operations and their parameters. This class has no built-in synchronizator, so LOCK_OBJECT and LOCK_THIS_OBJECT macros cannot be used with instances of this class |
| Common::GaParameters | Interface for parameters of genetic operations |
| Population::GaPopulation | GaPopulation class is used to host chromosomes. Population also provides statistical information about chromosomes in population by using GaStatistics class. Same chromosome can be hosted by multiple populations because they are stored in population using scaled chromosome object which contains smart pointer to chromosome and value of scaled fitness (because this value depends on population, but not on chromosome itself and same chromosome can be in multiple populations). Chromosomes in population can be sorted which provides easy way of tracking best and worst chromosomes, but if chromosomes are not sorted, population provides to sorted groups which stores indices of best and worst chromosomes. Sorting of chromosomes in population or in sorted groups is done my using provided sorting comparator. Both scaled and non-scaled fitness values of chromosomes can be used for sorting, which value is going to be used depends on specified parameters, but if scaling operation is not defined for the population, non-scaled fitness values are used. Maximal number of chromosomes which can be hosted is specified in population's parameters. Also whether the population is going to be fixed-size (number of chromosomes in population is always equals to maximal number of chromosomes it can store) or resizable (population can host from 0 to maximal number of chromosomes) is specified in population's parameters. During population initialization, provided prototype is used to create chromosomes which fill the population. Fixed-size populations are always filled during initialization, which is not the case with resizable populations. Besides hosting of chromosomes, population also binds extern genetic operations (selection, coupling, scaling, and replacement) which are going to be used by genetic algorithm during evolution |
| Population::GaPopulationConfiguration | This class stores parameters and genetic operations of a population or a group of populations. All populations bound to the configuration, are updated and notified every time when configuration is changed. Note that each population copies parameters' of the population and use local copy |
| Population::GaPopulationParameters | GaPopulationParameters class represents parameters of population |
| Common::GaRandom< TYPE > | Interface for random value generators |
| Common::GaRandomBool | GaRandomBool class generates random boolean values. It supports generating boolean with defined probabilities of true and false states. The class implements GaRandom interface. This class has no built-in synchronizator, so LOCK_OBJECT and LOCK_THIS_OBJECT macros cannot be used with instances of this class, but all public methods are thread-safe |
| Population::CouplingOperations::GaRandomCoupling | GaRandomCoupling coupling takes first parents sequentially from selection result set, and second parents are chosen randomly. If all parents are used as firs parent, but more children should be produced, this coupling operation wraps-around parent counter for the first parent and starts from beginning until enough children is produced. When two parents are chosen this operation produces specified number of children using crossover operation and then it chooses child with best fitness value among produced children and first parent is bound to it. This coupling use GaMultipleCrossoverCouplingParams class for parameters |
| Common::GaRandomDouble | GaRandomDouble class generates random double precision floating-point numbers. Class takes care about endianness of the architecture. Targeted architecture must support IEEE 754 standard. The class implements GaRandom interface. This class has no built-in synchronizator, so LOCK_OBJECT and LOCK_THIS_OBJECT macros cannot be used with instances of this class, but all public methods are thread-safe |
| Common::GaRandomFloat | GaRandomFloat class generates random single precision floating-point numbers. Targeted architecture must support IEEE 754 standard. The class implements GaRandom interface. This class has no built-in synchronizator, so LOCK_OBJECT and LOCK_THIS_OBJECT macros cannot be used with instances of this class, but all public methods are thread-safe |
| Common::GaRandomGenerator | GaRandomGenerator class implements algorithm for generating 64-bits wide random unsigned integers and floating-point numbers. It takes care of architecture's endianness, but underlying CPU architecture must support floating-point by IEEE 754 standard. GaRandomGenerator class doesn't implement GaRandom interface. Primary purpose of this class is to provide service for generating random numbers for classes which implement GaRandom interface |
| Common::GaRandomInteger | GaRandomInteger class generates random 32-bits wide integer numbers. The class implements GaRandom interface. This class has no built-in synchronizator, so LOCK_OBJECT and LOCK_THIS_OBJECT macros cannot be used with instances of this class, but all public methods are thread-safe |
| Population::ReplacementOperations::GaReplaceBest | GaReplaceBest replaces chromosomes with best fitness values in population. If population is sorted this operation can replace any number of chromosomes, if it is not sorted this operation can only replace chromosomes which are stored in the best chromosome sorted group of population. This replacement operation use GaReplacementParams class for parameters |
| Population::ReplacementOperations::GaReplaceElitismParams | This class should be used (directly or by inheritance) by replacement operations which can unintentionally remove the best chromosomes from population |
| Population::GaReplacementOperation | This class is interface for replacement operations which replace chromosomes of population with new chromosomes |
| Population::GaReplacementParams | This class is base for parameters of replacement operation |
| Population::ReplacementOperations::GaReplaceParents | GaReplaceParents replaces chromosomes which are marked as parents by coupling operation to offspring chromosomes. This operation saves the best chromosomes from replacement if specified in parameters. This replacement operation use GaReplaceElitismParams class for parameters |
| Population::ReplacementOperations::GaReplaceRandom | GaReplaceRandom randomly chooses chromosomes which are going to be replaced. This operation saves best chromosomes from replacement if specified in parameters. This replacement operation use GaReplaceElitismParams class for parameters |
| Population::ReplacementOperations::GaReplaceWorst | GaReplaceWorst replaces chromosomes with worst fitness values in population. If population is sorted this operation can replace any number of chromosomes, if it is not sorted this operation can only replace chromosomes which are stored in the worst chromosome sorted group of population. This replacement operation use GaReplacementParams class for parameters |
| Chromosome::GaScaledChromosome | This class wraps chromosome class and represents it in population. To reduce memory usage and improve performance same chromosome can be placed in multiple populations, but some chromosome's values has different values for separate populations. All values which are specific to the population are extracted from chromosome class to this class. Same object of GaScaledChromosome cannot be located in multiple populations |
| Population::ScalingOperations::GaScaleFactorParams | This class should be used (directly or by inheritance) by scaling operations which use user defined factor of scaling |
| Population::GaScalingOperation | This class is interface for scaling operations which transform chromosomes' fitness values |
| Population::GaScalingParams | This class is base for parameters of scaling operation |
| Threading::GaSectionLock | GaSectionLock class is used for automatic access control with help of GaCriticalSection class. Synchronization object can be automatically acquired when instance of GaSectionLock is created. If synchronization object is locked by instance of GaSectionLock it is released when the instance goes out of scope. This mechanism provides simple way of managing critical sections because users don't have to worry about releasing of synchronization object in most cases, but for more complicated cases LOCK and UNLOCK macros can be used with instances of this class or with GaCriticalSection class. GaSectionLock is mainly employed by LOCK_OBJECT and LOCK_THIS_OBJECT |
| Population::SelectionOperations::GaSelectBest | GaSelectBest selection is selects defined number of best chromosomes. If population is not-sorted, this selection can only select chromosomes which are in best sorted group. This selection use GaSelectionParams class for parameters |
| Population::SelectionOperations::GaSelectDuplicatesParams | This class should be used (directly or by inheritance) by selection operations which can control duplicates of chromosome in result set |
| Population::GaSelectionOperation | This class is interface for selection operation which selects chromosomes from population which are going to be used as parents in production of new chromosomes |
| Population::GaSelectionParams | This class is base for parameters of selection operation |
| Population::GaSelectionResultSet | This class is used as storage for selection operation (result set). It uses sorted group to store indices of selected chromosomes |
| Population::SelectionOperations::GaSelectRandom | GaSelectRandom selection is randomly selects defined number of chromosomes. This selection use GaSelectDuplicatesParams class for parameters |
| Population::SelectionOperations::GaSelectRandomBest | GaSelectRandomBest selection is randomly selects number of chromosomes and then it cuts off chromosomes with worst fitness values to fit in selection size. This selection use GaSelectRandomBestParams class for parameters |
| Population::SelectionOperations::GaSelectRandomBestParams | This class is used by GaSelectRandomBest selection operations |
| Population::SelectionOperations::GaSelectRouletteWheel | When GaSelectRouletteWheel selection is used chromosomes with better fitness values have better chances to be selected. It virtually transforms fitness value of chromosome to probability of selection. Population on which selection performed must be sorted. This selection can work with minimization or maximization of fitness values, as well as negative fitness values. This selection use GaSelectDuplicatesParams class for parameters |
| Population::SelectionOperations::GaSelectTournament | GaSelectTorunament selection is similar to GaSelectRouletteWheel selection. For one place in result set it performs multiple roulette wheel selection before it chooses only one chromosome with best fitness value among selected. This increases probability of selection of chromosome with better fitness value. This selection use GaSelectTorunamentParams class for parameters |
| Population::SelectionOperations::GaSelectTournamentParams | This class is used by GaSelectTournament selection operations |
| Population::SelectionOperations::GaSelectWorst | GaSelectWorst selection is selects defined number of worst chromosomes. If population is not-sorted, this selection can only select chromosomes which are in worst sorted group. This selection use GaSelectionParams class for parameters |
| Algorithm::SimpleAlgorithms::GaSimpleAlgorithm | Simple algorithm creates entirely new population of chromosomes at the end of each generation, only specified number of best chromosomes survive and they are copied into new generation. This algorithm uses two populations to avoid overlapping of generations which are used alternately |
| Algorithm::SimpleAlgorithms::GaSimpleAlgorithmParams | This class is used by GaSimpleAlgorithm as parameters |
| Population::CouplingOperations::GaSimpleCoupling | GaSimpleCoupling coupling takes first two parents and it produces two child using crossover operations, and each parent is bound to one child, then it takes next two parents, and so on... If all parents are used, but more children should be produced, this coupling operation wraps-around parent counter and starts from beginning until enough children is produced. This coupling use GaCouplingParams class for parameters |
| Chromosome::Representation::GaSingleValueChromosome< TYPE > | This class can be used for chromosomes which code has only one value. Value can be of any type as long as that type obeys requirements introduced by value set |
| Chromosome::Representation::GaSingleValueSet< T > | This template represents value set with only one value and its counterpart (inverted value) |
| Chromosome::Representation::GaSizableCode | GaSizableCode interface should be implemented by chromosomes' classes which code supports adding of new values into it or removing from it |
| Common::GaSmartPtr< T > | GaSmartPtr template class wraps C++ raw pointers, and takes over responsibility of managing the allocated memory. Smart pointer holds address of user data and reference to an object which is responsible for counting number of references to data, when there are no instances of GaSmartPtr pointing to location of the data (reference count of the location reaches 0), object is destroyed and memory used by the object is freed. Memory management by GaSmartPtr class is thread-safe, but after dereferencing smart pointer to access the data, it cannot be guaranteed that memory will not be freed if some other thread changes dereferenced pointer. Implemented smart pointers have some limitations: 1. Dynamically allocated arrays cannot be managed by GaSmartPtr class. 2. Circular references can cause memory leakage |
| Common::GaSmartStorage< T > | GaSmartStorage template class provides reference-counting for smart pointers. GaSmartStorage objects holds address of used data and number of references (smart pointers) which point to the data. Object of this class as well as the data are destroyed and memory is freed when there are no more references which points to the data. Arrays cannot be used with this class. This class has no built-in synchronizator, so LOCK_OBJECT and LOCK_THIS_OBJECT macros cannot be used with instances of this class, but all public method and operators are thread-safe |
| Population::GaSortedGroup | Sorted group stores indices of chromosomes in sorted order, chromosomes must be from same population. For sorting, group use provided fitness comparator. Direction depends on type of group. It group type is GASGT_BEST or GASGT_OTHER chromosomes are sorted in descending order by their fitness value, if group type is GASGT_WORST chromosomes are sorted in ascending order by their fitness value. Sorted group can only accept fixed number of chromosomes |
| Common::GaStatistics | GaStatistics class keeps track of statistical information about populations, groups of populations or algorithms. It contains information about previous and current statistics, and provides information about progress of statistical values |
| Common::GaStatValue< T > | GaStatValue template class stores single statistical value and keeps track of changes of that value between generations |
| Algorithm::GaStopCriteria | This class is interface for stop criteria of genetic algorithm |
| Algorithm::GaStopCriteriaParams | Interface for parameters of stop criteria operation |
| Chromosome::CrossoverOperations::GaSubCrossover | GaSubCrossover crossover operation creates offspring which code has values which are calculated form corresponding values of codes of both parents by subtracting them |
| Chromosome::Representation::GaSVArithmeticChromosome< TYPE > | This class can be used for chromosomes which code has only one value that supports arithmetic operations. Value can be of any type as long as that type obeys requirements introduced by value set and has defined arithmetic operators |
| Chromosome::Representation::GaSwapableCode | GaSwapableCode interface should be implemented by chromosomes' classes which code supports swapping of positions of its positions |
| Chromosome::MutationOperations::GaSwapMutation | GaInvertMutation mutation chooses random number of values at random positions in chromosome's code and inverts them. Maximum number of inverted values is specified in chromosomes parameters. This mutation changes at least on value |
| Threading::GaThread | GaThread class controls system threads. It wraps system specific control of threading. This class has built-in synchronizator so it is allowed to use LOCK_OBJECT and LOCK_THIS_OBJECT macros with instances of this class |
| Threading::GaThreadParameter | GaThreadParameter structure contains information needed to start new thread. It has pointer to function which is entry point of thread and pointer to parameters which will be passed to the function. Restrictions of entry point's function of a thread are described by GaThreadFunctionPointer type |
| Chromosome::Representation::GaUnboundValueSet< T > | This template represents value set with no additional limitations, except limitation introduced by the type and random generator used to generate values |
| Common::GaUnsignedIntToDouble | This union is used for conversation from 64-bits long integer random number to double precision floating point number in interval (0, 1) |
| Common::GaUnsignedIntToFloat | This union is used for conversation from 32-bits long integer random number to single precision floating point number in interval (0, 1) |
| Chromosome::Representation::GaValueIntervalBounds< T > | This template class represents bounds of interval value set |
| Chromosome::Representation::GaValueSet< T > | This template class is base class for all value set. Value sets store values which can be found in chromosomes' codes |
| Population::ScalingOperations::GaWindowScaling | GaWindowScaling operation calculates scaled fitness value of chromosome by subtracting fitness value of worst chromosome from fitness value of chromosome which is scaled. This operation can work with minimization or maximization of fitness values, as well as negative fitness values. This scaling operation is not based on ranking of chromosome and doesn't require any parameters |