xegaDfGene {xegaDfGene} | R Documentation |
Genetic operations for real-coded genetic and evolutionary algorithms.
For real-coded genes, the xegaDfGene
package provides
Gene initialization.
Decoding of parameters.
Scaling functions as a function factory for configuration.
Mutation functions as well as a function factory for configuration.
Crossover functions as well as a function factory for configuration.
Replication functions as well as a function factory for configuration.
Current support: Functions for differential evolution (de). See Price et al. (2005).
A real-coded gene is a named list:
$gene1 the gene must be a vector of reals.
$fit the fitness value of the gene (for EvalGeneDet and EvalGeneU) or the mean fitness (for stochastic functions evaluated with EvalGeneStoch).
$evaluated has the gene been evaluated?
$evalFail has the evaluation of the gene failed?
$var the cumulative variance of the fitness of all evaluations of a gene. (For stochastic functions)
$sigma the standard deviation of the fitness of all evaluations of a gene. (For stochastic functions)
$obs the number evaluations of a gene. (For stochastic functions)
We reuse the abstract interface of a problem environment
for binary-coded genes. The number of parameters
is given by length(penv$bitlength())
.
A problem environment penv
must provide:
$f(parameters, gene, lF)
:
Function with a real parameter vector as first argument
which returns a gene
with evaluated fitness.
$genelength(): The number of bits of the binary coded
real parameter vector. Used in InitGene
.
$bitlength(): A vector specifying the number of bits
used for coding each real parameter.
If penv$bitlength()[1]
is 20
,
then parameters[1]
is coded by 20 bits.
Used in GeneMap
.
$lb(): The lower bound vector of each parameter.
Used in GeneMap
.
$ub(): The upper bound vector of each paremeter.
Used in GeneMap
.
The xegaX-packages are a family of R-packages which implement eXtended Evolutionary and Genetic Algorithms (xega). The architecture has 3 layers, namely the user interface layer, the population layer, and the gene layer:
The user interface layer (package xega
)
provides a function call interface and configuration support
for several algorithms: genetic algorithms (sga),
permutation-based genetic algorithms (sgPerm),
derivation-free algorithms as e.g. differential evolution (sgde),
grammar-based genetic programming (sgp) and grammatical evolution
(sge).
The population layer (package xegaPopulation
) contains
population-related functionality as well as support for
population statistics dependent adaptive mechanisms and parallelization.
The gene layer is split in a representation-independent and a representation-dependent part:
The representation-independent part (package xegaSelectGene
)
is responsible for variants of selection operators, evaluation
strategies for genes, as well as profiling and timing capabilities.
The representation-dependent part consists of the following packages:
xegaGaGene
for binary coded genetic algorithms.
xegaPermGene
for permutation-based genetic algorithms.
xegaDfGene
for derivation-free algorithms as e.g.
differential evolution.
xegaGpGene
for grammar-based genetic algorithms.
xegaGeGene
for grammatical evolution algorithms.
The packages xegaDerivationTrees
and xegaBNF
support
the last two packages:
xegaBNF
essentially provides a grammar compiler, and
xegaDerivationTrees
is an abstract data type for derivation trees.
(c) 2023 Andreas Geyer-Schulz
MIT
https://github.com/ageyerschulz/xegaDfGene>
From CRAN by install.packages('xegaDfGene')
Andreas Geyer-Schulz
Price, Kenneth V., Storn, Rainer M. and Lampinen, Jouni A. (2005) The Differential Evolution Algorithm (Chapter 2), pp. 37-134. In: Differential Evolution. A Practical Approach to Global Optimization. Springer, Berlin. <doi:10.1007/3-540-31306-0>