xegaGpGene: Package xegaGpGene.

In xegaGpGene: Genetic Operations for Grammar-Based Genetic Programming

Package xegaGpGene.

Description

Genetic operations for grammar-based genetic algorithms.

Details

For derivation tree genes, the xegaGpGene package provides

• Gene initiatilization.

• Decoding of parameters.

• Mutation functions as well as a function factory for configuration.

• Crossover functions as well as a function factory for configuration. Crossover functions can be restricted by depth or by the non-terminal symbols which are allowed as roots of the subtrees which are exchanged between 2 genes. We provide two families of crossover functions:

  1. Crossover functions with two kids: Crossover preserves the genetic information in the gene pool.

  2. Crossover functions with one kid: These functions allow the construction of evaluation pipelines for genes. One advantage of this is a simple control structure at the population level.

Derivation Tree Gene Representation

A derivation tree gene is a named list:

• $gene1: The gene must be a complete derivation tree.

• $fit: The fitness value of the gene (for EvalGeneDet() and EvalGeneU()) or the mean fitness (for stochastic functions evaluated with EvalGeneStoch()).

• $evaluated: Boolean. Has the gene been evaluated?

• $evalFail: Boolean. Has the evaluation of the gene failed?

• $var: The variance of the fitness of all evaluations of a gene is updated after each evaluation 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(word, gene, lF): Function with a word of a language (a program) as first argument which computes the fitness of the gene.

Abstract Interface of Mutation Functions

Each mutation function has the following function signature:

newGene<-Mutate(gene, lF)

All local parameters of the mutation function configured are expected be available in the local function list lF.

Local Constants of Mutation Functions

The local constants of a mutation function determine the behavior of the function.

Constant	Default	Used in
lF$MaxMutDepth()	3	xegaGpMutateAllGene(),
	3	xegaGpMutateFilterGene()
lF$MinMutInsertionDepth()	1	xegaGpMutateFilterGene()
lF$MaxMutInsertionDepth()	7	xegaGpMutateFilterGene()

Abstract Interfaces of Crossover Functions

The signatures of the abstract interface to the 2 families of crossover functions are:

ListOfTwoGenes<-Crossover2(gene1, gene2, lF)

ListOfOneGene<-Crossover(gene1, gene2, lF)

All local parameters of the crossover function configured are expected to be available in the local function list lF.

Local Constants of Crossover Functions

Constant	Default	Used in
lF$MinCrossDepth()	1	xegaGpFilterCross2Gene(),
		xegaGpFilterCrossGene(),
lF$MaxCrossDepth()	7	xegaGpFilterCross2Gene(),
		xegaGpFilterCrossGene(),
lF$MaxTrials()	5	xegaGpAllCross2Gene()
		xegaGpAllCrossGene(),
		xegaGpFilter2CrossGene(),
		xegaGpFilterCrossGene(),

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

Copyright

(c) 2023 Andreas Geyer-Schulz

License

MIT

URL

<https://github.com/ageyerschulz/xegaGpGene>

Installation

From CRAN by install.packages('xegaGpGene')

Author(s)

Andreas Geyer-Schulz

References

Geyer-Schulz, Andreas (1997): Fuzzy Rule-Based Expert Systems and Genetic Machine Learning, Physica, Heidelberg. (ISBN:978-3-7908-0830-X)

See Also

Useful links:

• https://github.com/ageyerschulz/xegaGpGene

xegaGpGene documentation built on June 10, 2025, 9:14 a.m.