xegaGeGene {xegaGeGene}

Package xegaGeGene.

Description

The xegaGeGene package provides functions implementing grammatical evolution with binary coded genes:

Details

• Gene initialization.

• Gene maps for the mod and (approximately) for the bucket rule.

• Grammar-based decoders for binary coded genes.

• Analysis of the interaction of codon precision with the rule choice bias for a given grammar.

• Automatic determination of codon precision with a limited rule choice bias.

Gene Initialization

The number of bits of a gene are specified by lF$BitsOnGene().

The number of bits of a codon are specified by lF$CodonPrecision().

Binary Gene Representation

A binary gene is a named list:

• $gene1 the gene must be a binary vector.

• $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)

Abstract Interface of Problem Environment

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 parameter. Used in GeneMap.

The Architecture of the xegaX-Packages

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:

  1. The representation indendent part (package xegaSelectGene) is responsible for variants of selection operators, evaluation strategies for genes, as well as profiling and timing capabilities.

  2. 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 an abstract data type for derivation trees.

Copyright

(c) 2024 Andreas Geyer-Schulz

License

MIT

URL

https://github.com/ageyerschulz/xegaGeGene

Installation

From CRAN by install.packages('xegaGeGene')

Author(s)

Andreas Geyer-Schulz

References

Ryan, Conor and Collins, J. J. AND Neill, Michael O. (1998) Grammatical evolution: Evolving programs for an arbitrary language. In: Banzhaf, Wolfgang and Poli, Riccardo, Schoenauer, Marc and Fogarty, Terence C. (1998): Genetic Programming. First European Workshop, EuroGP' 98 Paris, France, April 14-15, 1998 Proceedings, Lecture Notes in Computer Science, 1391, Springer, Heidelberg. <doi:10.1007/BFb0055930>

O'Neil, Michael AND Ryan, Conor (2003) Grammatical Evolution: Evolutionary Automatic Programming in an Arbitrary Language. Kluwer, Dordrecht. <ISBN:1-4020-7444-1>

Ryan, Conor and O'Neill, Michael and Collins, J. J. (2018) Handbook of Grammatical Evolution. Springer International Publishing, Cham. <doi:10.1007/978-3-319-78717-6>