Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
Chromosome::CrossoverOperations::GaAddCrossoverGaAddCrossover crossover operation creates offspring which code has values which are calculated form corresponding values of codes of both parents by summing them
Algorithm::GaAlgorithmInterface for genetic algorithms
Algorithm::GaAlgorithmParamsInterface for parameters of genetic algorithm
Chromosome::Representation::GaArithmeticalCodeGaArithmeticalCode interface should be implemented by chromosomes' classes which code supports arithmetical operations over it or its values
Algorithm::GaBaseAlgorithmThis class implements control of algorithm's execution and its state. It also provides synchronization for multithreading control of algorithm
Population::CouplingOperations::GaBestAlwaysCouplingGaBestAlwaysCoupling 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::GaBinaryChromosomeThis class can be used for solutions of problems which can be encoded as array of bits
Chromosome::Representation::GaBinaryChromosomeParamsThis class is used by GaBinaryChromosome class as chromosomes' parameters
Chromosome::Representation::GaBitThis 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::GaChromosomeGaChromosome 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::GaChromosomeOperationsBlockThis class is CCB for chromosomes which use extern genetic operations. This CCB stores pointer to those operations
Chromosome::GaChromosomeParamsThis 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::GaChromosomeParamsBlockThis 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::GaCodeValueGaCodeValue is interface for values which are parts of chromosome's code. It is used by interfaces which manipulate chromosome's code
Chromosome::Representation::GaCodeValuesBufferThis 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::GaCouplingOperationThis class is interface for coupling operations which produce offspring from selected chromosomes
Population::GaCouplingParamsThis class is base for parameters of coupling operation
Population::GaCouplingResultSetThis 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::GaCriticalSectionGaCriticalSection class is wrapper class for system synchronization object
Population::CouplingOperations::GaCrossCouplingGaCrossCoupling 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::GaCrossoverOperationGaCrossoverOperation class is base for crossover operations
Chromosome::GaDefaultChromosomeGaDefaultChromosome 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::GaDynamicOperationChromosomeThis class should be base for chromosomes which use extern genetic operations
Population::ScalingOperations::GaExponentialScalingGaExponentialScaling 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::GaFitnessComparatorGaFitnessComparator class is base for fitness comparators
Algorithm::StopCriterias::GaFitnessCriteriaGaFitnessCriteria 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::GaFitnessCriteriaParamsGaFitnessCriteriaParams 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::GaFitnessOperationGaFitnessOperation class is base for fitness operations
Algorithm::StopCriterias::GaFitnessProgressCriteriaGaFitnessProgressCriteria 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::GaFitnessProgressCriteriaParamsGaFitnessProgressCriteriaParams 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::GaFlipMutationGaFlipMutation 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::GaGenerationCriteriaGaGenerationCriteria is used to stop genetic algorithm when it reaches specified number of generations. This stop criteria uses GaGenerationCriteriaParams class as parameters
Algorithm::StopCriterias::GaGenerationCriteriaParamsGaGenerationCriteriaParams 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::GaIncrementalAlgorithmIncremental 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::GaInverseCouplingGaInverseCoupling 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::GaInvertMutationGaSapwMutation 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::GaLinearScalingGaLinearScaling 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::GaMaxFitnessComparatorGaMaxFitnessComparator can be used when objective of evolution is to maximize fitness value
Chromosome::CrossoverOperations::GaMidpointCrossoverGaMidpointCrossover crossover operation creates offspring which code has values which are calculated form corresponding values of codes of both parents by midpoint algorithm
Chromosome::FitnessComparators::GaMinFitnessComparatorGaMinFitnessComparator can be used when objective of evolution is to minimize fitness value
Population::CouplingOperations::GaMulitpleCrossoverCouplingParamsThis 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::GaMultithreadingAlgorithmThis 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::GaMultithreadingAlgorithmParamsThis 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::GaMultiValueCodeGaMultiValueCode interface should be implemented by chromosomes' classes which code contains multiple values
Chromosome::CrossoverOperations::GaMultiValueCrossoverGaMultiValueCrossover 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::GaMutableCodeGaMutableCode interface should be implemented by chromosomes' classes which code supports random changes and inversion of its parts
Chromosome::GaMutationOperationGaMutationOperation 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::GaNormalizationScalingGaNormalizationScaling operation calculates scaled fitness based on ranking of chromosome. This scaling operation doesn't require any parameters
Observing::GaObserverGaObserver 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::GaObserverAdapterThis 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::GaObserversListThis class manages subscriptions of observers to algorithm's events
Common::GaOperationInterface 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::GaParametersInterface for parameters of genetic operations
Population::GaPopulationGaPopulation 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::GaPopulationConfigurationThis 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::GaPopulationParametersGaPopulationParameters class represents parameters of population
Common::GaRandom< TYPE >Interface for random value generators
Common::GaRandomBoolGaRandomBool 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::GaRandomCouplingGaRandomCoupling 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::GaRandomDoubleGaRandomDouble 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::GaRandomFloatGaRandomFloat 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::GaRandomGeneratorGaRandomGenerator 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::GaRandomIntegerGaRandomInteger 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::GaReplaceBestGaReplaceBest 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::GaReplaceElitismParamsThis class should be used (directly or by inheritance) by replacement operations which can unintentionally remove the best chromosomes from population
Population::GaReplacementOperationThis class is interface for replacement operations which replace chromosomes of population with new chromosomes
Population::GaReplacementParamsThis class is base for parameters of replacement operation
Population::ReplacementOperations::GaReplaceParentsGaReplaceParents 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::GaReplaceRandomGaReplaceRandom 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::GaReplaceWorstGaReplaceWorst 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::GaScaledChromosomeThis 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::GaScaleFactorParamsThis class should be used (directly or by inheritance) by scaling operations which use user defined factor of scaling
Population::GaScalingOperationThis class is interface for scaling operations which transform chromosomes' fitness values
Population::GaScalingParamsThis class is base for parameters of scaling operation
Threading::GaSectionLockGaSectionLock 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::GaSelectBestGaSelectBest 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::GaSelectDuplicatesParamsThis class should be used (directly or by inheritance) by selection operations which can control duplicates of chromosome in result set
Population::GaSelectionOperationThis 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::GaSelectionParamsThis class is base for parameters of selection operation
Population::GaSelectionResultSetThis class is used as storage for selection operation (result set). It uses sorted group to store indices of selected chromosomes
Population::SelectionOperations::GaSelectRandomGaSelectRandom selection is randomly selects defined number of chromosomes. This selection use GaSelectDuplicatesParams class for parameters
Population::SelectionOperations::GaSelectRandomBestGaSelectRandomBest 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::GaSelectRandomBestParamsThis class is used by GaSelectRandomBest selection operations
Population::SelectionOperations::GaSelectRouletteWheelWhen 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::GaSelectTournamentGaSelectTorunament 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::GaSelectTournamentParamsThis class is used by GaSelectTournament selection operations
Population::SelectionOperations::GaSelectWorstGaSelectWorst 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::GaSimpleAlgorithmSimple 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::GaSimpleAlgorithmParamsThis class is used by GaSimpleAlgorithm as parameters
Population::CouplingOperations::GaSimpleCouplingGaSimpleCoupling 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::GaSizableCodeGaSizableCode 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::GaSortedGroupSorted 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::GaStatisticsGaStatistics 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::GaStopCriteriaThis class is interface for stop criteria of genetic algorithm
Algorithm::GaStopCriteriaParamsInterface for parameters of stop criteria operation
Chromosome::CrossoverOperations::GaSubCrossoverGaSubCrossover 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::GaSwapableCodeGaSwapableCode interface should be implemented by chromosomes' classes which code supports swapping of positions of its positions
Chromosome::MutationOperations::GaSwapMutationGaInvertMutation 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::GaThreadGaThread 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::GaThreadParameterGaThreadParameter 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::GaUnsignedIntToDoubleThis union is used for conversation from 64-bits long integer random number to double precision floating point number in interval (0, 1)
Common::GaUnsignedIntToFloatThis 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::GaWindowScalingGaWindowScaling 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

Genetic Algorithm Library
Coolsoft Software Development