Description Usage Arguments Details Value Author(s) References See Also Examples
A simple Genetic Algorithm for minimising a function.
1 
OF 
The objective function, to be minimised. See Details. 
algo 
A list with the settings for algorithm. See Details and Examples. 
... 
Other pieces of data required to evaluate the objective function. See Details and Examples. 
The function implements a simple Genetic Algorithm (GA). A
GA evolves a collection of solutions (the socalled
population), all of which are coded as vectors containing only zeros
and ones. (In GAopt
, solutions are of mode logical
.)
The algorithm starts with randomlychosen or usersupplied population
and aims to iteratively improve this population by mixing solutions
and by switching single bits in solutions, both at random. In each
iteration, such randomlychanged solutions are compared with the
original population and better solutions replace inferior
ones. In GAopt
, the population size is kept constant.
GA language: iterations are called generations; new solutions
are called offspring or children (and the existing solutions, from which
the children are created, are parents); the objective function is called
a fitness function; mixing solutions is a crossover; and randomly
changing solutions is called mutation. The choice which solutions remain in
the population and which ones are discarded is called selection. In
GAopt
, selection is pairwise: a given child is compared with a
given parent; the better of the two is kept. In this way, the best
solution is automatically retained in the population.
To allow for constraints, the evaluation works as follows: after new
solutions are created, they are (i) repaired, (ii) evaluated through the
objective function, (iii) penalised. Step (ii) is done by a call to
OF
; steps (i) and (iii) by calls to algo$repair
and
algo$pen
. Step (i) and (iii) are optional, so the respective
functions default to NULL
. A penalty can also be directly written
in the OF
, since it amounts to a positive number added to the
‘clean’ objective function value; but a separate function is
often clearer. A separate penalty function is advantagous if either only
the objective function or only the penalty function can be vectorised.
Conceptually a GA consists of two loops: one loop across the
generations and, in any given generation, one loop across the solutions.
This is the default, controlled by the variables algo$loopOF
,
algo$loopRepair
and algo$loopPen
, which all default to
TRUE
. But it does not matter in what order the solutions are
evaluated (or repaired or penalised), so the second loop can be
vectorised. The respective algo$loopFun
must then be set to
FALSE
. (See also the examples for DEopt
and
PSopt
.)
The evaluation of the objective function in a given generation can even
be distributed. For this, an argument algo$methodOF
needs to be
set; see below for details (and Schumann, 2011, for examples).
All objects that are passed through ...
will be passed to the
objective function, to the repair function and to the penalty function.
The list algo
contains the following items:
nB
number of bits per solution. Must be specified.
nP
population size. Defaults to 50. Using default settings may not be a good idea.
nG
number of iterations (‘generations’). Defaults to 300. Using default settings may not be a good idea.
crossover
The crossover method. Default is
"onePoint"
; also possible is “uniform”.
prob
The probability for switching a single bit. Defaults to 0.01; typically a small number.
pen
a penalty function. Default is NULL
(no
penalty).
repair
a repair function. Default is NULL
(no
repairing).
initP
optional: the initial population. A logical
matrix of size length(algo$nB)
times algo$nP
, or a
function that creates such a matrix. If a function, it must take
no arguments. If mode(mP)
is not logical
, then
storage.mode(mP)
will be tried (and a warning will be
issued).
loopOF
logical. Should the OF
be evaluated
through a loop? Defaults to TRUE
.
loopPen
logical. Should the penalty function (if
specified) be evaluated through a loop? Defaults to TRUE
.
loopRepair
logical. Should the repair function (if
specified) be evaluated through a loop? Defaults to TRUE
.
methodOF
loop
(the default), vectorised
,
snow
or multicore
. Setting vectorised
is
equivalent to having algo$loopOF
set to FALSE
(and
methodOF
overrides loopOF
). snow
and
multicore
use functions clusterApply
and
mclapply
, respectively. For snow
, an object
algo$cl
needs to be specified (see below). For
multicore
, optional arguments can be passed through
algo$mc.control
(see below).
cl
a cluster object or the number of cores. See
documentation of package parallel
.
mc.control
a list of named elements; optional settings
for mclapply
(for instance,
list(mc.set.seed = FALSE)
)
printDetail
If TRUE
(the default), information
is printed.
printBar
If TRUE
(the default), a
txtProgressBar
is printed.
storeF
If TRUE
(the default), the objective
function values for every solution in every generation are stored
and returned as matrix Fmat
.
storeSolutions
If TRUE
, the solutions (ie,
binary strings) in every generation are stored and returned as a
list P
in list xlist
(see Value section below). To
check, for instance, the solutions at the end of the i
th
generation, retrieve xlist[[c(1L, i)]]
. This will be a
matrix of size algo$nB
times algo$nP
.
A list:
xbest 
the solution (the best member of the population) 
OFvalue 
objective function value of best solution 
popF 
a vector. The objective function values in the final population. 
Fmat 
if 
xlist 
if 

the value of 
Enrico Schumann
Gilli, M., Maringer, D. and Schumann, E. (2011) Numerical Methods and Optimization in Finance. Elsevier. http://www.elsevierdirect.com/product.jsp?isbn=9780123756626
Schumann, E. (2017) Financial Optimisation with R (NMOF Manual). http://enricoschumann.net/NMOF.htm#NMOFmanual
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23  ## a *very* simple problem (why?):
## match a binary (logical) string y
size < 20L ### the length of the string
OF < function(x, y) sum(x != y)
y < runif(size) > 0.5
x < runif(size) > 0.5
OF(y, y) ### the optimum value is zero
OF(x, y)
algo < list(nB = size, nP = 20L, nG = 100L, prob = 0.002,
printBar = TRUE)
sol < GAopt(OF, algo = algo, y = y)
## show differences (if any: marked by a '^')
cat(as.integer(y), "\n", as.integer(sol$xbest), "\n",
ifelse(y == sol$xbest , " ", "^"), "\n", sep = "")
algo$nP < 3L ### that shouldn't work so well
sol2 < GAopt(OF, algo = algo, y = y)
## show differences (if any: marked by a '^')
cat(as.integer(y), "\n", as.integer(sol2$xbest), "\n",
ifelse(y == sol2$xbest , " ", "^"), "\n", sep = "")

Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.