Evolution of Search Algorithms
Using Graph Structured Program Evolution
Shinichi Shirakawa and Tomoharu Nagao
Graduate School of Environment and Information Sciences, Yokohama National
University, 79-7, Tokiwadai, Hodogaya-ku, Yokohama, Kanagawa, 240-8501, Japanshirakawa@nlab.sogo1.ynu.ac.jp, nagao@ynu.ac.jp

Abstract. Numerous evolutionary computation (EC) techniques andrelated improvements showing effectiveness in various problem domains
have been proposed in recent studies. However, it is difficult to design
effective search algorithms for given target problems. It is therefore essential to construct effective search algorithms automatically. In this paper,
we propose a method for evolving search algorithms using Graph Structured Program Evolution (GRAPE), which has a graph structure and is
one of the automatic programming techniques developed recently. We apply the proposed method to construct search algorithms for benchmark
function optimization and template matching problems. Numerical experiments show that the constructed search algorithms are effective for
utilized search spaces and also for several other search spaces.

1

Introduction

Automatic programming, which generates computer programs automatically, hasbeen actively investigated in recent studies. Genetic programming (GP) [1] is atypical example of automatic programming, which was originally introduced by
Koza. GP evolves computer programs, which usually have a tree structure, andsearches for a desired program using a genetic algorithm (GA). Various representations for GP have been proposed thus far, including graph representation.
The advantages of a graph structure are that it can represent complex structurescompared with tree structures, and that it can contain time-series informationin its graph structure. Graph Structured Program Evolution (GRAPE) [2, 3] is
one of a number of automatic programming techniques developed recently. The
representation of GRAPE is a graph structure, therefore, it can represent complex programs (e.g., branches and loops) using this structure. The genotype of
GRAPE is in the form of a linear string of integers. GRAPE succeeds in generating complex programs automatically (e.g., factorial, exponentiation, list sorting,etc.). The study described in this paper is based on this GRAPE technique.
Numerous evolutionary computation (EC) techniques and related improvements, showing their effectiveness in various problem domains such as function
optimization and combination problems, have been proposed. In addition, no
free lunch (NFL) theorems [4] show that all black-box search algorithms have thesame average performance over the entire set of optimization problems. Therefore, it is essential to construct a search algorithm that is efficient in its approachto certain problems. In general, it is difficult to instantly construct efficient
search algorithms for the given problems. Moreover, the automatic constructionof search algorithms requires the use of key techniques. In this context, Meta
GA, which optimizes the parameters of GA using GA, was proposed. Parameters such as population size, crossover rate, and mutation rate can be optimized
in Meta GA. In addition, several techniques for the evolution of evolutionary
algorithms have been investigated [5–8]. A method for evolving evolutionary
algorithms, which evolves generation alternation procedures, was proposed by
Oltean [6]. Dioşan and Oltean proposed a method for evolving crossover operators for evolutionary function optimization using GP [7] and a method forevolving the structure of a particle swarm optimization (PSO) algorithm [8].
Recently, the researches on hyper-heuristics, which are the methods to combine heuristics to generate new ones, have attracted increasing attentions. Several literatures on hyper-heuristics using GP are existed. Burke et al. generated
a heuristic for the bin-packing problem using GP [9]. Kumar et al. showed that
GP can evolve a set of heuristics for biobjective 0/1 knapsack problem [10].
Pillay and Banzhaf generated a heuristic for the timetabling problem [11]. The
motivation of this work is the same as hyper-heuristics.
Our aim is to construct more efficient search strategies automatically sothat they resemble human-designed search algorithms. In this study, we generate search algorithms by evolving the programs of moving agents in the search
spaces using GRAPE. In particular, we focus on function optimization problems. A search algorithm is represented by a graph structure. The parameters
are updated at each node. We apply the proposed method to benchmark function optimization problems and template matching problems. After evolving thesearch algorithms, we apply them to test problems that were not used during
their evolution in order to verify their efficiency and versatility.
An overview of GRAPE is presented in the next section. In Section 3, we describe our proposed method, the evolution of search algorithms using GRAPE.
Next, in Section 4, we apply the proposed method to the problem of the automatic construction of search algorithms and show several experimental results.
Finally, in Section 5, we present our conclusions and possible future work.

2

Graph Structured Program Evolution (GRAPE)

GRAPE [2, 3] constructs graph-structured programs automatically. The featuresof GRAPE are summarized as follows:– Arbitrary directed graph structures.
– Ability to handle multiple data types using a data set.
– Genotype of an integer string.
A graph-structured program is composed of an arbitrary directed graph of nodes
and a data set. The data set through flows the directed graph and is processed at

Fig. 1. Structure of GRAPE (phenotype) and the genotype, which denotes a list ofnode types, connections, and arguments.

each node. In GRAPE, each node has two parts, one for processing and the otherfor branching. The processing component executes several types of processing
using the data set, e.g., arithmetic calculation and Boolean calculation. After
processing is complete, the next node is selected. The branching component decides the next node according to the data set. When the output node is reached,
the GRAPE program outputs data and the program terminates. The representation of GRAPE is a graph structure; therefore, it can represent complex
programs (e.g., branches and loops) using this structure. There are several datatypes in the GRAPE program: integer data type, Boolean data type, list data
type, and so on. The GRAPE program handles multiple data types using thedata set for each type. To adopt an evolutionary method, genotype-phenotype
mapping is used in GRAPE. This genotype-phenotype mapping method is similar to Cartesian GP (CGP) [12]. The GRAPE program is encoded in the form ofa linear string of integers. The genotype is an integer string, which denotes a listof node types, connections, and arguments. Although the genotype in GRAPE
is a fixed-length representation, the number of nodes in the phenotype can vary
but is bounded (not all of the nodes encoded in the genotype have to be connected). This allows the existence of inactive nodes. GRAPE has been shown togenerate a variety of programs successfully, such as factorial, Fibonacci sequence,
exponentiation, list reversing, and list sorting.

3

Evolution of Search Algorithms using GRAPEIn this study, an action program of searching agents is evolved by GRAPE. The
agents search for optimal parameters in the search space. The search algorithm
is achieved using the agents control program represented by GRAPE. The agentsdecide the next search point by moving through the search space in this model.

Fig. 2. Distributions of generated parameters using the prepared node functions (twodimensions).

An example of the GRAPE program is shown in Figure 1. The data set (parameters) of GRAPE contains the parameters of the target problem. The data set
flows the directed graph and is updated at each node. Following this, the parameters are evaluated when the evaluation node is reached, and then it moves
to the next node. After the evaluations of the predefined numbers, the searchfinishes.
Table 1 shows the node functions used in the experiments. Examples of nodefunctions used in the experiments are the initialization of parameters with uniformly distributed random numbers, the substitution of other parameters, andthe update of the parameters using two parameter sets with either uniformly
distributed random numbers or normally distributed random numbers. Whenthe parameters are updated, the agent (p) selects the best global parameters(q0), the best local parameters (q1), or the parameters of the random selectedagent (q2), shown as parameters “q” in Table 1. The best global parameters
are the best parameters of all agents; The best local parameters are the bestparameters of the agent. These nodes are based on operators that are usuallyused in real-coded genetic algorithms [13, 14]. For instance, N16 is the BLX − α[13]. Examples of generated parameters using these node functions are shown in
Figure 2. This figure shows examples in the case of two-dimensional parameters.
Moreover, the evaluation node (EVAL) has three branching components, whichcorrespond to an updating global best, an updating local best, and another casescenario.
A better search algorithm is evolved based on the results using the searchalgorithm represented by GRAPE. While the operator at each node is relatively
simple, it can construct complex search algorithms using a combination of these
operators.
The fitness assignment of each individual is based on the results of the search
for target search spaces, e.g., the summed best fitness for several search simulations. In this manner, a search algorithm, which is efficient for specific problems,
is obtained.

Table 1. Node functions used in the experiments.
Id# Connection Argument Definition
For a random selected parameter pr
1–
Initialize the parameter pr with uniform random number.
1q
p r = qr1
q
pr = pr + u(pr − α|pr − qr |, pr + α|pr − qr |)1
q
pr = u(min(pr , qr ) − α|pr − qr |, max(pr , qr ) + α|pr − qr |)1
q
pr = N (pr , (α|pr − qr |)2 )(p +q )
1q
pr = N ( r 2 r , (α|pr − qr |)2 )For the all parameters pi (i = 1, 2, 3, ...)
1–
Initialize the all parameters pi with random number.
1q
p i = qi1
qpi = pi + u(pi − α|pi − qi |, pi + α|pi − qi |)1
qpi = u(min(pi , qi ) − α|pi − qi |, max(pi , qi ) + α|pi − qi |)1
qpi = N (pi , (α|pi − qi |)2 )(p +q )
1qpi = N ( i 2 i , (α|pi − qi |)2 )Other types
1qpi = (pi − αdei ) + R · ((qi + αdei ) − (pi − αdei ))(q −p )
d: the distance between pi and qi , ei = |qi −pi | , R = u(0.0, 1.0)ii1qpi = pi + zei(q −p )
z = N (0, (αd)2 ), d: the distance between pi and qi , ei = |qi −pi |

N1
N2
N3
N4
N5
N6
N7
N8
N9
N10
N11
N12
N13
N14
N15

1

q

N16

2

–

EVAL

3

–

(p +q )iipi = i 2 i + zei(q −p )
z = N (0, (αd)2 ), d: the distance between pi and qi , ei = |qi −pi |ii
Decide the next node with rondom number.
If u(0.0, 1.0) < 0.5, then connection 1 is chosen.
Else connection 2 is chosen.
Evaluation node
Evaluate the current parameters p.
And if global best is updated, then connection 1 is chosen.
Else if local best is updated, then connection 2 is chosen.
Else connection 3 is chosen.

pi : ith parameter of agent p.
qi : ith parameter of partner agent q.
(q is best global parameters (q0) or best local parameters (q1)or parameters of other randomly selected agents (q2).)u(x, y): uniformly distributed random number among [x, y].
N (µ, σ 2 ): normally distributed random number.
Parameter α = 0.5.

4

Experiments and Results

In this section, we apply the proposed method to the evolution of search algorithms. The target problems are the benchmark function optimization andthe template matching problems. Template matching is an important real-world
problem. After evolving the search algorithm, we apply it to test problems thatare not used during evolution in order to verify its efficiency and versatility.
4.1

Experimental Settings

The parameters used in the experiments are listed in Table 2. In order to avoid
the problem caused by the non-reaching structures of the evaluation node, we
limited the number of execution steps to 50. When the program reaches the execution limit, the individual is assigned the worst fitness value. We used uniform

Table 2. Parameters used in the experiments.
Parameters for GRAPE
Number of generations
10000
Population size
100
Children size (for MGG)
20
Crossover rate
0.6
Uniform crossover rate (Pc )0.1
Mutation rate (Pm )0.02
Maximum number of nodes
50
Execution step limits
50
Parameters for search simulation
Number of agents
1, 10, 50
Number of function evaluations 10000 (benchmark functions)
5000 (template matching)Number of trials (Nt )5crossover and mutation as the genetic operators. The Minimal Generation Gap(MGG) [15, 16] is used as the generation alternation model. The MGG model
is a steady-state model proposed by Satoh et al. The MGG model has a desirable convergence property maintaining the diversity of the population andshows higher performance than other conventional models in a wide range of applications. GRAPE used with the MGG model shows higher performance than
GRAPE used with Simple GA in a variety of program evolutions [2].
4.2

Benchmark Function

The Rastrigin-d function is used in order to evaluate the search algorithm represented by GRAPE. The Rastrigin-d function is defined in equation (1) and isa multimodal function.
nPf (x1 , ..., xn ) = 10n +{(xi − d)2 − 10cos(2π(xi − d))}i=1
(1)(−5.12 ≤ xi ≤ 5.12)
where n is the number of dimensions. This function has the global minimum
value 0 at (d, ..., d). In this experiment, we use n = 20 and d = 1.0.
The parameters are randomized with the domain of definition. Then, search is
performed using the algorithm represented by GRAPE for a predefined numberof evaluations. We use 1, 10, and 50 as the number of agents in order to verify
the influence of this parameter. If the number of agents is greater than 1, allagents refer to the same search algorithm represented by GRAPE (this model ishomogeneous). Equation (2) is used as the fitness function of each individual in
GRAPE.
Nt
X
f itness = −
fi
(2)
i=1

where fi is the best evaluation value of the ith search simulation, and Nt is thenumber of trials. The higher the numerical value, the better is the performance.

(a) Function optimization(b) Template matching
Fig. 3. Obtained search algorithm structures for (a) a benchmark function optimization
problem and (b) a template matching problem using GRAPE (number of agents is 10).

We tested the evolution of the search algorithms using these experimental settings and obtained a search algorithm represented by GRAPE, which is efficientwith respect to the Rastrigin-d function.
Figure 3 (a) shows an example of the obtained structure (graph-structured
search algorithm) constructed by the proposed method when the number of
agents is 10. Unnecessary nodes are deleted in this structure. The processing
branches to two through the difference in the evaluation of the structure. This
structure is relatively simple. However, we can see a more complex structurethat is difficult to understand at sight in other experiments.
Next, we apply the obtained search algorithms to other test functions. We
use the famous seven test functions in Table 3. The experimental condition is asfollows:

Table 3. Test functions used in the experiments. Sphere, Ridge, and Rosenbrock are
unimodal functions. Rastrigin, Ackley, and Schwefel are multimodal functions. n is thenumber of dimensions.
Name
SphereFunctions
f =

n
P
2

xi

Range of xi

fmin[−100, 100]

0[−100, 100]

0[−30, 30]0[−5.12, 5.12]

0[−32, 32]

0

i=1
n

Ridge

f =

i
P P

(

x j )2i=1 j=1
n−1

Rosenbrock f =P{100(xi+1 − x2i )2 + (xi − 1)2 }i=1

Rastriginn

f = 10n +P{x2i − 10cos(2πxi )}i=1

AckleySchwefel

f = 20 − 20exp(−0.2
f =

n
P

i=1

−xi sin(

p

r

n
1
n

n

P 2

1
xi ) + e − exp( ni=1P

cos(2πxi ))i=1|xi |)[−500, 500] −418.98 ∗ n– Number of dimensions n: 10, 20, 30– Number of trials: 50– Number of function evaluations: 5.0 × 105
We use a sufficient value as the number of function evaluations.
For comparison with conventional search algorithms, we compare the performance of our method with that of particle swarm optimization (PSO) [17,18]. PSO is one of a number of search algorithms introduced by Kennedy andEberhart. It is categorized as an evolutionary algorithm and is based on an analogy of the movement of the flight of a flock of birds. Each particle represents
a searching point in search space. The particles start at a random initial position and search for the minimum or maximum of a given objective function by
moving through the search space. Each particle includes information relating to“a velocity vector,” “a current position vector,” and “own best position vector.”
Moreover, all particles have the same information, i.e., “a position vector of thebest particle of all (global best).” At each iteration, a new velocity vector and a
new position vector for each particle update provides a better solution according
to these four factors. The updating equations arevi = ωvi + c1 r1 (x̂ − xi ) + c2 r2 (x̂g − xi )(3)

xi = x i + v i(4)where xi is the ith particle’s position vector, Vi is the ith particle’s velocity
vector, x̂ is the ith particle’s previous best position vector, and x̂g is the global
best vector. The parameters ω, c1 , and c2 are the coefficients of weight. We set
ω = 0.72, c1 , c2 = 1.49. These values are recommended in [18]. The variables

Table 4. The average performances for benchmark functions determined by applying
the evolved search algorithm and PSO (average over 50 trials with the same parameter
set). n is the number of dimensions. The values shown in the parentheses are calculatedusing standard deviation.
Functionn # agents = 1 # agents = 10 # agents = 50
PSO
10 2.36 × 10−32 1.72 × 10−116 4.10 × 10−119
0.0(6.58 × 10−32 ) (8.25 × 10−116 ) (1.38 × 10−118 )(0.0)
Sphere20 7.05 × 10−28
2.54 × 10−81
2.41 × 10−84 4.94 × 10−324(1.51 × 10−27 ) (7.96 × 10−81 ) (7.24 × 10−84 )(0.0)
30 3.91 × 10−25
2.92 × 10−65
1.77 × 10−67 6.32 × 10−179
−25
−64
−67
(7.38 × 10
) (1.29 × 10
) (9.35 × 10)
(0.0)
10 2.10 × 10−30 3.25 × 10−114 8.62 × 10−117 1.22 × 10−276(1.06 × 10−29 ) (2.17 × 10−113 ) (3.84 × 10−116 )
(0.0)
Ridge
20 4.00 × 10−25
3.27 × 10−79
1.28 × 10−82
5.33 × 102
−24
−78
−82
(2.04 × 10
) (1.11 × 10
) (3.27 × 10
) (1.63 × 103 )30 1.03 × 10−22
5.64 × 10−62
2.53 × 10−65
4.07 × 103(1.66 × 10−22 ) (3.75 × 10−61 ) (9.50 × 10−65 ) (5.05 × 103 )
10
8.22
4.36
4.74
3.74 × 103(7.48)(5.95)(6.30)(1.78 × 104 )Rosenbrock 20
9.75
4.90
7.14
9.07 × 103(8.26)(6.04)(7.88)(2.73 × 104 )30 1.20 × 101
8.65
7.49
1.11 × 104(1.49 × 101 )(7.92)(1.15 × 101 )(2.94 × 104 )10 7.39 × 10−15
4.52 × 10−14
1.11 × 10−14
6.27(1.07 × 10−14 ) (6.14 × 10−14 ) (1.34 × 10−14 )(3.35)−14−13−14
Rastrigin
20 4.04 × 10
3.16 × 10
7.22 × 10
3.79 × 101(4.14 × 10−14 ) (2.76 × 10−13 ) (5.25 × 10−14 ) (1.18 × 101 )30 1.51 × 10−13
2.80 × 10−12
2.58 × 10−13
9.38 × 101(9.69 × 10−14 ) (9.27 × 10−12 ) (1.37 × 10−13 ) (2.91 × 101 )10 1.68 × 10−14
3.42 × 10−14
1.44 × 10−14 4.00 × 10−15(5.36 × 10−15 ) (2.76 × 10−14 ) (6.27 × 10−15 ) (3.61 × 10−2 )Ackley20 4.80 × 10−14
1.57 × 10−13
3.42 × 10−14
3.29 × 10−1
(1.58 × 10−14 ) (2.88 × 10−13 ) (1.11 × 10−14 ) (2.23 × 10−2 )30 2.29 × 10−13
4.23 × 10−13
5.69 × 10−14
1.79(1.11 × 10−13 ) (1.10 × 10−12 ) (1.20 × 10−14 )(8.86)
10 −4.19 × 103−4.19 × 103−4.19 × 103−3.52 × 103(9.09 × 10−13 ) (1.66 × 101 )(9.09 × 10−13 ) (2.40 × 102 )Schwefel
20 −8.38 × 103−8.38 × 103−8.38 × 103−6.29 × 103(1.82 × 10−12 ) (1.82 × 10−12 ) (1.82 × 10−12 ) (4.76 × 102 )30 −1.26 × 104−1.26 × 104−1.26 × 104−8.90 × 103(7.28 × 10−12 ) (7.28 × 10−12 ) (7.28 × 10−12 ) (5.73 × 102 )r1 and r2 are random numbers in the range [0.0, 1.0]. In the experiments, thenumber of particles is 50.
Table 4 shows the search results for 50 different runs with the same parameter set. According to these results, the evolved search algorithms perform
significantly better than the conventional PSO algorithm. The evolved searchalgorithms are effective not only in relation to the Rastrigin function for the
training search space, but also in terms of other test functions. It also shows
better performance in a variety of problem dimensions. Although the search algorithms are generated using only the Rastrigin-d function (20 dimensions), they
can be useful for other types of test functions.

4.3

Template Matching

Template matching is an important technique for investigating similarities between two patterns, predefined patterns (template) and target patterns. Template matching is also useful for the detection of an object by determining its
position, angle, and magnification ratio in an image. For the detection of a
two-dimensional object, four parameters (x-coordinate, y-coordinate, angle, andmagnification ratio) must be optimized in template matching. We use a simple
objective function: the normalized sum of absolute difference between the template image and the target image. The equation for the objective function in theexperiments is as follows:1f (x, y, rate, angle) = W ·H·V
max

H
W P
P

|fi0 j 0 − tij |i=1 j=1Hi0 = rate ∗ ((i − W2 ) ∗ cos(angle) + (j − 2 ) ∗ sin(angle)) + x
W
j 0 = rate ∗ ((i − 2 ) ∗ sin(angle) + (j − H2 ) ∗ cos(angle)) + y(5)where tij is the brightness of the template image, fij is the brightness of thetarget image, W and H denote the image size of the template image, and Vmax
is the maximum brightness. This objective function should be minimized.
The template images and the target image used in the experiment are shownin Figure 4. These are grayscale images, with the size of the template image
being 64 × 64 pixels, and the size of the target images 640 × 480 pixels. The
ranges of each parameter are as follows:– Positions of template image: 0 ≤ x ≤ X, 0 ≤ y ≤ Y (X and Y denote theimage size of the target image)– Magnification ratio: 1.0 ≤ rate ≤ 2.0– Angle: −180◦ ≤ angle ≤ 180◦
The parameters used in the experiment are shown in Table 2. Target image 1
and the template image in Figure 4 are used to evolve the search algorithm
represented by GRAPE. Equation (2) is also used as the fitness function ofeach individual in GRAPE. By these settings, we obtain a search algorithm,
which is effective to template matching. Figure 3 (b) shows an example of theobtained structure (graph-structured search algorithm) constructed by the proposed method when the number of agents is 10.
The performances of the evolved search algorithms and PSO are shown in
Table 5. The number of evaluations is 10000. We use the two target images shownin Figure 4. The evolved search algorithms perform better than the conventional
PSO algorithm for both target images. Therefore, we can conclude that generalsearch algorithms for template matching can be constructed automatically.

5

Conclusions and Future WorkIn this paper, we proposed a new method for the automatic construction of
search algorithms based on GRAPE, which evolves graph-structured programs.

Template image
Target image 1

Target image 2

Fig. 4. Target images and the template image used in the experiments. Target image 1
is used for constructing the search algorithms. Target image 2 is applied to the evolved
search algorithm.
Table 5. The average performances for template matching problems found by applying
the evolved search algorithm and PSO (average over 50 trials with the same parameter
set). Best/Worst refers to the fitness of the best individual in the best/worst run,respectively. The number of evaluations is 10000.
# agents=1 # agents=10 # agents=50 PSO
Target image 1
Average
0.08900.08890.08900.105
Stddev
0.00501
0.005780.004240.0137Best
0.08460.08450.08450.0858
Worst
0.107
0.107
0.103
0.134
Target image 2
Average
0.07350.0726
0.07140.0793
Stddev
0.00684
0.00328
0.002810.0113Best
0.06980.06980.0698
0.070
Worst
0.116
0.07760.07900.132

We applied the proposed method to evolve search algorithms for function optimization and template matching problems and confirmed that efficient searchalgorithms for each problem were obtained by the proposed method. From theexperimental results, the performances of evolved search algorithms were foundto outperform a conventional PSO algorithm. In future work, we will apply the
proposed method to other types of problems. Further, we will propose a method
for evolving search algorithms with a heterogeneous model.

References
1. Koza, J.R.: Genetic Programming: On the Programming of Computers by Meansof Natural Selection. MIT Press (1992)
2. Shirakawa, S., Ogino, S., Nagao, T.: Graph Structured Program Evolution. In:
Proceedings of the Genetic and Evolutionary Computation Conference (GECCO2007). Volume 2., London, UK, ACM Press (2007) 1686–1693

3. Shirakawa, S., Nagao, T.: Evolution of sorting algorithm using graph structured
program evolution. In: Proceedings of the 2007 IEEE International Conference on
Systems, Man and Cybernetics (SMC 2007), Montreal, Canada (2007) 1256–1261
4. Wolpert, D., Macready, W.: No free lunch theorems for optimization. IEEE Transactions on Evolutionary Computation 1(1) (1997) 67–82
5. Tavares, J., Machado, P., Cardoso, A., Pereira, F.B., Costa, E.: On the evolutionof evolutionary algorithms. In: Proceedings of the Genetic Programming 7th European Conference (EuroGP 2004). Volume 3003 of LNCS., Coimbra, Portugal,
Springer-Verlag (2004) 389–398
6. Oltean, M.: Evolving evolutionay algorithm using linear genetic programming.
Evolutionary Computation 13(3) (2005) 387–410
7. Dioşan, L., Oltean, M.: Evolving crossover operators for function optimization. In:
Proceedings of the 9th European Conference on Genetic Programming (EuroGP
2006). Volume 3905 of LNCS., Budapest Hungary, Springer-Verlag (2006) 97–108
8. Dioşan, L., Oltean, M.: Evolving the structure of the particle swarm optimization
algorithms. In: Proceedings of the 6th European Conference on Evolutionary Computation in Combinatorial Optimization (EvoCOP 2006). Volume 3906 of LNCS.,
Budapest Hungary, Springer-Verlag (2006) 25–36
9. Burke, E.K., Hyde, M.R., Kendall, G.: Evolving bin packing heuristics with genetic
programming. In: Parallel Problem Solving from Nature - PPSN IX. Volume 4193
of LNCS., Reykjavik, Iceland, Springer-Verlag (2006) 860–869
10. Kumar, R., Joshi, A.H., Banka, K.K., Rockett, P.I.: Evolution of hyperheuristics forthe biobjective 0/1 knapsack problem by multiobjective genetic programming. In:
Proceedings of the Genetic and Evolutionary Computation Conference (GECCO2008), Atlanta, GA, USA, ACM Press (2008) 1227–1234
11. Pillay, N., Banzhaf, W.: A genetic programming approach to the generation of
hyper-heuristics for the uncapacitated examination timetabling problem. In: Proceedings of the EPIA Workshops. Volume 4874 of LNCS., Guimarães, Portugal,
Springer-Verlag (2007) 223–234
12. Miller, J.F., Thomson, P.: Cartesian genetic programming. In: Proceedings of the
3rd European Conference on Genetic Programming (EuroGP 2000). Volume 1802
of LNCS., Edinburgh, Springer-Verlag (2000) 121–132
13. Eshelman, L.J., Schaffer, J.D.: Real coded genetic algorithms and intervalschemata. In: Foundations of Genetic Algorithms 2. (1993) 187–202
14. Ono, I., Kobayashi, S.: A real-coded genetic algorithm for function optimization using unimodal normal distribution crossover. In: Proceedings of the 7thInternational Conference on Genetic Algorithms, East Lansing, MI, USA, Morgan
Kaufmann (1997) 246–253
15. Satoh, H., Yamamura, M., Kobayashi, S.: Minimal generation gap model for considering both exploration and exploitations. In: Proceedings of the IIZUKA’96.
(1996) 494–497
16. Deb, K., Anand, A., Joshi, D.: A computationally efficient evolutionary algorithm
for real-parameter optimization. Evolutionary Computation 10(4) (2002) 371–395
17. Kennedy, J., Eberhart, R.C.: Particle swarm optimization. In: Proceedings of theIEEE International Conference on Neural Networks. Volume IV., Perth, Australia(1995) 1942–1948
18. Eberhart, R.C., Shi, Y.: Comparing inertia weights and constriction factors inparticle swarm optimization. In: Proceedings of the 2000 Congress on Evolutionary
Computation (CEC 2000). Volume 1. (2000) 84–88