Package {gatbxr}

Genetic Algorithm Toolbox

Description

A collection of genetic algorithm operators ported from the Genetic Algorithm Toolbox for 'MATLAB' developed at the Department of Automatic Control and Systems Engineering of The University of Sheffield, UK.

Details

To create populations:

crtbase

Create a base vector

crtbp

Create arbitrary discrete random populations

crtrp

Create real-valued initial population

Fitness assignment:

ranking

Generalised rank-based fitness assignment

scaling

Linear fitness scaling

Selection functions:

reins

Uniform random and fitness-based reinsertion

rws

Roulette wheel selection

select

High-level selection routine

sus

Stochastic universal sampling

Mutation operators:

mut

Discrete mutation

mutate

High-level mutation function

mutbga

Real-value mutation

Crossover operators:

recdis

Discrete recombination

recint

Intermediate recombination

reclin

Line recombination

recmut

Line recombination with mutation features

recombin

High-level recombination operator

xovdp

Double-point crossover

xovdprs

Double-point reduced surrogate crossover

xovmp

General multi-point crossover

xovsh

Shuffle crossover

xovshrs

Shuffle reduced surrogate crossover

xovsp

Single-point crossover

xovsprs

Single-point reduced surrogate crossover

Subpopulation support:

migrate

Exchange individuals between subpopulations

Utility functions:

bs2rv

Binary string to real-value conversion

Author(s)

Maintainer: Liang Zhao wethenwethen@gmail.com (R implementation) [translator]

Authors:

• Liang Zhao wethenwethen@gmail.com (R implementation) [translator]

• Andrew Chipperfield (Author of the original 'MATLAB' toolbox) [copyright holder]

• Peter Fleming (Author of the original 'MATLAB' toolbox) [copyright holder]

• Hartmut Pohlheim (Author of the original 'MATLAB' toolbox) [copyright holder]

• Carlos Fonseca (Author of the original 'MATLAB' toolbox) [copyright holder]

Other contributors:

• Alex Shenfield (Tested the original 'MATLAB' toolbox) [contributor]

• The University of Sheffield (Copyright holder of the original 'MATLAB' toolbox) [copyright holder]

References

Chipperfield, A. J., Fleming, P. J., Pohlheim, H. and Fonseca, C. M. (1994) Genetic Algorithm Toolbox for Use with MATLAB: User's Guide, Version 1.2. Department of Automatic Control and Systems Engineering, University of Sheffield. https://github.com/UoS-CODeM/GA-Toolbox

See Also

Useful links:

• https://github.com/drizztxx/gatbxr

• Report bugs at https://github.com/drizztxx/gatbxr/issues

Examples

## Simple Genetic Algorithm
##
## Test objective function is De Jong's first test function.
## Binary representation for the individuals is used.
##
## Author:     Hartmut Pohlheim
## History:    23.03.94     file created
##             15.01.03     tested under MATLAB v6 by Alex Shenfield
##             06.06.16     Re-modified for R by Liang Zhao

NIND = 40;           ## Number of individuals per subpopulations
MAXGEN = 100;        ## max Number of generations
GGAP = 0.9;          ## Generation gap, how many new individuals are created
SEL_F = 'sus';       ## Name of selection function
XOV_F = 'xovsp';     ## Name of recombination function for individuals
MUT_F = 'mut';       ## Name of mutation function for individuals

## Objective function: De Jong's first test function (sphere)
objfun1 <- function(Phen){
  res <- apply(Phen * Phen,1,sum)
  return(res)
}

## set boundaries of objective function
   lb=-512;
   ub=512;

## Number of variables of objective function
   NVAR = 20;

## Build field description list
   PRECI = 20;    ## Precision of binary representation
   FieldDD = list(prec=PRECI,lb=lb,ub=ub,code="gray",scale="arith",lbin=TRUE,ubin=TRUE);

## Create population
   Chrom = crtbp(NIND, NVAR*PRECI)$Chrom;
   ObjV = objfun1(bs2rv(Chrom,FieldDD));

## reset count variables
   gen = 0;
   Best = rep(NA,MAXGEN)

## Iterate population
   while (gen < MAXGEN){
     ## Record the best objective value of the population
     Best[gen+1] = min(ObjV);

     ## Fitness assignment to whole population
     FitnV = ranking(ObjV);

     ## Select individuals from population
     SelCh = select(SEL_F, Chrom, FitnV, GGAP);

     ## Recombine selected individuals (crossover)
     SelCh=recombin(XOV_F, SelCh);

     ## Mutate offspring
     SelCh=mutate(MUT_F, SelCh);

     ##Evaluate offspring, call objective function
     ObjVSel = objfun1(bs2rv(SelCh,FieldDD));

     ## Insert offspring in population replacing parents
     rs = reins(Chrom, SelCh,1,c(1,1),ObjV,ObjVSel);
     Chrom = rs$Chrom;
     ObjV  = rs$ObjVCh

     gen = gen + 1;
   }

## Best objective value found in each generation
plot(Best, type = "l", xlab = "Generation", ylab = "Best objective value")
## End of script

Binary string to real vector

Description

This function decodes binary chromosomes into vectors of reals. The chromosomes are seen as the concatenation of binary strings of given length, and decoded into real numbers in a specified interval using either standard binary or Gray decoding.

Usage

bs2rv(Chrom, FieldD)

Arguments

Value

a real matrix containing the population phenotypes. Each row corresponds to one individual and each column to one variable.

Author(s)

The original 'MATLAB' implementation of bs2rv was written by Carlos Fonseca and updated by Andrew Chipperfield. The R implementation was written by Liang Zhao.

See Also

crtbp

Examples

## Create a population of 40 chromosomes of length 400
Chrom = crtbp(Nind = 40, Lind = 400)$Chrom

## Convert to reals in the range [-512, 512] with a precision of 20
## (20 bits represent one real number) on an arithmetic scale by binary decoding.
Phen = bs2rv(Chrom = Chrom,
             FieldD = list(prec=20,lb=-512,ub=512,code="binary",scale="arith",lbin=TRUE,ubin=TRUE))

## Two variables with different bounds, decoded with Gray code
Chrom = crtbp(5, 16)$Chrom
Phen = bs2rv(Chrom,
             FieldD = list(prec=8,lb=c(-1,10),ub=c(1,100),code="gray",
                           scale=c("arith","log"),lbin=TRUE,ubin=TRUE))

Create base vector

Description

This function creates a vector containing the base of the loci in a chromosome.

Usage

crtbase(Lind, Base = NULL)

Arguments

Value

a vector whose elements correspond to the base of the loci of the associated chromosome structure.

Author(s)

The original 'MATLAB' implementation of crtbase was written by Andrew Chipperfield. The R implementation was written by Liang Zhao.

Examples

## 10 binary loci
Base = crtbase(10)

## 3 loci of base 8 followed by 2 loci of base 4
Base = crtbase(c(3,2), c(8,4))

Create an initial population

Description

This function creates a binary population of given size and structure.

Usage

crtbp(Nind, Lind = NULL, Base = NULL)

Arguments

Value

a list containing following components:

Author(s)

The original 'MATLAB' implementation of crtbp was written by Andrew Chipperfield. The R implementation was written by Liang Zhao.

See Also

crtbase, crtrp

Examples

## 40 individuals with 10 binary loci
Chrom = crtbp(40,10)$Chrom

## 6 individuals with 5 loci of base 8
Chrom = crtbp(6,5,8)$Chrom

## 6 individuals whose loci have bases 2, 4 and 8
Chrom = crtbp(6,c(2,4,8))$Chrom

Create a real-valued initial population

Description

This function creates a population of given size of random real-values.

Usage

crtrp(Nind, FieldDR)

Arguments

Details

The first step in a genetic algorithm is to create an initial population consisting of random individuals. crtrp produces a matrix, Chrom, containing uniformly distributed random values in its elements.

Chrom = crtrp(Nind, FieldDR) creates a random real-valued matrix of size Nind * Nvar, where Nind specifies the number of individuals in the population and Nvar the number of variables of each individual. Nvar is derived from FieldDR with Nvar = NCOL(FieldDR).

FieldDR is a matrix of size 2 * Nvar and contains the boundaries of each variable of an individual. The first row contains the lower bounds, the second row the upper bounds.

FieldDR is also used in other functions such as mutate.

Value

a matrix containing the random valued individuals of the new population of size Nind by number of variables.

Author(s)

The original 'MATLAB' implementation of crtrp was written by Hartmut Pohlheim and tested by Alex Shenfield. The R implementation was written by Liang Zhao.

See Also

mutbga, recdis, recint, reclin

Examples

## To create a random population of 6 individuals with 4 variables each:
## Define boundaries on the variables,
FieldDR = matrix(c(-100,-50,-30,-20,
                    100,50,30,20),2,4,byrow=TRUE)
## Create initial population
Chrom = crtrp(6,FieldDR)

Migration of individuals between subpopulations

Description

This function performs migration of individuals.

Usage

migrate(
  Chrom,
  SUBPOP = 1,
  ObjV,
  MIGR = 0.2,
  Select = FALSE,
  Structure = c("net", "neighbourhood", "ring")
)

Arguments

Details

gatbxr provides support for multiple subpopulations through the use of high-level genetic operator functions and a routine for exchanging individuals between subpopulations. In the literature, the use of multiple populations has been shown, in most cases, to improve the quality of the results obtained using GAs compared to the single population GA.

gatbxr supports the use of a single population divided into a number of subpopulations or demes by modifying the use of data structures such that subpopulations are stored in contiguous blocks within a single matrix.

In this model each subpopulation is evolved over generations by a traditional GA and from time to time individuals migrate from one subpopulation to another. The amount of migration of individuals and the pattern of that migration determines how much genetic diversity can occur.

migrate implements the transfer of individuals between subpopulations, in which Structure specifies the population topology over which migration will take place. The default unrestricted migration topology (net) is the most general migration strategy. Here, individuals may migrate from any subpopulation to another. For each subpopulation, a pool of potential immigrants is constructed from the other subpopulations. The individual migrants are then determined according to the appropriate selection strategy.

Structure ring transfers individuals between directionally adjacent subpopulations. And neighbourhood is a similar strategy. Like the ring topology, migration is made only between nearest neighbours, however, migration may occur in either direction between subpopulations. For each subpopulation, the possible immigrants are determined, according to the desired selection method, from the adjacent subpopulations and a final selection made from this pool of individuals. This ensures that individuals will not migrate from a subpopulation to the same population.

Value

a list containing following components:

Author(s)

The original 'MATLAB' implementation of migrate was written by Hartmut Pohlheim. The R implementation was written by Liang Zhao.

See Also

select, recombin, mutate, reins

Examples

## create initial population of 5 subpopulations with 10 individuals each
Chrom = crtbp(50,10)$Chrom

## calculate objective values (to be minimized) with sum function
ObjV = apply(Chrom,1,sum)

## choose 20% of the individuals of one subpopulation and replace
## these individuals with the fittest individuals from an adjacent
## subpopulation in a unidirectional ring structure
res = migrate(Chrom, SUBPOP = 5, ObjV, Select = TRUE, Structure = "ring")

Discrete mutation (low-level function)

Description

This function takes the representation of the current population, mutates each element with given probability and returns the resulting population.

Usage

mut(OldChrom, Pm = NULL, BaseV = NULL)

Arguments

Value

a matrix containing a mutated version of OldChrom.

Author(s)

The original 'MATLAB' implementation of mut was written by Andrew Chipperfield. The R implementation was written by Liang Zhao.

See Also

mutate, mutbga

Examples

Chrom = crtbp(40,10)$Chrom

NewChrom = mut(OldChrom=Chrom)

Mutation (high-level function)

Description

This function takes a matrix OldChrom containing the representation of the individuals in the current population, mutates the individuals and returns the resulting population.

The function handles multiple populations and calls the low-level mutation function for the actual mutation process.

Usage

mutate(MUT_F = "mut", OldChrom, FieldDR = NULL, MutOpt = NULL, SUBPOP = 1, ...)

Arguments

Value

a matrix containing the chromosomes of the population after mutation in the same format as OldChrom.

Note

mutate has the same name as functions in other packages (for example dplyr::mutate); use gatbxr::mutate if another package masks it.

Author(s)

The original 'MATLAB' implementation of mutate was written by Hartmut Pohlheim. The R implementation was written by Liang Zhao.

See Also

mut, mutbga

Examples

## Binary population
Chrom = crtbp(40,10)$Chrom
NewChrom = mutate(MUT_F="mut",OldChrom=Chrom)

## Real-valued population
FieldDR = matrix(c(-100,-50,-30,-20,100,50,30,20),2,4,byrow=TRUE)
Chrom = crtrp(6,FieldDR)
NewChrom = mutate("mutbga",Chrom,FieldDR)

Mutation of real-valued population

Description

This function implements the mutation operator of the Breeder Genetic Algorithm.

Usage

mutbga(OldChrom, FieldDR, MutOpt = NULL)

Arguments

Details

mutbga takes a matrix OldChrom containing the real representation of the individuals in the current population, mutates the individuals with given probability and returns the resulting population.

The mutation of a variable is computed as follows:
mutated variable = variable + MutMx * range * MutOpt[2] * delta, where MutMx = 1 or -1 with probability MutOpt[1] (+ or - with equal probability), else 0. range = 0.5 * domain of variable (search interval defined by FieldDR). delta = sum(0 to m-1)pi*2^-i, pi = 1 with probability 1/m, else 0, m = 20.

With m = 20, the mutation operator is able to locate the optimum up to a precision of range * MutOpt[2] * 2^-19.

mutbga is able to generate most points in the hypercube defined by the variables of the individual and the range of the mutation. However, it tests more often near the variable, that is, the probability of small step sizes is greater than that of larger step sizes.

Value

a matrix containing the chromosomes of the population after mutation in the same format as OldChrom.

Author(s)

The original 'MATLAB' implementation of mutbga was written by Hartmut Pohlheim. The R implementation was written by Liang Zhao.

References

Muhlenbein, H. and Schlierkamp-Voosen, D. (1993) Predictive Models for the Breeder Genetic Algorithm: I. Continuous Parameter Optimization. Evolutionary Computation, 1(1), 25–49. doi:10.1162/evco.1993.1.1.25

See Also

mutate, recdis, recint, recmut, reclin

Examples

## Initialise a real-valued population
FieldDR = matrix(c(-100,-50,-30,-20,100,50,30,20),2,4,byrow=TRUE)
Chrom = crtrp(6,FieldDR)

## Perform mutation
NewChrom = mutbga(Chrom,FieldDR)

Rank-based fitness assignment

Description

This function ranks individuals represented by their associated cost, to be minimized, and returns a vector FitnV containing the corresponding individual fitnesses. For multiple subpopulations the ranking is performed separately for each subpopulation.

Usage

ranking(ObjV, RFun = c(2, 0), SUBPOP = 1)

Arguments

Details

Individuals with equal objective values receive the same fitness, namely the average of the fitness values assigned to their ranks.

Value

a vector containing the fitness values of the individuals in the current population.

Author(s)

The original 'MATLAB' implementation of ranking was written by Hartmut Pohlheim and Carlos Fonseca. The R implementation was written by Liang Zhao.

See Also

scaling, select

Examples

Chrom = crtbp(40,10)$Chrom

## Objective function is the sum of individuals
ObjV = apply(Chrom,1,sum)

## Linear ranking with selective pressure 2
FitnV = ranking(ObjV)

## Non-linear ranking with selective pressure 3
FitnV = ranking(ObjV, RFun = c(3,1))

Discrete recombination

Description

This function performs discrete recombination between pairs of individuals and returns the new individuals after mating.

Usage

recdis(OldChrom)

Arguments

Details

recdis is a function applicable to both populations of real-value variables and binary or integer variables. The pairs are mated in order, odd row with the next even row. If the number of rows in the matrix OldChrom is odd then the last row is not mated and added at the end of NewChrom. The population should therefore be organised into contiguous pairs that require mating. This can be achieved by using the function ranking to assign a fitness level to each individual and a selection function (e.g. select) to select individuals with a probability related to their fitness in the current population.

Value

a matrix containing the chromosomes of the population after mating, ready to be mutated and/or evaluated, in the same format as OldChrom.

Algorithm

Discrete recombination exchanges variable values between the individuals. For each variable the parent who contributes its variable value to the offspring is chosen randomly with equal probability.

Discrete recombination can generate the corners of the hypercube defined by the parents.

Author(s)

The original 'MATLAB' implementation was written by Hartmut Pohlheim. The R implementation was written by Liang Zhao.

See Also

recombin, recint, reclin, ranking, sus, rws

Examples

## Initial a real-valued population
FieldDR = matrix(c(-100,-50,-30,-20,100,50,30,20),2,4,byrow=TRUE)
Chrom = crtrp(6,FieldDR)

## Perform discrete recombination
NewChrom = recdis(Chrom)

Intermediate recombination

Description

This function performs extended intermediate recombination between pairs of individuals and returns the new individuals after mating.

Usage

recint(OldChrom)

Arguments

Details

recint is a function only applicable to populations of real-value variables (and not binary or integer). The pairs are mated in order, odd row with the next even row. If the number of rows in the matrix OldChrom is odd then the last row is not mated and added at the end of NewChrom. The population should therefore be organised into contiguous pairs that require mating. This can be achieved by using the function ranking to assign a fitness level to each individual and a selection function (e.g. select) to select individuals with a probability related to their fitness in the current population.

Value

a matrix containing the chromosomes of the population after mating, ready to be mutated and/or evaluated, in the same format as OldChrom.

Algorithm

Intermediate recombination combines parent values using the following rule:

offspring = parent1 + Alpha * (parent2 - parent1)

where Alpha is a scaling factor chosen uniformly at random in the interval [-0.25, 1.25]. recint produces a new Alpha for each pair of values to be combined.

Intermediate recombination can generate any point within a hypercube slightly larger than that defined by the parents.

Intermediate recombination is similar to line recombination reclin. Whereas recint uses a new Alpha factor for each pair of values combined together, reclin uses one Alpha factor for each pair of parents.

Author(s)

The original 'MATLAB' implementation was written by Hartmut Pohlheim. The R implementation was written by Liang Zhao.

See Also

recombin, recdis, reclin, ranking, sus, rws

Examples

## Initial a real-valued population
FieldDR = matrix(c(-100,-50,-30,-20,100,50,30,20),2,4,byrow=TRUE)
Chrom = crtrp(6,FieldDR)

## Perform intermediate recombination
NewChrom = recint(Chrom)

Line recombination

Description

This function performs line recombination between pairs of individuals and returns the new individuals after mating.

Usage

reclin(OldChrom)

Arguments

Details

reclin is a function only applicable to populations of real-value variables (and not binary or integer). The pairs are mated in order, odd row with the next even row. If the number of rows in the matrix OldChrom is odd then the last row is not mated and added at the end of NewChrom. The population should therefore be organised into contiguous pairs that require mating. This can be achieved by using the function ranking to assign a fitness level to each individual and a selection function (e.g. select) to select individuals with a probability related to their fitness in the current population.

Value

a matrix containing the chromosomes of the population after mating, ready to be mutated and/or evaluated, in the same format as OldChrom.

Algorithm

Line recombination combines parent values using the following rule:

offspring = parent1 + Alpha * (parent2 - parent1)

where Alpha is a scaling factor chosen uniformly at random in the interval [-0.25, 1.25]. reclin produces one Alpha factor for each pair of parents combined.

Line recombination can generate any point on a slightly longer line than that defined by the parents.

Line recombination is similar to intermediate recombination recint. Whereas reclin uses one Alpha factor for each pair of parents combined together, recint uses a new Alpha factor for each pair of values.

Author(s)

The original 'MATLAB' implementation was written by Hartmut Pohlheim. The R implementation was written by Liang Zhao.

See Also

recombin, recdis, recint, ranking, sus, rws

Examples

## Initial a real-valued population
FieldDR = matrix(c(-100,-50,-30,-20,100,50,30,20),2,4,byrow=TRUE)
Chrom = crtrp(6,FieldDR)

## Perform line recombination
NewChrom = reclin(Chrom)

Line recombination with mutation features

Description

This function performs line recombination with mutation features between pairs of individuals.

Usage

recmut(OldChrom, FieldDR, MutOpt = NULL)

Arguments

Details

recmut is a function only applicable to populations of real-value variables (and not binary or integer). The pairs are mated in order, odd row with the next even row. If the number of rows in the matrix OldChrom is odd then the last row is not mated and added at the end of NewChrom. The population should therefore be organised into contiguous pairs that require mating. This can be achieved by using the function ranking to assign a fitness level to each individual and a selection function (e.g. select) to select individuals with a probability related to their fitness in the current population.

The offspring of a pair of two parents are computed as follows:
offspring1 = parent1 + RecMx * range * MutOpt[2] * delta * Diff
offspring2 = parent2 + RecMx * range * MutOpt[2] * delta * -Diff
where,
RecMx = 1 or -1 with probability MutOpt[1] (- with probability 0.9), else 0.
range = 0.5 * domain of variable (search interval defined by FieldDR).
delta = sum(0 to m-1)pi*2^-i, pi = 1 with probability 1/m, else 0, m = 20.
Diff = (parent2 - parent1)/|norm(parent2) - norm(parent1)|. Pairs of parents with equal norms are not moved.

The recombination operator recmut generates offspring in a direction defined by the parents (line recombination). It tests more often outside the area defined by the parents and in the direction of parent1. The point for the offspring is defined by features of the mutation operator. The probability of small step sizes is greater than that of bigger steps (see mutbga).

Value

a matrix containing the chromosomes of the population after mating, ready to be mutated and/or evaluated, in the same format as OldChrom.

Note

This function doesn't work with high level recombination function recombin

Author(s)

The original 'MATLAB' implementation of recmut was written by Hartmut Pohlheim. The R implementation was written by Liang Zhao.

See Also

mutate, mutbga, reclin

Examples

## Initial a real-valued population
FieldDR = matrix(c(-100,-50,-30,-20,100,50,30,20),2,4,byrow=TRUE)
Chrom = crtrp(6,FieldDR)

## Perform line recombination with mutation
NewChrom = recmut(Chrom,FieldDR)

Recombination (high-level function)

Description

This function performs recombination between pairs of individuals and returns the new individuals after mating. The function handles multiple populations and calls the low-level recombination function for the actual recombination process.

Usage

recombin(REC_F, Chrom, RecOpt = 0.7, SUBPOP = 1, ...)

Arguments

Value

a matrix containing the chromosomes of the population after recombination in the same format as Chrom.

Note

This function doesn't work with low level recombination function recmut.

Author(s)

The original 'MATLAB' implementation of recombin was written by Hartmut Pohlheim. The R implementation was written by Liang Zhao.

See Also

xovmp, recdis, recint, reclin

Examples

Selch = crtbp(40,10)$Chrom

NewChrom = recombin(REC_F="xovsp",Chrom=Selch)

Reinsertion of offspring in population replacing parents

Description

This function reinserts offspring in the population.

Usage

reins(
  Chrom,
  SelCh,
  SUBPOP = 1,
  InsOpt = c(0, 1),
  ObjVCh = NULL,
  ObjVSel = NULL
)

Arguments

Value

a list containing following components:

Author(s)

The original 'MATLAB' implementation of reins was written by Hartmut Pohlheim and tested by Alex Shenfield. The R implementation was written by Liang Zhao.

See Also

select, recombin, mutate

Examples

## Parents and their objective values (to be minimized)
Chrom = crtbp(10,8)$Chrom
ObjVCh = apply(Chrom,1,sum)

## Offspring and their objective values
SelCh = crtbp(6,8)$Chrom
ObjVSel = apply(SelCh,1,sum)

## Replace the worst parents with all offspring (fitness-based insertion)
res = reins(Chrom, SelCh, InsOpt = c(1,1), ObjVCh = ObjVCh, ObjVSel = ObjVSel)

## Insert the best 50% of the offspring at uniformly random positions
res = reins(Chrom, SelCh, InsOpt = c(0,0.5), ObjVSel = ObjVSel)

Roulette Wheel Selection

Description

This function selects a given number of individuals from a population.

Usage

rws(FitnV, Nsel)

Arguments

Details

rws probabilistically selects Nsel individuals for reproduction according to their fitness, FitnV, in the current population.

NewChrIx = rws(FitnV,Nsel) selects Nsel individuals from a population using roulette wheel selection. FitnV is a vector containing a performance measure for each individual in the population. This can be achieved by using the function ranking or scaling to assign a fitness level to each individual.

rws is a low-level selection function normally called by select.

Value

a vector containing the indexes of the selected individuals relative to the original population, shuffled. The new population, ready for mating, can be obtained by calculating OldChrom[NewChrIx,].

Algorithm

A form of roulette wheel selection is implemented by obtaining a cumulative sum of the fitness vector, FitnV, and generating Nsel uniformly at random distributed numbers between 0 and sum(FitnV). The index of the individuals selected is determined by comparing the generated numbers with the cumulative sum vector. The probability of an individual being selected is then given by:

F(x_i) = \frac{f(x_i)}{\sum_{i=1}^{Nind} f(x_i)}

where f(x_i) is the fitness of individual x_i and F(x_i) is the probability of that individual being selected.

Author(s)

The original 'MATLAB' implementation of rws was written by Carlos Fonseca and Andrew Chipperfield. The R implementation was written by Liang Zhao.

See Also

select, sus, reins, ranking, scaling

Examples

## Consider a population of 8 individuals with the assigned fitness values, FitnV:
FitnV = c(1.5,1.35,1.21,1.07,0.92,0.78,0.64,0.5)
## Select the indices of 6 individuals:
NewChrIx = rws(FitnV,6)

Linear fitness scaling

Description

This function implements a linear fitness scaling algorithm. For multiple subpopulations scaling is performed separately for each subpopulation.

Usage

scaling(ObjV, Smul = 2, SUBPOP = 1)

Arguments

Details

scaling converts the objective values, ObjV, into a fitness measure with a known upper bound, determined by the value of Smul, such that,

F(x_i) = \alpha f(x_i) + b

where f(x_i) is the objective value of individual x_i, \alpha is a scaling coefficient, b is an offset and F(x_i) is the resulting fitness value of individual x_i. If f_{ave} is the average objective value in the current generation, then the maximum fitness of the scaled population is upper bounded at f_{ave} * Smul. If Smul is omitted then the default value is set to 2. The average fitness of the scaled population is also set to f_{ave}.

If the upper bound cannot be reached without producing negative fitness values, scaling instead chooses the offset b such that the smallest scaled fitness value is zero. If all objective values of a subpopulation are equal, every individual is assigned the average value.

Value

a vector containing the individual fitnesses for the current population.

Note

Negative objective values are not supported, as linear scaling becomes unreliable in that case. ranking is generally recommended instead; scaling is included only for the sake of completeness.

Author(s)

The original 'MATLAB' implementation of scaling was written by Andrew Chipperfield. The R implementation was written by Liang Zhao.

References

Goldberg, D. E. (1989) Genetic Algorithms in Search, Optimization and Machine Learning. Addison Wesley.

See Also

ranking, reins, rws, select, sus

Examples

Chrom = crtbp(40,10)$Chrom

## Objective function is the sum of individuals
ObjV = apply(Chrom,1,sum)
FitnV = scaling(ObjV)

Selection (high-level function)

Description

This function performs universal selection. The function handles multiple populations and calls the low level selection function for the actual selection process.

Usage

select(SEL_F = "sus", Chrom, FitnV, GGAP = 1, SUBPOP = 1, ...)

Arguments

Value

a matrix containing the selected individuals.

Note

select has the same name as functions in other packages (for example dplyr::select); use gatbxr::select if another package masks it.

Author(s)

The original 'MATLAB' implementation of select was written by Hartmut Pohlheim. The R implementation was written by Liang Zhao.

See Also

sus, rws, ranking

Examples

Chrom = crtbp(40,10)$Chrom

## Objective function is the sum of individuals
FitnV = ranking(apply(Chrom,1,sum))

Selch = select(SEL_F="sus",Chrom=Chrom,FitnV=FitnV,GGAP=0.9)

Stochastic Universal Sampling

Description

This function performs selection with stochastic universal sampling.

Usage

sus(FitnV, Nsel)

Arguments

Value

a vector containing the indexes of the selected individuals relative to the original population, shuffled. The new population, ready for mating, can be obtained by calculating OldChrom[NewChrIx,].

Author(s)

The original 'MATLAB' implementation of sus was written by Hartmut Pohlheim and Carlos Fonseca. The R implementation was written by Liang Zhao.

Examples

Chrom = crtbp(40,10)$Chrom

## Objective function is the sum of individuals
FitnV = ranking(apply(Chrom,1,sum))

Selch = sus(FitnV=FitnV,Nsel=2)

Crossover operators for binary representation

Description

These functions take a matrix OldChrom containing the binary representation of the individuals in the current population, apply crossover to consecutive pairs of individuals with defined probability and return the resulting population.

Usage

xovmp(OldChrom, Px = 0.7, Npt = 0, Rs = FALSE)

xovsp(OldChrom, Px = 0.7)

xovdp(OldChrom, Px = 0.7)

xovsh(OldChrom, Px = 0.7)

xovsprs(OldChrom, Px = 0.7)

xovdprs(OldChrom, Px = 0.7)

xovshrs(OldChrom, Px = 0.7)

Arguments

Details

xovmp is the general crossover function for binary representation and is called by all other crossover functions. When xovmp is called by the high-level function recombin, its additional arguments can be passed through .... With different combinations of arguments, it can be used identically to xovsp, xovdp, xovsh, xovsprs, xovdprs and xovshrs. Although these functions are redundant, they are kept for completeness.

xovsp performs single-point crossover between pairs of individuals. When called by recombin, recombin("xovsp",Chrom) is identical to recombin("xovmp",Chrom,Npt=1).

xovdp performs double-point crossover between pairs of individuals. When called by recombin, recombin("xovdp",Chrom) is identical to recombin("xovmp",Chrom,Npt=2).

xovsh performs shuffle-point crossover between pairs of individuals. When called by recombin, recombin("xovsh",Chrom) is identical to recombin("xovmp",Chrom).

xovsprs performs single-point reduced surrogate crossover between pairs of individuals. When called by recombin, recombin("xovsprs",Chrom) is identical to recombin("xovmp",Chrom,Npt=1,Rs=TRUE).

xovdprs performs double-point reduced surrogate crossover between pairs of individuals. When called by recombin, recombin("xovdprs",Chrom) is identical to recombin("xovmp",Chrom,Npt=2,Rs=TRUE).

xovshrs performs shuffle-point reduced surrogate crossover between pairs of individuals. When called by recombin, recombin("xovshrs",Chrom) is identical to recombin("xovmp",Chrom,Rs=TRUE).

Value

a matrix containing the offspring after mating, ready to be mutated and/or evaluated, in the same format as OldChrom.

Author(s)

The original 'MATLAB' implementation of xovmp was written by Carlos Fonseca and updated by Andrew Chipperfield; the other crossover functions were written by Hartmut Pohlheim. The R implementation was written by Liang Zhao.

See Also

recombin

Examples

Chrom = crtbp(40,10)$Chrom

## Shuffle crossover
Selch = xovmp(OldChrom=Chrom)

## Single-point crossover
Selch = xovsp(Chrom, Px = 0.8)