CSC583 – Artificial

Intelligence Algorithms
Topic 4 – Evolutionary Algorithm
Faculty of Computer & Mathematical Sciences
Universiti Teknologi MARA
A. Introduction
A. Introduction: Objectives
• To understand:
• How nature inspires evolutionary algorithm
• The foundations of evolutionary algorithm
• The differences between genetic algorithm, genetic
programming and evolutionary programming
A. Introduction: Can Evolution be Intelligent?
• Intelligence can be defined as the capability of a system to
adapt its behaviour to ever-changing environment.
• If, over successive generations an organism survives, we can say
that this organism is capable of learning to predict changes in
environment
A. Introduction: Can Evolution be Intelligent?
(cont)
• Evolutionary computation simulates evolution on a
computer.
• The result of such a simulation is a series of optimisation
algorithms, usually based on a simple set of rules.
• Optimisation iteratively improves the quality of solutions
until an optimal, or at least feasible, solution is found.
A. Introduction: Can Evolution be Intelligent?
(cont)
• The evolutionary approach is based on computational
models of natural selection and genetics.
• We call them evolutionary computation, an umbrella term
that combines genetic algorithms, evolution strategies and
genetic programming.
A. Introduction: Classifications of EA
A. Introduction: Simulation of Natural
Evolution – Survival of the Fittest
• Darwinism is based on processes of reproduction, mutation,
competition and selection.
• The power to reproduce appears to be an essential property of
life.
• The power to mutate is also guaranteed in any living organism that
reproduces itself in a continuously changing environment.
• Processes of competition and selection normally take place in the
natural world, where expanding populations of different species
are limited by a finite space.
• Evolutionary fitness – population’s ability to survive and reproduce
A. Introduction: Simulation of Natural
Evolution (cont)
• All methods of evolutionary computation simulate natural
evolution by:
• creating a population of individuals
• evaluating their fitness
• generating a new population through genetic operations
• repeating this process a number of times.
A. Introduction: EA Analogy Foundation
Genetic Algorithms
B. Genetic Algorithms
• Genetic Algorithms is a search technique used in computing
to find true or approximate solutions to optimization and
search problems based on biological evolution
• Introduced in early 1970s by John Holland, GA aims to make
computers do what nature does.
B. Genetic Algorithms
• Holland introduced algorithms that manipulate strings of
binary digits
• Each artificial “chromosomes” consists of a number of “genes”,
and each gene is represented by 0 or 1:

1 0 1 1 0 1 0 0 0 0 0 1 0 1 0 1

genes
C. Genetic Algorithms: Steps
• Step 1:
• Represent the problem variable domain as a chromosome of a
fixed length, choose the size of a chromosome population N, the
crossover probability pc and the mutation probability pm.
• Step 2:
• Define a fitness function to measure the performance, or fitness,
of an individual chromosome in the problem domain. The fitness
function establishes the basis for selecting chromosomes that will
be mated during reproduction.
C. Genetic Algorithms: Steps (cont)
• Step 3:
• Randomly generate an initial population of chromosomes of size
N:
x 1 , x 2, . . . , x N
• Step 4:
• Calculate the fitness of each individual chromosome:
f(x1), f(x2), . . . , f(xN)
C. Genetic Algorithms: Steps (cont)
• Step 5:
• Select a pair of chromosomes for mating from the current
population. Parent chromosomes are selected with a probability
related to their fitness.
• Selection Techniques
• Roulette Wheel Selection
• Rank Selection
• Tournament Selection
• etc
C. Genetic Algorithms: Steps (cont)
• Step 6:
• Create a pair of offspring chromosomes by applying the genetic
operators - crossover and mutation.
• Step 7:
• Place the created offspring chromosomes in the new population.
• Step 8:
• Repeat Step 5 until the size of the new chromosome population
becomes equal to the size of the initial population, N.
C. Genetic Algorithms: Steps (cont)
• Step 9:
• Replace the initial (parent) chromosome population with the new
(offspring) population.
• Step 10:
• Go to Step 4, and repeat the process until the termination
criterion is satisfied.
C. Genetic Algorithms: Crossover & Mutation
• Crossover and Mutation are genetic operators. There are several
techniques for these two operators

Crossover Techniques Mutation Techniques

one-point crossover insert mutation
n-point crossover swap mutation
uniform crossover inversion mutation
order 1 crossover scramble mutation
C. Genetic Algorithms: Crossover & Mutation
(cont)
• Crossover Technique 1: One-point Crossover
• Choose a random point on the two parents
• Split parents at this crossover point
• Create children by exchanging tails
• Pc typically in range (0.6, 0.9)
C. Genetic Algorithms: Crossover & Mutation
(cont)
• Crossover Technique 2: n-point Crossover
• Choose n random crossover points
• Split along those points
• Glue parts, alternating between parents
• Generalisation of 1 point (still some positional bias)
C. Genetic Algorithms: Crossover & Mutation
(cont)
• Crossover Technique 3: Uniform Crossover
• Assign 'heads' to one parent, 'tails' to the other
• Flip a coin for each gene of the first child
• Make an inverse copy of the gene for the second child
• Inheritance is independent of position
C. Genetic Algorithms: Crossover & Mutation
(cont)
• Crossover Technique 4: Order 1 Crossover
• A swath of consecutive alleles from parent 1 drops down
• Remaining values are placed in the child in the order which they
appear in parent 2.
C. Genetic Algorithms: Crossover & Mutation
(cont)
• Mutation Technique 1: Insert Mutation
• Pick two allele values at random
• Move the second to follow the first, shifting the rest along to
accommodate
• Note that this preserves most of the order and the adjacency
information
C. Genetic Algorithms: Crossover & Mutation
(cont)
• Mutation Technique 2: Swap Mutation
• Pick two alleles at random and swap their positions
• Preserves most of adjacency information (4 links broken), disrupts
order more
C. Genetic Algorithms: Crossover & Mutation
(cont)
• Mutation Technique 3: Inversion Mutation
• Pick two alleles at random and then invert the substring between
them.
• Preserves most adjacency information (only breaks two links) but
disruptive of order information
C. Genetic Algorithms: Crossover & Mutation
(cont)
• Mutation Technique 4: Scramble Mutation
• Pick a subset of genes at random
• Randomly rearrange the alleles in those positions
• (note subset does not have to be continuous)
C. Genetic Algorithms: Crossover & Mutation
(cont)
• Crossover OR Mutation?
• Decade long debate: which one is better / necessary / main-
background
• Answer (at least, rather wide agreement):
• it depends on the problem, but
• in general, it is good to have both
• both have another role
• mutation-only-EA is possible, xover-only-EA would not work
C. Genetic Algorithms: Crossover & Mutation
(cont)
• Crossover OR Mutation?
• Exploration: Discovering promising areas in the search space, i.e.
gaining information on the problem
• Exploitation: Optimising within a promising area, i.e. using
information
• Crossover is explorative, it makes a big jump to an area
somewhere “in between” two (parent) areas
• Mutation is exploitative, it creates random small diversions,
thereby staying near (in the area of ) the parent
C. Genetic Algorithms: Crossover & Mutation
(cont)
• Crossover OR Mutation?
• Only crossover can combine information from two parents
• Only mutation can introduce new information (alleles)
• Crossover does not change the allele frequencies of the
population (thought experiment: 50% 0’s on first bit in the
population, ?% after performing n crossovers)
• To hit the optimum you often need a ‘lucky’ mutation
D. Genetic Algorithms: Pseudocodes
{
initialize population;
evaluate population;
while TerminationCriteriaNotSatisfied
{
select parents for reproduction;
perform crossover and mutation;
evaluate population;
}
}
E. Genetic Algorithms: Case Study
• Find the maximum value of the function (15x - x2) where
parameter x varies between 0 and 15. Assume x only takes
integer values.
• Possible chromosomes:

(4 genes only because 15 in binary: 1111)

E. Genetic Algorithms: Case Study - Solution
• Step 1:
• chromosome population N is 6, crossover probability = 0.7,
mutation probability = 0.0001
• Step 2:
• fitness function: f(x) = 15 x - x2
E. Genetic Algorithms: Case Study - Solution
f(x) = 15 x - x2
• Step 3: f(12) = 15(12) - (12x12)
• randomly generated population = 180 - 144
= 36
• Step 4:
• calculate fitness
E. Genetic Algorithms: Case Study - Solution
• Step 5:
• select chromosomes for mating based on fitness 36/218 x 100
• calculate fitness ratio = 16.5%

sum = 218
E. Genetic Algorithms: Case Study - Solution
• Step 5 (cont):
• select chromosomes for mating based on fitness
• E.g: spin roulette wheel where chromosomes are given slices
based on fitness ratio
• spin 6 times (same as N)

Selected:
X6 and X2
X1 and X5
X2 and X5
E. Genetic Algorithms: Case Study - Solution
• Step 6
• generate offspring by using genetic operator - crossover
• (one-point crossover) randomly choose a crossover point
where two parent chromosomes “break”
• exchanges the chromosome parts after that point
• if pair of chromosomes does not crossover, cloning takes place
E. Genetic Algorithms: Case Study - Solution
• Step 6 (cont)
• generate offspring by using genetic operator - crossover

cloning
E. Genetic Algorithms: Case Study - Solution
• Step 6 (cont)
• generate offspring by using genetic operator – mutation
• flips a randomly selected gene in a chromosome
• mutation probability is quite small in nature, and is kept low for
GAs between 0.001 and 0.01
E. Genetic Algorithms: Case Study - Solution
• Step 6 (cont)
• generate offspring by using genetic operator – mutation
E. Genetic Algorithms: Case Study - Solution
• Step 7
• place the created offspring chromosomes in the new population.
• Step 8
• continue until population size is N = 6.
E. Genetic Algorithms: Case Study - Solution
• Step 9
• replace initial (parent) population with offspring population
• Step 10
• repeat until termination criterion (typically several hundreds
generations)

chromosomes initial locations chromosomes final locations

E. Genetic Algorithms: Case Study Cycle
Crossover
Generation i
X1i 1 1 0 0 f = 36 X6i 1 0 00 1 0 1 00 00 X2i
X2i 0 1 0 0 f = 44
X3i 0 0 0 1 f = 14
X4i 1 1 1 0 f = 14 X1i 10 11 00 00 0 11 11 11 X5i
X5i 0 1 1 1 f = 56
X6i 1 0 0 1 f = 54
X2i 0 1 0 0 0 1 1 1 X5i
Generation (i + 1)
X1i+1 1 0 0 0 f = 56 Mutation
X2i+1 0 1 0 1 f = 50 X6'i 1 0 0 0
X3i+1 1 0 1 1 f = 44
X2'i 0 1 0 10
X4i+1 0 1 0 0 f = 44
X1'i 10 1 1 1 1 1 X1"i
X5i+1 0 1 1 0 f = 54
X6i+1 0 1 1 1 f = 56 X5'i 0 1 01 01

X2i 0 1 0 0 1 0 X2"i

X5i 0 1 1 1
E. Genetic Algorithms: Case Study 2
• The Traveling Salesman Problem:
• Find a tour of a given set of cities so that each city is visited
only once the total distance traveled is minimized
E. Genetic Algorithms: Case Study 2 -
Individuals
• Representation is an ordered list of city numbers known as
an order-based GA.

1) London 3) Dunedin 5) Beijing 7) Tokyo

2) Venice 4) Singapore 6) Phoenix 8) Victoria

CityList1 (3 5 7 2 1 6 4 8)
CityList2 (2 5 7 6 8 1 3 4)
… etc
E. Genetic Algorithms: Case Study 2 -
Selection
• Fitness function calculates the total distance between each
city.

CityList1 (3 5 7 2 1 6 4 8)
CityList2 (2 5 7 6 8 1 3 4)
E. Genetic Algorithms: Case Study 2 -
Crossover
• Order 1 crossover

Parent1 (3 5 7 2 1 6 4 8)
Parent2 (2 5 7 6 8 1 3 4)

Child (5 8 7 2 1 6 3 4)
E. Genetic Algorithms: Case Study 2 -
Mutation
• Swap Mutation

Before: (5 8 7 2 1 6 3 4)

After: (5 8 6 2 1 7 3 4)
E. Genetic Algorithms: Case Study 2 –TSP
Example: 30 Cities
E. Genetic Algorithms: Case Study 2 –TSP30
Example: Solution i
E. Genetic Algorithms: Case Study 2 –TSP30
Example: Solution j
E. Genetic Algorithms: Case Study 2 –TSP30
Example: Solution k
E. Genetic Algorithms: Case Study 2 –TSP30
Example: Best Solution
E. Genetic Algorithms: Case Study 2 - TSP30
Example: Overview of Performance
F. Genetic Algorithms: Benefits
• Concept is easy to understand
• Modular, separate from application
• Supports multi-objective optimization
• Good for “noisy” environments
• Always an answer; answer gets better with time
• Inherently parallel; easily distributed
F. Genetic Algorithms: Benefits (cont)
• Many ways to speed up and improve a GA-based application as
knowledge about problem domain is gained
• Easy to exploit previous or alternate solutions
• Flexible building blocks for hybrid applications
• Substantial history and range of use
G. Genetic Algorithms: When to Use?
• Alternate solutions are too slow or overly complicated
• Need an exploratory tool to examine new approaches
• Problem is similar to one that has already been successfully solved by
using a GA
• Want to hybridize with an existing solution
• Benefits of the GA technology meet key problem requirements
H. Genetic Algorithms: Some Application
Types
Domain Application Types
Control gas pipeline, pole balancing, missile evasion, pursuit

Design semiconductor layout, aircraft design, keyboard

configuration, communication networks
Scheduling manufacturing, facility scheduling, resource allocation

Robotics trajectory planning

Machine Learning designing neural networks, improving classification

algorithms, classifier systems
Signal Processing filter design

Game Playing poker, checkers, prisoner’s dilemma

Combinatorial set covering, travelling salesman, routing, bin packing,

graph colouring and partitioning
Optimization
I. Genetic Algorithms: Past Year Question
N is 4 and the chromosomes are built in the form of x=abcdef. Each
gene has integer values ranging from 0-9. Fitness function: f(x) = (a* b)
+ (c * d) - (e + f)
The initial population:
X1 = 247125 X2 = 354246 X3= 415312 X4= 256234
a) Calculate the fitness of each individual chromosome, and arrange them in
descending order where the objective is to find the maximum value of x.
b) Apply crossover on the first and second chromosomes using a one-point
crossover which is in the middle
c) Apply mutation for all chromosomes by swapping the first gene with the last
gene
Genetic Programming
J. Genetic Programming: Introduction
• An evolutionary algorithm-based methodology inspired by biological
evolution to find computer programs that perform a user defined task
• Genetic Programming (GP) is a set of instructions and a fitness
function to measure how well a computer has performed a task.
• It is a specialization of Genetic Algorithm (GA) where each
individual is a computer program.
• A machine learning used to optimize a population of computer
program according to a fitness landscape determined by a
program’s ability to perform a given computational task.
J. Genetic Programming: Introduction (cont)
• Genetic programming is an extension of the conventional genetic
algorithm, but the goal of genetic programming is not just to evolve a
bit-string representation of some problem but the computer code
that solves the problem
• Genetic programming creates computer programs as the solution,
while GAs create a string of binary numbers that represent the
solution.
K. Genetic Programming: Why?
• It saves times by freeing the human from having to design complex
algorithm.
• Not only designing the algorithms but creating ones that give optimal
solutions
L. Genetic Programming: How?
• Any computer program is a sequence of operations (functions)
applied to values (arguments)
• E.g: y * 3;
• Different programming languages may include different
types of statements and operations, and have different syntactic restrictions
• Genetic programming manipulates programs by applying genetic
operators
• Programming language that permits a computer program to be
manipulated as data: LISP
L. Genetic Programming: How – (What is
LISP?)
• LISP (List Processor) has two basic structures of atoms and lists
• Atom: smallest indivisible element of LISP Syntax
• List: Object composed of atoms and/or other lists
• Example: list

(-(*A B) C)

atoms

• This expression of atoms and lists are called symbolic expressions or S-

expressions
L. Genetic Programming: How – (What is
LISP?) (cont)
• Any LISP S-expression can be depicted as a rooted point-labelled tree
with ordered branches (syntax tree).
• Three has points that each represents either a function or a terminal
function

terminal

Tree for S-expression (-(*A B) C)

L. Genetic Programming: How? –
Representations
• In GP, programs are represented by syntax tree rather than lines of
codes
• The variables and constants in the program are leaves of the tree. In
GP they are called terminals, whilst the arithmetic operations are
internal nodes called functions.
• The sets of allowed functions and terminals together form the
primitive set of a GP system
L. Genetic Programming: How? –
Representations (cont)
• Examples of primitives in Genetic Programming: function and
terminal sets

Function Set Terminal Set

Kind of Primitive Example(s) Kind of Primitive Example(s)
Arithmetic +, *, / Variables x, y
Mathematical sin, cos, exp Constant values 3, 0.45
Boolean AND, OR, NOT 0-arity functions rand, go left
Conditional IF-THEN-ELSE
Looping FOR, REPEAT
... ...
L. Genetic Programming: How? –
Representations (cont)
• Example of syntax tree for operation: max(x+x,x+3*y)
L. Genetic Programming: How? –
Representations (cont)
• It is common in GP literature to represent expression in a prefix
notation. E.g: y * 3 = * y 3
• In more advanced forms of GP, programs can be composed of
multiple components (e.g., subroutines).

Multi-component program representation

L. Genetic Programming: How? (cont)
• The basic control flow of genetic programming, where survival of the
fittest is used to find solutions is shown below:
M. Genetic Programming: Steps
1. Randomly create an initial population of programs from the available
primitives
2. repeat
3. Execute each program and ascertain its fitness.
4. Select one or two program(s) from the population with a probability
based on fitness to participate in genetic operations
5. Create new individual program(s) by applying genetic operations with
specified probabilities
6. until an acceptable solution is found or some other stopping condition is
met (e.g., a maximum number of generations is reached).
7. return the best-so-far individual.
M. Genetic Programming: 1. Individual
• In GP the individuals in the initial population are typically randomly
generated
• The main parameter for the initialization method is the maximum tree
depth (number of edges that need to be traversed to reach the node
starting from the tree’s root node)
• Depth of tree = depth of its deepest leaf
• This parameter is used to restrict the size of the initialized trees
• There are a number of different approaches to generating this random
initial population
• full method
• grow method
• ramped half-and-half (combination of full and grow)
M. Genetic Programming: 1. Individual (Full
Method )
• Starting from root, nodes are taken at random from the function set
until the maximum depth is reached
• Beyond that depth, only terminals can be chosen
• Full method generates trees where all the leaves are at the same
depth
M. Genetic Programming: 1. Individual (Full
Method ) - Example
• Full tree of depth 2, when depth is < 2, choose from function set, else
from terminal set
• function set = {+, -, *, /}
• terminal set = {x, y, 0, 1, 2}

depth = 0 depth = 1 depth = 2

depth = 2
M. Genetic Programming: 1. Individual (Grow
Method )
• Starting from root, nodes are taken at random from the primitive set
(function and terminal set) until the maximum depth is reached
• Beyond that depth, only terminals can be chosen (same as full
method)
• Grow method allows for the creation of trees of more varied sizes and
shapes
M. Genetic Programming: 1. Individual (Grow
Method ) - Example
• Full tree of depth 2, when depth is < 2, choose from primitive set, else
from terminal set
• function set = {+, -, *, /}
• terminal set = {x, y, 0, 1, 2}

depth = 0 depth = 1 depth = 1

depth = 2
M. Genetic Programming: 1. Individual
(Ramped Half-and-Half Method)
• Combines both full and grow methods
• Produces trees of various shapes and sizes (up to maximum depth,
md)
• Population is first evenly divided into equal parts (md -1)
• Then for each parts half the trees will be generated using full method
and the other half using the grow method
• Thus a population is created with good variation
M. Genetic Programming: 1. Individual (Ramped
Half-and-Half Method) - Example
• Population is 30, maximum depth is 6
• Divide population into 6-1 = 5 parts

depth = 2 depth = 3 depth = 4 depth = 5 depth = 6

3 full 3 full 3 full 3 full 3 full
3 grow 3 grow 3 grow 3 grow 3 grow
M. Genetic Programming: 2. Selection
• Just like GA, genetic operators (crossover & mutation) in GP are
applied to individuals that are selected based on their fitness
• Better individuals are more likely to have more child programs than
inferior individuals
• The fitness measure is a problem specific issue that has to answer the
question “how good (or bad) is this individual?”
• In the robotic soccer domain, the question could be replaced with an
algorithm like: let the individual play soccer for five minutes; the fitness value
is the same as the number of goals scored. ⚽
M. Genetic Programming: 3. Crossover
• In this technique genetic material from two individuals is mixed to
form off-spring.
• The most commonly used form of crossover is subtree crossover
• Given two parents, subtree crossover randomly (and independently)
selects a crossover point (a node) in each parent tree.
M. Genetic Programming: 3. Crossover –
Example 1
M. Genetic Programming: 3. Crossover –
Example 2
M. Genetic Programming: 4. Mutation
• The most commonly used form of mutation in GP is called subtree
mutation
• It randomly selects a mutation point in a tree and substitutes the
subtree rooted there with a randomly generated subtree
M. Genetic Programming: 4. Mutation –
Example 1
M. Genetic Programming: 4. Mutation –
Example 2
N. Genetic Programming: Preparatory Steps
The key choices are:
1. What it the terminal set?
2. What is the function set?
3. What is the fitness measure?
4. What parameters will be used for controlling the run?
• E.g: population size
5. What will be the termination criterion, and what will be designated
the result of the run?
N. Genetic Programming: Preparatory Steps
(cont)
O. Genetic Algorithm vs Genetic Programming
• GP is much powerful than GA.
• The output of the GA is a quantity (bit strings that represent
coded solutions), while output of GP is a another computer program.
• Where there is no ideal solution, GP works best (ex. A program that
drives a car).
P. Genetic Programming: Sample Questions
1. Given the following S-expressions, represent them in the form of
syntax tree
a) (+(-ab)c)
b) (* 5 (- 7 3))
2. Perform a crossover operation on the trees above where the
crossover point is the node with ‘-’ function
Evolutionary Programming
Q. Evolutionary Programming: Introduction
• Evolutionary Programming model evolution as a process of adaptive
behavior of individuals and species rather than of adaptive genetics
• It defines evolution as process that generates organisms of increasing
intellect over time – learning process
• Populations of trial solutions are evolved, but the solutions are
modified such that there is a continuous diversity of behaviors while
at the same time maintaining a strong behavioral link between
parents and offspring.
• EP is similar to GP but the structure of the program to be optimized is
fixed, while its numerical parameters are allowed to evolve
R. Evolutionary Programming: 1. Individual
• Evolutionary Programming individuals (each representing whole
species) is determined by the optimization problem it is solving
• Therefore there is no restriction on the data types that can be
processed (real-valued vectors)
• Examples:
• Neural networks
• Finite state machines
• Electronic circuits
R. Evolutionary Programming: 2. Selection
• In EP, each individual creates one child by mutation
• Thus, EP is deterministic and not biased by fitness
• However these parents and offspring populations are then merged
and compete for survival in a round-robin tournament format
R. Evolutionary Programming: 3. Crossover
• None
• Rationale: one point in the search space stands for a species, not for
an individual and there can be no crossover between species
• Much historical debate “mutation vs. crossover”
• Pragmatic approach seems to prevail today
R. Evolutionary Programming: 4. Mutation
• EP Mutation operator is problem or data type specific
• Each problem can use different attribute data types for the individuals
• Example of mutations for finite state machines:
• add a state
• delete a state
• change the start state
• change an output symbol
• change a state transition
S. Summary
• Genetic algorithm is the most popular type of EA. One seeks the
solution of a problem in the form of strings of numbers (traditionally
binary, although the best representations are usually those that
reflect something about the problem being solved virtually always
applying recombination operators in addition to selection and
mutation
• This type of EA is often used in optimization problems.
• It is very important to note, however, that while evolution can be
considered to approach an optimum in computer science terms,
actual biological evolution does not seek an optimum.
S. Summary
• Evolutionary programming - Like genetic programming, only the
structure of the program is fixed and its numerical parameters are
allowed to evolve, and its main variation operator is mutation
• Genetic programming - Here the solutions are in the form of
computer programs, and their fitness is determined by their ability to
solve a computational problem.
T. Review Questions
• Define GA, GP and EP
• What is the purpose of applying EA?
• What type of problems are suitable to apply EA?
References
• http://www0.cs.ucl.ac.uk/staff/W.Langdon/ftp/papers/poli0
8_fieldguide.pdf
• https://www.win.tue.nl/ipa/archive/falldays2007/HandoutEg
germont.pdf
• https://www.cs.montana.edu/~bwall/cs580/introduction_to
_gp.pdf
• https://w3.onera.fr/smac/tracker
• http://cslt.riit.tsinghua.edu.cn/mediawiki/images/e/e8/Intro
duction_to_Evolutionary_Computing.pdf