Chapter 5
Integer Programming Techniques
In the previous chapter we illustrated the use of two simple integer programming techniques
for the design of laminates subject to in-plane stiness requirements. One method, enumeration, has general applicability beyond in-plane stiness design, but for most problems it is
too computationally expensive. The second method, Miki's lamination parameter diagram,
can be generalized to a few other problems, but cannot handle many problems of interest. The objective of the present chapter is to describe methods which are more generally
applicable to the design of laminated composites.
Section 5.1 describes the formulation of linear integer programming problems. This class
of problems has been studied extensively by developers of optimization methods, and ecient algorithms which are guaranteed to nd the global optimum are available. Section 5.2
shows how in-plane stiness design problems, of the type discussed in the previous chapter, can be formulated as linear integer programming problems. Section 5.3 describes the
branch-and-bound algorithm, which is the most popular general algorithm for linear integer
programming.
For problems that cannot be formulated as linear integer programming problems, algorithms that deal with nonlinear integer programming problems must be used. Such algorithms have not reached the level of eciency and reliability achieved for linear problems.
Furthermore, the choice of algorithm is highly problem dependent. We chose to concentrate
on a single class of algorithms, genetic algorithms, with which we had extensive and good
experience in the design of composite laminates. Additionally, genetic algorithms are fairly
easy to implement and to tailor to the particular laminate design problem at hand. Section 5.4 provides an introduction to genetic algorithms and their application to composite
laminate design.
143
CHAPTER 5. INTEGER PROGRAMMING TECHNIQUES
5.1 Integer Linear Programming
An optimization problem is called a Linear Programming (LP) problem if the objective function and the constraint functions are linear functions of the design variables. The standard
form of an LP problem is
minimize
f (x) = cT x
such that
Ax = b
(5.1.1)
x 0
where c is an n 1 vector of constant coecients, A is an m n matrix of constraint
coecients, and b is an m 1 vector of constants. Note that the sign of the design variables
are restricted to be positive in the standard form. Some commercially available LP codes
are also restricted to handle positive valued design variables. If a variable is to have an
unrestricted sign, then the standard procedure is to replace it with the dierence of two
positive variables. For example, an unrestricted design variable xi is replaced by two new
variables, as
xi = x+i ; x;i
where both x+i and x;i are limited to be positive, but depending on relative magnitudes of
the two the outcome may yield a positive or a negative value for the variable xi . A disadvantage of the approach just described is the doubling of the number of design variables.
If the designer has a good idea of the lowest possible value of the variable that can assume
negative values, then more practical approach is to dene the new variable by adding a
positive constant C to the variable with an unrestricted sign,
xpos
i = xi + C
where C is greater than the absolute value of the lowest possible value of the unrestricted
variable.
More general LP problems allow design variables of unrestricted signs and general inequalities. However, frequently the values of the design variables are restricted not exceed
or drop below values that are dictated by either availability of the resources or physical
limitations. Such upper and lower bounds on the design variables are often treated dierently than constraints that involve more than one design variable. The bounds, therefore,
are often written separately. The general LP problem is
minimize
f (x) = cT x
such that
Ax b
(5.1.2)
x xU
x xL
144
5.2. IN-PLANE STIFFNESS DESIGN AS A LINEAR INTEGER PROGRAMMING PROBLEM
where xU and xL are the vectors of upper and lower bounds for the design variables. This
more general form of LP can be converted to the standard form by change of variables.
This standard form is then solved by a variety of solution techniques, most notably the
Simplex method. The reader is referred to, for example, Arora (1989) for more information
on solution of LP problems.
In the case of LP problems encountered in laminate design problems, some or all of the
variables of a LP problem are restricted to take only integer values. If all the variables are
so restricted, the problem is called an integer linear programming (ILP) problem or pure
ILP problem. If some of the design variables are allowed to be continuous, the problem is
referred to as mixed integer linear programming (MILP) problem, and its standard form is
minimize
f (x) = cT1 x + cT2 y
such that
A1x + A2 y = b
(5.1.3)
xi 0 integer
yj 0 :
It is also common to have problems where design variables are used to indicate a yes-orno type decision-making situation. Such problems are referred to as zero/one or binary ILP
problems. For example, as we will demonstrate later in Chapter 8, in a laminate stacking
sequence design the presence of a layer with a specied ber orientation (or its absence)
can be represented by a binary variable. Many programs for the solution of ILP programs
permit the user to specify that some of the variables are binary.
Most of the remaining discussion in this chapter assumes problems to be pure ILP.
5.2 In-plane Stiness Design as a Linear Integer Programming Problem
Linear Programming (LP) problems have been important in management, economics and
engineering for many years. As a result, ecient software for solving LP problems is readily available and, therefore, there is a substantial incentive to formulate laminate design
problems as LP problems. A quick review of the in-plane stiness problem reveals that
certain in-plane laminate properties are indeed linear functions of the design variables. For
example, from Table 2.1 and Eq. (2.4.31) we see that the elements of the in-plane stiness
matrix A,
A11 = h(U1 + U2 V1 + U3 V3 )
A12 = h(U4 ; U3 V3 )
A22 = h(U1 ; U2 V1 + U3 V3 )
A66 = h(U5 ; U3 V3 )
(5.2.1)
145
CHAPTER 5. INTEGER PROGRAMMING TECHNIQUES
are all linear functions of the in-plane lamination parameters V1 and V3 . Furthermore, it
is demonstrated in the following that for laminates with prescribed ber orientations, it is
possible to express the in-plane lamination parameters as linear functions of the number of
layers of a given orientation.
Restricting ourselves to balanced symmetric laminates, we rewrite Eq. (4.2.4) by expanding the summation over each layer in one half of the laminate
V1 = 2(v1 cos 21 + v2 cos 22 + v3 cos 23 + : : : + vN=2 cos 2N=2 )
V3 = 2(v1 cos 41 + v2 cos 42 + v3 cos 43 + : : : + vN=2 cos 4N=2 ) : (5.2.2)
In this representation, the volume fractions of individual layers vi , i = 1 : : : N=2, are equal
to the ratio of the thickness of a layer, t, to total laminate thickness, h. Therefore, in the
common case when all layers have the same thickness t,
V = 2t (cos 2 + cos 2 + cos 2 + : : : + cos 2 )
1
2
3
N=2
h
V3 = 2ht (cos 41 + cos 42 + cos 43 + : : : + cos 4N=2 ) :
1
(5.2.3)
If several of the individual layers are made up of the same orientation angles, say np layers
with p, and nq layers with q , then Eqs. (5.2.3) take the following form
V = 2t (n cos 2 + n cos 2 )
p
q
q
h p
V3 = 2ht (np cos 4p + nq cos 4q ) :
1
(5.2.4)
For a constant thickness laminate with specied values of the ber orientations p and q ,
the cosine terms are constants and, therefore, the in-plane stiness parameters are linear
functions of the number of layers np and nq . Hence, the elements of the in-plane stiness
matrix A are also linear functions of the number of layers. When the laminate thickness is
not constant, the lamination parameters are not linear functions of the number of layers,
but the in-plane stiness coecients are still linear, because the h in the denominators in
Eqs. (5.2.4) cancels the h in Eqs. (5.2.1)
For example, consider a balanced symmetric laminate which contains only 0 , 45 ,
and 90 layers. The in-plane lamination parameters are given by
(5.2.5)
V = 2t (n ; n ) and V = 2t (n ; 2n + n )
1
h
o
n
3
h
o
f
n
where no is the number of 0 layers, nn is the number of 90 layers, and nf is the number
of 450 layer groups in half of the laminate. The thickness of the laminate may be written
as
h = 2t(no + 2nf + nn) :
(5.2.6)
146
5.2. IN-PLANE STIFFNESS DESIGN AS A LINEAR INTEGER PROGRAMMING PROBLEM
Substituting this expression into Eq. (5.2.5) we see that the in-plane stiness parameters
V1 and V3 are no longer linear in the numbers of layers of distinct orientation angles.
However, the coecients of the stiness matrix are still linear functions of the number of
layers. Substituting the in-plane stiness parameters into Eqs. (5.2.1) yields the following
expressions for stiness coecients
A11 = 2 t (no + 2nf + nn) U1 + (U2 + U3 ) no ; 2U3 nf + (U3 ; U2 )nn]
A22 = 2 t (no + 2nf + nn ) U1 + (U3 ; U2 ) no ; 2U3 nf + (U3 + U2 )nn]
A12 = 2 t (no + 2nf + nn) U4 ; U3 (no ; 2nf + nn )]
(5.2.7)
A66 = 2 t (no + 2nf + nn) U5 ; U3 (no ; 2nf + nn)] :
The weight of the laminate is proportional to the total laminate thickness h which we
have seen is a linear function of the number of layers. Thus, we can formulate as LP any
in-plane design problem which involves the weight and linear expressions in the elements
of the A matrix.
The eective engineering elastic constants are not linear functions of the numbers of
layers, but two of them, the laminate shear stiness Gxy and the Poisson's ratio xy , can
be used to formulate linear constraints. For example if we require that the laminate has a
d , using Eqs. (2.4.38) and (5.2.7) we can
Poisson's ratio larger than a certain value xy xy
impose the following linear constraint
d (n + 2n + n )U + (U ; U )n
(no + 2nf + nn)U4 ; U3 (no ; 2nf + nn)
xy
o
n 1
3
2 o
f
;2U3 nf + (U3 + U2)nn] :
(5.2.8)
This equation may be rearranged in the standard form of an inequality constraint as
;U4 ; U3 ; xyd (U1 + U3 ; U2 )]no ; 2U4 + 2U3 ; xyd (2U1 ; 2U3 )]nf
; U4 ; U3 ; xyd (U1 + U3 + U2 )] 0 : (5.2.9)
Most in-plane laminate design problems can be usually classied as weight minimization
or stiness maximization. In the weight minimization problem, we minimize the weight
of the laminate, which is equivalent to minimizing the thickness when the laminate is
made from a single material. Constraints are placed on the stinesses and occasionally
on the maximum or minimum percentages of layers of given orientation. In the stiness
maximization problem, the objective function is one of the stiness properties, while the
weight, or the thickness, or the total number of layers are specied. Additional stiness
and layer percentage constraints may also be present. The following example demonstrates
a stiness maximization problem. The weight minimization problem is left as an exercise
(see Exercise 1).
147
CHAPTER 5. INTEGER PROGRAMMING TECHNIQUES
Example 5.2.1
For a 16 layer balanced symmetric laminate, formulate the problem of determining the number
of 0 , 45 , and 90 layers to maximize the stiness coecient A11 while keeping the shear
stiness Gxy of the laminate larger than 12 GPa, and A22 larger than 20 MN/m. The properties
of individual layers are E1 = 76 GPa, E2 = 5:5 GPa, G12 = 2:3 GPa, 12 = 0:34, and
t = 0:125 10;3m.
Using the material properties specied, we calculate the Ui 's to be
U1 = 32:44 GPa U2 = 35:55 GPa U3 = 8:652 GPa
U4 = 10:54 GPa and U5 = 10:95 GPa :
For this problem the laminate has constant thickness of
2 t (no + 2 nf + nn ) = h = 2 10;3m and so from Eq. (5.2.7) the coecients of the stiness matrix A are
A11 = 64:88 + 11:05no ; 4:326nf ; 6:724nn A22 = 64:88 ; 6:724no ; 4:326nf + 11:05nn A66 = 21:90 ; 2:163no + 4:326nf ; 2:163nn all in MN=m. Therefore, the shear stiness is
Gxy = 10:95 ; 1:082no + 2:163nf ; 1:082nn GPa :
The optimization problem is then formulated as
maximize
subject to
f (no nf nn ) = 11:05 no ; 4:326 nf ; 6:724 nn
6:724 no + 4:326 nf ; 11:05 nn 44:88 ;1:082 no + 2:163 nf ; 1:082 nn 1:050 no + 2 nf + nn = 8 (a)
no nn 2 0 1 2 : : : 8 nf 2 0 1 2 3 4 :
Note that the constant term in the A11 is ignored for the objective function because most
linear programming programs do not allow constants in their input. Adding a constant to the
objective function or multiplying it with a positive constant does not change the optimal values
of the design variables. However, these operations change the value of the objective function at
the optimum, and that change must be reversed in order to obtain the optimum of the original
problem. Also note that the constraint equation Eq. (a) is added to the problem to insure that
the total number of layers in the laminate adds up to sixteen. Based on this equation, the
148
5.3. SOLUTION OF INTEGER LINEAR PROGRAMMING PROBLEMS
design variable no and nn can take any integer value between 1 and 8, but the largest integer
number nf can assume is 4, which correspond to all 45 laminate.
The solution of the problem is no = 2, nf = 3, nn = 0 which corresponds to a 02= 453]s
laminate. 5.3 Solution of Integer Linear Programming Problems
A common approach to solving MILP problems is to round-o the optimum values of the
variables, obtained by assuming them to be continuous, to the nearest acceptable integer
value. For problems with n integer design variables there are 2n possible rounded-o designs,
and the problem of choosing the best one is formidable for large n. For example, for a
problem with 10 design variables there are 1,024 possibilities. Increasing the number of
design variables to 20 would increase the number of possibilities to more than 1,000,000.
Furthermore, for some problems the optimum design may not even be one of these roundedo designs, while for others, none of the rounded-o designs may be feasible. Thus, instead
of using continuous optimization method followed by rounding, it may be more reasonable
to use methods specically developed for MILP problems.
5.3.1 Enumeration
For problems with a small number of design variables, enumeration of all possible solutions
is a reasonable alternative to rounding. For many laminate design problems, the cost of an
analysis is low enough so that enumeration is a reasonable procedure, even if the number
of possible designs is in the thousands.
Example 5.3.1
Solve Example (5.2.1) by enumerating all possible 16-ply laminates. The possible laminates
are 0no= 45nf =90nn]s , with the condition of having exactly 16 layers given as
no + 2 nf + nn = 8 :
It is convenient to enumerate on the basis of the number nf of 45 pairs, as we can have only
5 possible values (0,1,2,3,4). Then for each value of nf , we can vary no from zero to 8 ; 2nf ,
and use what is left for nn . The results are summarized in Table 5.1.
Only four of the laminates satisfy the constraints that A22 be at least 20 MN/m and that
Gxy be at least 12 GPa, and these are marked by the letter 'F' (for feasible design). Among
these the 453=02]s design, has the highest A11 . 149
CHAPTER 5. INTEGER PROGRAMMING TECHNIQUES
Table 5.1: Enumeration of all possible 16 balanced symmetric laminates
laminate
A11 (MN=m) A22 (MN=m) Gxy (GPa)
908]s
0=907]s
02 =906]s
03 =905]s
04 =904]s
05 =903]s
06 =902]s
07 =90]s
08 ]s
45=906]s
45=0=905]s
45=02=904]s
45=03=903]s
45=04=902]s
45=05=90]s
45=06]s
452=904]s
452=0=903]s
452=02=902]s
452=03=90]s
452=04]s
453=902]s
453=0=90]s
453=02]s
454]s
150
11.09
28.86
46.64
64.41
82.18
99.96
117.73
135.51
153.28
20.21
37.98
55.76
73.53
91.31
109.08
126.85
29.33
47.11
64.88
82.65
100.43
38.45
56.23
74.00
47.58
153.28
135.51
117.73
99.96
82.18
64.41
46.64
28.86
11.09
126.85
109.08
91.31
73.53
55.76
37.98
20.21
100.43
82.65
64.88
47.11
29.33
74.00
56.23
38.45
47.58
2.29
2.29
2.29
2.29
2.29
2.29
2.29
2.29
2.29
6.62
6.62
6.62
6.62
6.62
6.62
6.62
10.95
10.95
10.95
10.95
10.95
15.27
15.27
15.28
19.60
F
F
F
F
5.3. SOLUTION OF INTEGER LINEAR PROGRAMMING PROBLEMS
As can be seen from this example, we have used the condition that the total number
of layers is 16 to reduce the number of combinations of no , nf and nn that we needed to
check. A systematic way of taking advantage of constraints to reduce the number of cases
that need to be inspected by enumeration is called an enumeration tree. An example from
Garnkel and Nemhauser (1972) demonstrates the use of a constraint in an enumeration
tree. The example also introduces some of the terminology that will be useful for the most
important algorithm for ILP discussed later in this chapter text, the Branch-and-Bound
technique.
Example 5.3.2
Consider the binary ILP problem of choosing a combination of ve variables such that the
following summation is satised
h=
5
X
i=1
ixi = 5 :
A decision tree representing the progression of solution of this problem is composed of nodes
and branches that represent the solutions and the combinations of variables that lead to those
solutions, respectively (Figure 5.1). The top node of the tree corresponds to a solution for which
all the variables are turned o (xi = 0 i = 1 : : : 5) with a function value of h = 0. Branching
from this solution are two paths corresponding to the two alternatives for the rst variable. The
branch with x1 = 1 has h = 1 and tolerates turning additional variables on without running
the risk of exceeding the required function value of 5. The other branch is same as the initial
solution, and can be branched further. Next, these two nodes are branched by considering the
on and o alternatives for the second variable. The node arrived by taking x1 = x2 = 1 has
h = 3 and is terminated because further branching would mean adding a number that would
cause h to exceed its required value of 5. Such a vertex is said to be fathomed, and is indicated
by a vertical line. The other three vertices are said to be live, and can be branched further by
considering the alternatives for the remaining variables in a sequential manner until either the
created nodes are fathomed or the branches arrive at feasible solutions to the problem.
For the present example, after considering 19 possible combinations of variables, we identied 3 feasible solutions which are marked by an asterisk. This is a 40% reduction in the
total number of possible trials, namely 25 = 32, needed to identify all possible solutions. For a
laminate design problem in which trials with dierent combinations of variables could require
lengthy analyses an enumeration tree can yield substantial savings. 5.3.2 Branch-and-Bound Algorithm
The concept behind the enumeration technique forms the basis for this powerful algorithm
suitable for MILP problems. The original algorithm, developed by Land and Doig (1960),
151
CHAPTER 5. INTEGER PROGRAMMING TECHNIQUES
*
x 2=
h=1
=1
1
x2 = 0
h=3
h=1
x 3=
1
x3 = 0
h=4
h=5
x 4=
h=1
x1
1
x4 = 0
h=1
*
x3
h=0
x2
x1 = 0
=
1
h=2
h=0
=1
x3 = 0
h=2
1
h=3
x3=
x2 = 0
h=5
h=4
x4 = 0
h=0
x4
h=0
x3 = 0
=1
h=0
x 5=
1
x5 = 0
h=5
*
h=0
P
Figure 5.1: Enumeration tree for binary ILP problem with constraint h = 5i=1 ixi = 5.
relies on calculating upper and lower bounds on the objective function, so that nodes that
result in designs with objective functions outside the bounds can be fathomed, and thereby,
the number of analyses required can be reduced. Consider a hypothetical example of a
MILP problem of the type of Eq. (5.1.3). The rst step of the algorithm is to solve the
LP problem obtained from the MILP problem by assuming the variables to be continuous
valued. If all the x variables for the resulting solution have integer values, there is no need to
continue the problem is solved. Suppose several of the variables assume non-integer values
and the objective function value is f1 . The f1 value will form a lower bound fL = f1 for the
MILP, since imposing conditions that require non-integer valued variables to take integer
values can only cause the objective function to increase. This initial problem is labeled as
LP-1 and is placed in the top node of the enumeration tree as shown in Figure (5.2). For
the purpose of illustration, it is assumed that only two variables xk and xk+1 violate the
integer requirement with xk = x1k = 4:3 and xk+1 = x1k+1 = 2:8.
The second step of the algorithm is to branch from the node into two new LP problems
by adding a new constraint to the LP-1 that involves only one of the non-integer variables,
say xk . One of the problems, LP-2, will require the value of the branched variable, xk to
be less than or equal to the largest integer smaller than x1k , and the other, LP-3, will have
a constraint that xk is larger than the smallest integer larger than x1k . These two problems
152
5.3. SOLUTION OF INTEGER LINEAR PROGRAMMING PROBLEMS
LP - 2
f2
_> 4
xk = 4
xk+1 = 3.5
xk
LP - 1
fL = f1
xk = 4.3
xk+1 = 2.8
x
k
>_ 5
xk = 5
xk+1 = 2
xk+1 >_ 3
x
k+
1
LP - 4
f4 > fU
>_ 4
LP - 5
f5 < fU
LP - 3
fU = f3
Figure 5.2: Illustration of branch-and-bound decision tree for MILP problems.
actually do branch the feasible design space of the LP-1 into two segments. There are
several possibilities for the solutions of these two new problems. One of these possibilities is
to have no feasible solution for the new problem. In that case the new node will be fathomed.
Another possibility is to reach an all integer feasible solution (see LP-3 of Figure 5.2). In this
case the node will again be fathomed, but the value of the objective function will provide
an upper bound for the optimum solution because it is feasible.
We denote that upper bound as fU and update it when we nd other integer solutions
with lower values than the current fU . Once an upper bound has been established, any node
that has an LP solution with a larger value of the objective function will be fathomed, and
only those solutions that have the potential of producing an objective function between
fL and fU will be pursued. If there are no solutions with an objective function smaller
than fU , then the node with fU is an optimum solution. If there are other solutions with
an objective function smaller than fU , they may still include non-integer valued variables
(LP-2 of Figure 5.2), and are labeled as live nodes. Live nodes are then branched again by
considering one of the remaining non-integer values and resulting solutions are analyzed
until all the nodes are fathomed.
The performance of the branch-and-bound algorithm depends heavily on the choice of
non-integer variable to be used for branching, and the selection of the node to be branched.
If a selected node and branching variable leads to an upper bound close to the objective
function of the LP-1 early in the enumeration scheme, then substantial computational savings can be obtained because of the elimination of branches that cannot generate solutions
lower than the upper bound. A rule of thumb for choosing the non-integer variable to be
153
CHAPTER 5. INTEGER PROGRAMMING TECHNIQUES
no = 3.51
n = 2.24 A11 = 94.00
LP - 1 nf = 0
n
no ≥ 4
no ≤ 3
LP - 2
no solution
LP - 3
nf ≥ 3
no = 2
n
LP - 4 f = 3
A11 = 74.00
no = 3
nf = 2.5
A11 = 87.25
nf ≤ 2
LP - 5
no solution
Figure 5.3: Branch and Bound decision tree for laminate design problem
branched is to take the variable with the largest fraction. For the selection of the node to
be branched, we choose, among all the live nodes, the LP problem which has the smallest
value of the objective function that node is most likely to generate a feasible design with
a tighter upper bound.
Example 5.3.3
Solve Example (5.2.1) by the branch-and-bound method, using software for solving continuous
linear programming problems.
The decision tree for this problem is shown in Figure 5.3. The rst node shows the solution
with non-integer number of layers 03:51= 452:24]s , with A11 = 94 GPa. With no having the
larger fraction, we branch on no . The branch with the additional constraint of no 4 does
not have a solution because the constraint on Gxy cannot be satised. The branch with an
additional constraint of no 3 yields the solution 03 = 452:5]s with A11 = 87:25 GPa. Now
that no and nn are integers, we can branch only on nf . As shown in the Figure, the branch with
nf 2 does not have a solution because again we cannot satisfy the constraint on Gxy , and
the branch with nf 3 yields 02 = 453]s with A11 = 74:0 GPa. This is an integer solution,
and since we do not have any more live nodes it is the optimum solution.
154
5.4. GENETIC ALGORITHMS
Branch-and-bound is only one of the algorithms for the solution of ILP or MILP problems. However, because of its simplicity it is incorporated into many commercially available
computer programs (see, for example, Johnson and Powell (1978), and Schrage (1989)).
There are a number of other techniques which are capable of handling general discretevalued problems (see, for example, Kovacs (1980)). Some of these algorithms are good not
only for ILP problems but also for NLP problems with integer variables.
Linear problems have a big advantage over nonlinear ones in that we can count on getting the global optimum for the problem. Algorithms for nonlinear problems, on the other
hand, typically provide only a local optimum. A methodical way of dealing with multiple
minima for discrete optimization problems is to use random search techniques that sample
the design space for a global minimum without the use of derivatives. However, the eciency of traditional random search techniques is poor for problems that have large number
of variables. Two algorithms, simulated annealing (Laarhoven, 1987) and genetic algorithms
(Goldberg, 1989), have emerged more recently as tools ideally suited for optimization problems where a global minimum is sought. In addition to being able to locate near-global
solutions, these two algorithms are also powerful tools for problems with discrete-valued
design variables. Both algorithms mimic naturally observed phenomena and their implementation calls for the use of a random selection process which is guided by probabilistic
decisions. The next section describes genetic algorithms, in particular some which have
recently been applied to the design of composite laminates.
5.4 Genetic Algorithms
Genetic algorithms use techniques derived from biology, and rely on the application of
Darwin's principle of survival of the ttest. When a population of biological creatures is
allowed to evolve over generations, individual characteristics that are useful for survival tend
to be passed on to future generations, because individuals carrying them get more chances to
breed. In biological populations these characteristics are stored in chromosomal strings. The
mechanics of natural genetics is based on operations that result in structured yet randomized
exchange of genetic information (hence biological traits) between the chromosomal strings
of the reproducing parents, and consists of reproduction, crossover, occasional mutation,
and inversion of the chromosomal strings.
Genetic algorithms, developed by Holland (1975), mimic the mechanics of natural genetics for articial systems based on operations which are the counterparts of the natural ones
(even called by the same names). As will be described in the following paragraphs, these operations involve simple, easy to program, random exchanges of location of numbers in strings
that represent the design variables. These operations may appear like a completely random
155
CHAPTER 5. INTEGER PROGRAMMING TECHNIQUES
search of extremum in parameter space based on function values only. However, genetic
algorithms are experimentally proven to be robust, and the reader is referred to Goldberg
(1989) for discussion of their theoretical properties. Here we discuss the genetic representation of a minimization problem, and focus on the mechanics of three commonly used
genetic operations (namely reproduction, crossover, and mutation) and a fourth operator,
permutation (or sometimes called gene swap), recently proposed for buckling optimization
of composite plates.
Unlike many search algorithms that move from one point to another in the design variable space, genetic algorithms work with a population of strings. This aspect of the genetic
algorithms is responsible for increased chance for obtaining global or near-global optima.
By keeping many solution points that may have the potential of being close to minima
(local or global) in the pool during the search process, rather than converging on a single
point early in the process, we reduce the risk of converging to a local minimum. Working
on a population of designs also suggests the possibility of implementation on parallel computers. However, the concept of parallelism is even more basic to genetic algorithms in that
evolutionary selection can improve in parallel many dierent characteristics of the design.
Also, since the outcome of the search is random, repeated genetic optimization will often
yield dierent good designs. This aspect can be very useful to the designer when the design
space includes many local optima of comparable performance.
Genetic algorithms have been applied to optimal structural design only recently. The
rst application of the algorithm to a structural design was presented by Goldberg and
Samtani (1986) who solved a well known 10-bar truss weight minimization problem. More
recently, Hajela (1990) used genetic search for several structural design problems for which
the design space is known to be either nonconvex or disjoint. Rao et al. (1991) addressed the
optimal selection of discrete actuator locations in actively controlled structures via genetic
algorithms. Applications of the algorithm to design with composite materials are recent (see
Callahan and Weeks, 1992, Le Riche and Haftka 1993, Hajela and Erisman 1993, Nagendra
et al.1993, and Kogiso et al.,1994).
5.4.1 Design Coding
Application of the operators of the genetic algorithm to a search problem rst requires the
representation of the possible combinations of the variables in terms of bit strings that are
counterparts of the chromosomes of the biological genetics. For historical reasons, binary
numbers were predominantly used for representing design information as bit strings. For
integer design variables this is quite simple. For example, consider the minimization problem
minimize
156
f (x)
x = fx1 x2 x3 x4 g
(5.4.1)
5.4. GENETIC ALGORITHMS
where the variables are integer and can assume values in the range f15 x1 x4 0g,
f7 x2 0g, and f3 x3 0g. The length of the bit string used to represent each
variable, in this case, is dictated by the range of the variables. For example, the design
variable vector can be a binary string represented as
1 1 1| 0{z1 1}
0| 1{z1 0} 1| {z0 1} |{z}
x1
x2
x3
x4
(5.4.2)
where binary representations of the individual variables are strung head-to-tail, and, in this
example, the variables are x1 = 6 x2 = 5 x3 = 3 x4 = 11. For problems where the design
variables are continuous within a range xLi xi xUi , the common practice is to divide
the intervals to a nite number of subintervals so as to discretize the design variables. The
size of the subintervals, which determines the precision of the solution obtained by the
genetic algorithm, denes the number of bits needed. If a variable is dened in a range
fxLi xi xUi g and the precision needed for the nal value is xincr, then the number m of
binary digits needed for an appropriate representation can be calculated from
2m
(xUi ; xLi )=xincr + 1 :
(5.4.3)
For example, if f0:01 xi 1:81g and the required precision is 0:001, the smallest number
of digits is m = 11, which actually produces increments of 0:00087 in the value of the
variable, instead of the required value of 0:001.
The conversion of variables to binary numbers introduces a degree of complexity that is
not always necessary. Binary variables have the advantage of corresponding to the smallest
possible alphabet, which has some theoretical advantages. For example, with a very large
alphabet, it is more dicult to ensure that every possible gene is present in the initial population. However, studies comparing binary to other representations tend to nd superior
performance by non-binary representations (e.g., Michalewicz, 1992, Furuya and Haftka,
1993). In many problems we can use the actual values of the design variables in the string,
as long as we take precautions with the crossover and mutation operators as will be described later. The use of real variables in strings has enjoyed more popularity in Europe
than in the United States (see, for example, Back and Schwefel, 1993). The European school
often uses the term Evolutionary Strategies to describe methods, such as genetic algorithms,
based on mimicking evolution. Variants of genetic algorithms that employ real numbers and
are applied to function optimization have been dubbed as Evolutionary Algorithms by the
European school.
For designing the stacking sequence of a laminate we typically employ a code assigning
an integer digit to each possible orientation angle. For example, the stacking sequence of
a laminate that can only admit 0 , 45 , ;45 and 90 layers with xed thickness t can
157
CHAPTER 5. INTEGER PROGRAMMING TECHNIQUES
be represented by a string containing the digits 1, 2, 3, and 4, respectively. The 16-ply
laminate 45=04 =902 ]s is then represented by the genetic code 2 3 1 1 1 1 4 4 4 4 1 1 1 1
3 2]. If we make use of the symmetry condition (that is, limit ourselves to only symmetric
laminates) we can simply represent the same laminate by 2 3 1 1 1 1 4 4]. This reduction in
the length of the string can signicantly improve the speed of the genetic search. There are
416 = 4:3 109 16-digit strings that correspond to distinct designs, but only 48 = 65 536
strings of 8 digits.
For most applications laminates are further assumed to be balanced, requiring a ;45
layer for every 45 layer. The pair of o-axis angles are normally placed adjacent to one
another in order to keep the values of the D16 and D26 terms small. This allows us to
reduce further the length of the string for balanced symmetric laminates. We dene stack
variables which represent two adjacent layers with the same orientation. For a laminate
made of only 02 , 452 , and 902 layers we use the 1 2 and 3 representation. Therefore, the
45=04 =902 ]s laminate is represented by 2 1 1 3]. This reduction in the length of the string,
however, does not permit us to represent laminates containing stacks with odd number of
0 or 90 layers. It is also possible to use natural coding, where the gene looks like the
stacking sequence. For example, the stacking sequence 45=04 =902 ]s may be represented
as 45 0 0 90]. This natural representation reduces the eort of coding and decoding, but it
requires more specialized programming tailored to the specic set of orientations used.
For in-plane laminate-design problems, the stacking sequence is often unimportant, and
we need only the number of layers in each given orientation. Then we can represent the
symmetric and balanced laminate (L )NL =(L;1 )NL;1 = : : : =(1 )N1 ]s as a string with
the L integers Ni , i = 1 : : : L, or with a longer string containing the binary representation
of these integers. For example, in-plane design of a 48-ply balanced and symmetric laminate
with 30 , 45 , and 60 stacks can be represented by a string N1 N2 N3 ]. The integers
N1, N2 and N3 , represent the number of stacks of 30 , 45 , and 60 layers, respectively,
and can vary between 0 and 12. Of course, we will need a constraint requiring that N1 + N2 +
N3 = 12. Instead we can have a string composed only of N1 N2 ], with N3 = 12 ; N1 ; N2,
with a constraint that N3 0. This second representation is much more ecient. The design
space associated with N1 N2 N3 ] has 133 = 2197 possible designs, while the design space
associated with N1 N2 ] has only 169 possible designs. It is easy to check that, because of
the constraint on N3 , there are only 91 possible designs. So with the rst representation
we have a much larger design space, and additionally the great majority of the designs
generated by the genetic algorithm on the way to the optimum will violate the constraint
N1 + N2 + N3 = 12, resulting in slower progress towards the optimum. With the second
representation, we have a smaller design space, and more than half of the designs generated
by the genetic algorithm will be possible designs (that is, satisfy the constraint N3 0).
158
5.4. GENETIC ALGORITHMS
Genetic algorithms generally work with a population of strings that are all of the same
length. This can present a problem when the number of layers in the laminate is unknown,
as in the case of thickness minimization, and we use a coding with one number for each
layer or each two-layer stack. We can solve this problem by making the length of our
strings correspond to an upper limit on the thickness of the laminate and adding another
digit to represent an absent layer or stack. For example, assume that we found that all
the constraints can be satised with a 12-ply laminate, but we seek thinner laminates that
satisfy these constraints. Limiting ourselves to symmetric laminates, this means that we can
use 6 digit strings to code the laminate. We will then represent the laminate 05 ]s by 0 1 1 1
1 1], with the zero in the leftmost position corresponding to the absent layer. Similarly, we
will represent 0=90=45= ; 45]s by 0 0 1 4 2 3]. As will be seen later, with this approach we
need to take precautions of not having 0s appear anywhere except for the leftmost positions
in the string.
5.4.2 Initial Population
Most genetic algorithms work with a xed size population, so that the size of the initial
population of designs determines the size of the population in all future generations as well.
We will denote that size by ns , for the number of strings. Choosing the population size is
at the present a matter of trial and error. In general, the optimal size of the population
increases with problem size. That is, the design of a thin laminate that can be represented
by a short string will require a smaller population size than the design of a thicker laminate
that must be represented by a longer string. Similarly, the design of a structure composed
of several laminates will require an even larger population size. For example, for the design
of 48-ply balanced symmetric laminates (12-digit string) subject to buckling and strength
constraints, Le Riche and Haftka (1993) found that the optimum population size was 8. For
the design of a simple wing made up of 18 dierent laminates, the best population size was
about 50 (Le Riche, 1994).
The initial population is typically generated at random. Subroutines or functions that
generate random numbers distributed uniformly between 0 and 1 are widely available, and
we use them extensively in genetic algorithms. Such random number generators typically
require an input `seed' the rst time they are called. The seed determines the sequence of
random number that will be generated by repeatedly calling the function or subroutine.
Thus the numbers are not truly random, and are often called pseudo random numbers.
However, for the use in genetic algorithms the distinction is not important. In the following
we will assume that random numbers are generated by a function RAND(ISEED) and we
will denote by r the output of the function.
For example, consider the case of the stacking sequence design of a laminate made of 0 ,
159
CHAPTER 5. INTEGER PROGRAMMING TECHNIQUES
subroutine init(lamin,L,ns,nmax)
integer lamin(L,ns)
do 100 i=1,ns
do 100 j=1,L
lamin(j,i)=(nmax+1)*rand(iseed)
100 continue
return
end
Figure 5.4: Fortran subroutine for generating initial population of ns strings of length L,
with each digit being an integer between 0 and nmax.
45 , ;45 and 90 layers, so that each digit in the string can take integer values in the range
(0,4), with zero corresponding to an absent layer. Using RAND, we rst generate a random
number r between 0 and 1.0, and then transform it to a choice of an integer between zero
and four by taking the value b5rc, where bxc indicate the integer part of a real number
x (oor function). We can then repeat this process for each layer to generate the entire
laminate. Then we repeat it again to generate the requisite ns laminates (see Figure 5.4).
Subroutine init of Figure 5.4 will produce zeroes or `voids' inside the laminate, and these
voids will have to be pushed out, for example
1 0 4 2 0 3 ) 0 0 1 4 2 3 ) 0=90=45= ; 45]s :
(5.4.4)
We can use information on the design to bias the initial population makeup. One case
where we need such bias is when we encounter a singular optimum associated with 0 layers.
A singular optimum is an isolated optimum which represents a discontinuity in design space.
We can get a singular optimum in the design of composite laminates when the objective
function favors designs with 45 or 90 layers, but the loading is primarily in the 0
direction. This phenomenon was reported by Schmit and Farshi, 1973, for continuous layerthickness design variables. However, a similar problem with a singular optimum occurs with
discrete thickness designs, as explained below.
Consider, for example, a 48-ply laminate under uniaxial tension, where we want to
maximize Gxy subject to constraints on strains in the layers. The optimum design will
usually be an all 45 laminate. If we start with a design with a small number of 0 layers,
such as (458 =04 )s , the strains in the zero bers will be higher than the strains in the 45
or the ;45 bers (see Exercise 2 at the end of this chapter). If the load is high enough, the
laminate will rst fail due to breakage of the 0 bers. If we reduce the number of 0 layers
160
5.4. GENETIC ALGORITHMS
by two to (459 =02 )s , the situation will worsen as the strains in the 0 layers will increase.
However, if we eliminate the last 0 layer and get an all 45 laminate, the strains in the
zero direction will not matter because we will not have any bers in this direction. The all
45 optimum is called singular because it cannot be obtained by gradual reduction of the
0 layers.
When continuous optimization techniques are used, this diculty has to be countered
by considering designs that have 0 layers and also designs that do not have 0 layers.
With genetic algorithms we have to use a similar strategy, seeding the initial population
with some designs without any 0 layers. Kogiso et al. (1994) have shown that such seeding
helps in getting optimal no-zero-layer designs, and does not appear to have adverse eects
even when the optimum is not singular.
Once an initial population is generated we apply a series of genetic operators that
produce a new generation and replace the initial population with the new one. The rst of
these operations is selection.
5.4.3 Selection and Fitness
The selection process in genetic algorithms mimics biology in giving more t designs a higher
chance to breed and pass their genes to future generations. Genetic algorithms therefore
need to dene tness and use it in a procedure that selects pairs of parent designs that
will be used to create child designs for future generations. For unconstrained problems, the
tness of a design can be dened as the objective function (for maximization problems)
or a constant minus the objective (for minimization problems). For constrained problems
the tness also must consider constraint violations or constraint margins. Several methods
exist for handling constraints, and this is a hotly debated topic (e.g., Le Riche et al., 1995).
The following is one simple way for handling constraints.
Consider the standard formulation of an optimization problem, Eq. (1.4.1), where for
simplicity we omit the equality constraints
minimize
such that
f (x)
gj (x) 0
x2X
j = 1 : : : ng :
We assume that the constraints are normalized so that a constraint value of -0.1 corresponds
to a 10 percent margin, while a constraint value of 0.1 corresponds to a 10 percent deciency.
The design margin of safety is then dened by the most critical constraint gmax = maxj (gj ).
If gmax is positive the design is infeasible, and we want to add a penalty to the objective
161
CHAPTER 5. INTEGER PROGRAMMING TECHNIQUES
function to help the search move into the feasible design. If gmax is negative we have a feasible
design with a positive margin of safety, and we want to reduce the objective function as a
bonus for that margin. We can dene an augmented objective function f f =
(
f + p gmax + if gmax > 0 ,
f ; jgmax j
otherwise:
(5.4.5)
In Eq. (5.4.5) there are two parameters, and p that penalize infeasible design. The
rst, should be chosen as a small infeasibility penalty which applies even for very small
constraint violations. It should typically be a very small percentage of the average value of
the objective function. The second parameter p penalizes substantial constraint violations.
The penalty parameter p needs to be chosen large enough so that all infeasible designs
have a higher value of f than the optimum design. However, we do not want to use a very
large penalty parameter because the design process often benets from shortcuts taken via
infeasible design. For example, consider a situation where we require the laminate to be
balanced, but we have a coding that permits unbalanced designs. Now suppose we have
a design that needs to replace a pair of 0=90] layers with a stack of 45] layers. We
can have intermediate designs where only one layer is replaced. For example, a 0 layer
is replaced by a 45 layer, resulting in an unbalanced laminate. If we penalize constraint
violation too heavily, the unbalanced laminate will have such low tness value that it will
have very little chance of being selected for reproduction. So to achieve a transition from
the pair of 0=90] layers to the 45] stack, we must have two changes in the genetic string
occur simultaneously. Such double change has very little probability of happening with the
standard genetic operators described below, and having to rely on a double change will slow
down convergence. This example illustrates a case where the easiest transition between two
feasible designs proceeds through an intermediate infeasible design. This situation is not
unique to balance constraints, but is quite common. Therefore, large values for penalty
parameters are often found to slow down the convergence of the genetic algorithm.
Occasionally, we have designs which are only slightly infeasible, but which have very
good objective functions. Without the rst penalty parameter, we would have to use very
large values of p to ensure that these designs did not have the best augmented objective,
because the value of gmax for these designs is very small. This situation is the reason for
using two penalty parameters instead of one.
The bonus parameter is needed when the optimum design is not unique, so that we
want to nd the optimum design with the highest safety margin. When we design laminates
for minimum thickness we often encounter such non-uniqueness because the thickness can
be only a multiple of the basic layer thickness. Thus, we often can obtain several laminates,
all having the same thickness, but with dierent constraint margins. The bonus parameter
162
5.4. GENETIC ALGORITHMS
ensures that the selection process favors the design with the highest margin of safety.
However, the bonus parameter needs to be small enough so that no design has a lower f than the optimum design, no matter how large the constraint margin is.
Genetic algorithms traditionally use the concept of tness, which is higher for the better
individuals, rather than the concept of an objective function which could be maximized or
minimized. To accommodate the minimization problem, we can dene the tness, , from
f as
= c ; f
(5.4.6)
where c is a constant chosen large enough so that is always positive, but not so large, so as
to almost obliterate the relative dierences between dierent designs. When large changes
in the magnitude of f occur during the optimization, it may be desirable to periodically
update c as well, so that these conditions will be met.
Example 5.4.1
Consider the following optimization problem,
maximize
f (x)
such that
g1 (x) 0 and g2 (x) 0 A population of four designs calculated to have the following objective function and constraint
function values,
design-1:
f 1 = 6:69 g11 = ;0:11 g21 = ;0:50
design-2:
f 2 = 7:30 g12 = 0:28 g22 = 0:15
design-3:
f 3 = 6:49 g13 = ;0:71 g23 = ;0:51
design-4:
f 4 = 7:02 g14 = 0:16 g24 = ;0:79
a) Determine the largest value of the bonus parameter that may be used for this set of
designs without causing the GA to pick an inferior design as the best design of the population.
b) If the bonus parameter is = 0:2, and the penalty parameter = 0:01, determine the
smallest value of the penalty parameter p that can be used without causing the GA to pick an
infeasible design as the best design of the population.
For part a) of this problem, we consider only designs that satisfy both constraints. Therefore,
we will add bonus only to the objective functions of design-1 and design-3. Note that this is
a maximization problem so we add the bonus to the objective function (as opposed to the
function of Eq. (5.4.5) from which we subtract the bonus). The bonus is calculated on the
basis of the most critical constraint. For design-1, g11 = 0:11 is the most critical, and for
design-3, g23 = 0:51, is the most critical. Adding a bonus to these constraints for the two
designs will change the tness function of the respective designs,
1 = 6:69 + 0:11 and 3 = 6:49 + 0:51
163
CHAPTER 5. INTEGER PROGRAMMING TECHNIQUES
Clearly, design-1 has a better objective function than design-3. However, design-3 has a constraint margin which is larger than that of design-1, and adding too large a bonus may make the
tness of the design-3 better than that of design-1. This is not an acceptable situation, and
the largest value of the bonus parameter should be limited such that the tness 3 is smaller
than the tness 1 . Therefore,
(0:51 ; 0:11) < (6:69 ; 6:49) ) 0:5 :
For part b), we penalize those designs that have constraint violation, namely, design-2 and
design-4. Typically, designs that violate one or more of the constraints have better objective
function values than designs that satisfy all constraints, as is the case in this example. If the
penalty parameter is not large enough, the tness function of the design with a constraint
violation may be better than the tness of the best design which satises all the constraints.
In this example, the tness of the best feasible design with the specied bonus parameter of
= 0:2 is,
1 = 6:69 + 0:2 0:11 = 6:71 :
For the second design, the value of the penalty parameter which will cause 3 to become larger
than 1 is,
7:30 ; 0:01 ; p 0:28 > 6:71 ! p < 2:07 :
For the fourth design, the value of the penalty parameter which will cause its tness to become
larger than 1 is,
7:02 ; 0:01 ; p 0:16 > 6:71 ) p < 1:88 :
Therefore, the smallest penalty parameter that can be used without causing the GA to pick an
infeasible design as the best design of the population is the largest of the two values, p = 2:07.
If we use a penalty parameter of p = 1:88, the tness of design-2 becomes 2 = 6:76 which is
larger than the tness of the best feasible design and, therefore, is unacceptable. In the example above we picked the permissible values of the penalty and bonus parameters by inspecting 4 possible designs. Of course, other designs may exist that will require
more stringent values for these parameters. In general, we need to try and estimate reasonable values for these parameters based on our knowledge of the problem. It pays to begin
with relatively small penalty parameters. If these parameters are inappropriate we will nd
that the genetic algorithm will yield infeasible designs, and then we can increase the penalty
parameters. Similarly, we may want to start with fairly substantial bonus parameters. If we
nd that some of the designs with high constraint margins produce tnesses larger than tnesses for designs that have better value of actual objective function but smaller constraint
margins, we can reduce the bonus parameter.
Once we dene the tness of all the designs in the population, a common procedure
for selecting parent designs is to simulate a biased roulette wheel, with each design being
assigned to a sector of the roulette wheel with an area proportional to its tness. That is,
164
5.4. GENETIC ALGORITHMS
subroutine select(R,ns,parent)
integer parent(2)
dimension R(ns)
do 400 i=1,2
place=rand(iseed)
do 300 j=2,ns
if (place .gt. R(j-1)) go to 300
parent(i)=j-1
go to 400
300 continue
parent(i)=ns
400 continue
return
end
Figure 5.5: Fortran subroutine for selecting two parents by simulating a roulette wheel.
with ns designs having tness values of i i = 1 : : : ns , the ith designs gets a fraction ri
of the wheel, where
ri = Pns i :
(5.4.7)
j =1 j
On the computer the roulette wheel can be implemented by generating a random number
r between zero and one, and then selecting the ith design if
Ri;1 r < Ri
(5.4.8)
where R0 = 0:0, and
i
X
Ri = rj
i = 1 : : : ns :
(5.4.9)
j =1
The procedure is coded as subroutine select in Figure 5.5, and demonstrated in the
following example.
Example 5.4.2
For a generation of six designs the following tnesses were calculated, f1 2 3 4 5 6 g =
f0:35 0:60 0:38 0:65 0:45 0:15g. In order to select parents for crossover, six random numbers
165
CHAPTER 5. INTEGER PROGRAMMING TECHNIQUES
between 0:0 and 1:0 were generated: r = f0:2825 0:7123 0:1560 0:9217 0:6120 0:3471g.
Construct the roulette wheel and determine the individuals selected for the crossover operation.
For the given list of tnesses, the sum of all tnesses yield
ns
X
j =1
j = 0:35 + 0:60 + 0:38 + 0:65 + 0:45 + 0:15 = 2:58 :
Therefore, the fractions of the wheel occupied by the dierent designs are given by,
fr1 r2 r3 r4 r5 r6 g = f0:1357 0:2326 0:1473 0:2519 0:1744 0:0581g :
In order to implement the selection process using the roulette wheel, we create another list of
numbers following Eq. (5.4.9),
fR0 R1 R2 R3 R4 R5 R6 g = f0:0 0:1357 0:3683 0:5156 0:7675 0:9419 1:0g and the wheel for this generation of designs is shown in Figure 5.6 with the integers on the
slices indicating the location of the design in the initial tness list (Also note that the angles
associated with the Ri s are obtained by multiplying them by 360 ).
r = 0.2825
r = 0.3471
r = 0.1560
R2
R1
2
1
3
R3
6
4
5
R0, R6
R5
r = 0.9217
r = 0.6120
R4
r = 0.7123
Figure 5.6: Roulette wheel for Example 5.4.1
The locations of the Ri i = 1 : : : 6 are marked along the circumference of the wheel. For
each value of the random number r, we chose a parent design using Eq. (5.4.8). That is, we
place the random number around the circumference going counter clockwise from R0 = 0 and
166
5.4. GENETIC ALGORITHMS
nd the interval in which the random number falls. For the rst random number r = 0:2825
we have
R1 < 0:2825 < R2 therefore, design 2 is selected. For the remaining random numbers, we have
R3 < 0:7123 < R4 R1 < 0:1560 < R2 R4 < 0:9217 < R5 R3 < 0:6120 < R4 and R1 < 0:3471 < R2
:
The parent designs selected for the next generations are,
f2 4 2 5 4 2g :
Dening tness on the basis of the numerical value of the objective function or the
augmented function carries the disadvantage that towards the end of the optimization,
when the dierences between competing designs become small, the selection pressures in
favor of the better design becomes small, and progress slows down. For this reason, another
popular strategy is to dene the tness based on the relative rank of the designs. In that
case, the ith ranked design is reassigned a tness value of
i = ns ; i + 1 :
(5.4.10)
In this case the portion of the roulette wheel assigned to the design, Eq. (5.4.7), becomes
i + 1)
ri = 2((nns ;
+ 1)n :
s
s
(5.4.11)
Example 5.4.3
Repeat the previous example, Example 5.4.2, for a tness list of f1 2 3 4 5 6 g =
f0:62 0:60 0:65 0:61 0:57 0:64g, which represent a typical population towards the end of a
genetic optimization when the dierence between the designs becomes small. Use the same six
random numbers used in the previous example, a) for the standard tness-based selection, b)
for the rank-based selection process.
a) In this case of tness based selection, the fractions of the wheel occupied by the dierent
designs are given by,
fr1 r2 r3 r4 r5 r6 g = f0:1680 0:1626 0:1762 0:1653 0:1545 0:1734g and the wheel for this generation of designs is shown in Figure 5.7-a.
167
CHAPTER 5. INTEGER PROGRAMMING TECHNIQUES
r = 0.2825
r = 0.3471
r = 0.2825
r = 0.1560
R2
r = 0.3471
r = 0.1560
R1
R1
2
1
2
1
3
R3
R0, R6
R4
4
r = 0.9217
R5
r = 0.9217
R4
r = 0.6120
R3
r = 0.7123
a) based on fitnesses
r = 0.7123
b) based on ranking
Figure 5.7: Roulette wheel for example 5.4.2
The list of summation of fractions of the area of the wheel is,
fR1 R2 R3 R4 R5 R6 g = f0:1680 0:3306 0:5068 0:6721 0:8266 1:0g :
For the same set of random numbers used in the previous example, we have
R1 < 0:2825 < R2 R4 < 0:7123 < R5 R0 < 0:1560 < R1 R5 < 0:9217 < R6 R3 < 0:6120 < R4 and R2 < 0:3471 < R3 yielding the following parents,
f2 5 1 6 4 3g :
Note that, none of the designs are selected twice as parents.
b) Reordering the designs according to ranking we have
f0:65 0:64 0:62 0:61 0:60 0:57g where the corresponding designs from the original list are,
f3 6 1 4 2 5g :
The new rank-based tnesses for these designs are,
f6 5 4 3 2 1g :
168
R0, R6
R5
5
3
5
r = 0.6120
R2
6
4
6
5.4. GENETIC ALGORITHMS
The fractions of the wheel occupied by the rank-based designs are given by Eq. 5.4.11 as,
fr1 r2 r3 r4 r5 r6 g = f0:2857 0:2381 0:1905 0:1429 0:0952 0:0476g and the wheel for this generation of designs is shown in Figure 5.7-b. Note that the numbers in
the list above are ordered from best to poorest rather than by the original order of the designs.
So r1 = 0:2857 corresponds to the best design, or design #3 of the original list.
The list of summation of fractions of the areas of the wheel is,
fR1 R2 R3 R4 R5 R6 g = f0:2857 0:5238 0:7143 0:8572 0:9524 1:0g and, for the same set of random numbers used in the previous example, we have
R0 < 0:2825 < R1 R2 < 0:7123 < R3 R0 < 0:1560 < R1 R4 < 0:9217 < R5 R2 < 0:6120 < R3 and R1 < 0:3471 < R2 :
These random numbers select the
f1 3 1 5 3 2g
designs of the ranked population as parents. The original designs corresponding to these parents
are,
f3 1 3 2 1 6g :
The designs 1 and 3 in the original population, which are among the designs with the highest
tnesses, are each selected twice as parents. On the other hand designs 4 and 5 of the original
population with low tnesses are not selected. Another advantage of the rank-based selection procedure is its capability to handle
negative values of the tness function, , as well as the combination of negative and positive
ones. This feature becomes especially handy in cases where, for designs that violate the
constraint, a large penalty multiplier causes the tness function to become negative (see
for example Exercise 5.5) .
5.4.4 Crossover
Once pairs of parents are selected, the mating of the pair also involves a random process
called crossover. The simplest crossover, the single-point crossover, begins by generating a
random integer k between 1 and L ; 1, where L is the string length. This number denes a
cuto point in each of the two strings, and separates each into two sub-strings. Denoting,
for convenience, the two parts as left (initial part) and right (nal part) substrings, we
splice together the left part of the string of one parent with the right part of the string of
the other parent. The random integer needed for dening the cuto point can be generated
169
CHAPTER 5. INTEGER PROGRAMMING TECHNIQUES
as (L ; 1)r + 1], where r is our (0.,1.) uniformly distributed random variable. Consider, for
example, two symmetric laminates coded in a string of length L = 9, and a crossover point
k=5
parent 1:
0 0 1 2 1k3 1 1 1 0=45=0= ; 45=03 ]s
parent 2:
0 0 0 0 1k2 3 4 1 0=45= ; 45=90=0]s :
(5.4.12)
The two possible child designs are
child 1:
0 0 1 2 1 2 3 4 1 0=45=0=45= ; 45=90=0]s
child 2:
0 0 0 0 1 3 1 1 1 0= ; 45=03 ]s :
(5.4.13)
One or both of the child designs are then selected for the next generation. Note that even
though both parent laminates are balanced, neither child is. This indicates the disadvantage
of coding that distinguishes between + and ; in balanced laminates. One solution to this
problem is to use the previously discussed two-layer stacks. Another solution is discussed
later in Section 5.4.7 .
Crossover is typically implemented with some probability pc. If crossover is not indicated
then one of the parents is cloned into the next generation. Implementation of crossover
begins with the generation of single random number r uniformly distributed between 0.
and 1. If the number is less than pc crossover will be performed by generating another
random number for the cuto point. The decisions on which parent to clone or which child
design to select are not important, as the parents were selected at random. The processes
of selection and crossover are repeated until there are ns child designs.
Multiple point crossovers in which information between the two parents are swapped
among more string segments is also possible, but because of the mixing of the strings the
crossover becomes a more random process and the performance of the algorithm might
degrade (De Jong, 1975). An exception to this is the two-point crossover. In fact, the one
point crossover can be viewed as a special case of the two point crossover in which one end
of the string is the second crossover point. Booker (1987) showed that, instead of letting
the end of the string to be the second point that denes the string segment to be crossed,
choosing the end-point randomly improves the performance of the algorithm.
When integer or real variables, such as number of layers or panel dimensions, are represented by binary strings, crossover may generate child designs that do not bear any
resemblance to the parent designs. Consider, for example, a rectangular panel with a length
variable l. Assume the length variable to have an expected range of (0.05, 3.2) inches, represented to an accuracy of 0.05 inch by a 6-digit binary number b. The binary number has
a range from 0 to 26 ; 1 = 63, so that we calculate l as
l = 0:05 (b + 1) :
(5.4.14)
170
5.4. GENETIC ALGORITHMS
The following crossover scenario, between two panels of lengths 0.8 and 2.45 can take place
parent 1:
parent 2:
0 0k1 1 1 1 l = 0:8
1 1k0 0 0 0 l = 2:45 :
(5.4.15)
The two possible child designs are
child 1:
child 2:
0 0 0 0 0 0 l = 0:05
1 1 1 1 1 1 l = 3:2 :
(5.4.16)
That is, instead of getting child designs that have some intermediate value between the
two parent designs we obtain designs that are more extreme than either parent. One can
check that most of the designs obtained by crossover from these two parents will have this
property. This property reduces from the eectiveness of crossover operator for combining
existing traits from parent designs into the child designs. However, it contributes to the
exploration of new design alternatives, a process which is usually handled by the mutation
operator described in the next section. It is probably preferable to let the crossover operator
control recombination of existing traits, and the mutation operator handle exploration of
new traits. However, one can expect that in some situations the additional exploratory
power of the binary crossover operator is benecial.
If, on the other hand, we use real numbers to represent the variables we run into the
opposite problem. In this kind of a representation the real values of each of the variables
is assigned to a single location in the genetic string. With binary representation of these
real numbers, crossover can create child designs which have intermediate values of the
parents genes. However, with each real number represented by a single gene, crossover can
only reproduce values present in the initial population. This situation may be acceptable,
since the mutation operator, described in the next section can create new values. Another
solution to this problem is to replace the ordinary crossover with an averaging crossover.
For example, if we have a string of length L with integer or real variables, we generate the
crossover cuto point as a real random number w = rL between 0 and L. Then we take the
rst bwc variables from one parent, the last L ; bwc ; 1 from the second parent, and we
average the bwc + 1 variable between the two parents according to the fraction w ; bwc.
That is, if in location bwc + 1 the rst parent has the value x1 and the second parent x2 ,
then the child design will have
xc = (w ; bwc) x1 + (1 ; w + bwc) x2
(5.4.17)
Consider, for example, a problem where we design a balanced, symmetric laminated plate
with the design variables being the length a and width b of the plate, and the numbers of
stacks of 02 , 45 , and 902 in half of the thickness of the plate, denoted as N0 , N45 and
171
CHAPTER 5. INTEGER PROGRAMMING TECHNIQUES
N90 , respectively. The genetic string will be a b N0 N45 N90 ]. The following crossover
scenario will correspond to a 10:1 7:3 0]20 plate crossed with a 12:5 6:3 04 = 45=904 ]s
plate with a cuto point of 2.35:
parent 1:
parent 2:
10:1 7:3 5 0 0
12:5 6:3 2 1 2 :
(5.4.18)
The (only) child design is
child : 10:1 7:3 3 1 2 :
(5.4.19)
That is the child design is a 10:1 7:3 06 = 45=904 ]s plate. Note that with the cuto point
being 2.35, the rst two numbers in the string were taken from parent 1, the last two from
parent 2, while the third number was calculated as
N0 = (2:35 ; 2)5 + (1 ; 2:35 + 2)2 = 3:05
(5.4.20)
and then rounded down to an integer. If the cuto involved one of the real numbers in
the string the last step of rounding would have not been required. The process is coded in
subroutine cross for integer variables, as shown in Figure 5.8.
5.4.5 Mutation
Mutation serves an important task of preventing premature loss of important genetic information by introduction of occasional random alteration of a string. Inferior designs may
have some good traits that can get lost in the gene pool when these designs are not selected
as parents. Additionally, mutation is needed when integer or real coding is used because in
most cases there is low probability that all the possible genes are represented in the initial
population. Consider, for example an initial population of 20 designs, each with 6 genes,
where each gene can take a value from 1 to 10. Let us calculate the probability that no
member of the initial population will have a value of 10 for one of the 6 genes. The probability that any individual design does not have the value 10 in the rst gene is 0.9. The
probability that none of the designs have that value is 0:920 = 0:121. That is the probability
that at least one design will have a gene with a value of 10 is 0.879. The probability that
at least one design will have the value 10 for each one of the 6 genes is 0:8796 = 0:46. That
is, there is more than 50 percent chance that the value 10 is missing from at least one gene
in the entire initial population. Because this is the highest value for the gene, averaging
crossover cannot create this gene, and only mutation can.
Mutation is implemented by changing, at random, the value of a digit in the string with
small probability. Based on small rate of occurrence in biological systems and on numerical
172
5.4. GENETIC ALGORITHMS
subroutine cross(parent,chldlm,prntlm,ns,pc,L)
integer parent(2),prntlm(L,ns),chldlm(L)
id1=parent(1)
id2=parent(2)
clone=rand(iseed)
if (clone .gt. pc) then
do 100 i=1,L
chldlm(i)=prntlm(i,id1)
100 continue
return
else
endif
rcut=L*rand(iseed)
icut=int(rcut)
if (icut .eq. 0) go to 300
do 200 i=1,icut
chldlm(i)=prntlm(i,id1)
200 continue
300 continue
chldlm(icut+1)=(rcut-icut)*prntlm(icut+1,id1)
@ +(1.-rcut+icut)*prntlm(icut+1,id2)
if (icut .eq. L-1) return
do 400 i=icut+2,L
chldlm(i)=prntlm(i,id2)
400 continue
return
end
Figure 5.8: Fortran subroutine for averaging crossover with integer variables in a string of
length L. Crossover is performed with probability pc, otherwise the rst parent is cloned.
173
CHAPTER 5. INTEGER PROGRAMMING TECHNIQUES
experiments, the role of the mutation operation on the performance of a genetic algorithm
is considered to be a secondary eect. Goldberg suggests a rate of mutation pm of one in
one thousand bit operations. However, when integer coding is used higher mutation rates
are required. Our experience with stacking sequence design suggests a rate of about one in
a hundred, with smaller populations requiring higher mutation rates to preserve diversity
in the population. Mutation is implemented by generating a random number between 0 and
1 and applying a mutation if its value is smaller than pm . Another random number can
then be used to select a replacement to the digit being mutated. When we use 0 to denote
absent layers, a mutation may create a void inside the laminate, so that we have to pack
the laminate as described earlier in Section 5.4.2 after the mutation operation.
When real design variables are coded as binary numbers, there are situations where
small changes in the design cannot be achieved by mutations. For example, consider the
case when we have an integer design variable varying from 0 to 31, coded as a 5 digit binary
number. The string 01111] corresponds to 15 and the string 10000] corresponds to 16. Even
though the two designs are close, it is extremely unlikely that a mutation will change one
string into another. This can occasionally result in slower progress for the algorithm. For
example, if the optimum design corresponds to 16, and 15 is a close second best, we can
run into situations when most of the members of the population have a value of 15 at some
stage of the optimization. Making the nal improvement from 15 to 16 can then take a very
long time. To counteract this problem, one can use another binary coding, called the gray
code, which does not have the abrupt change in digits due to small changes in the value
of the number. Alternatively, we can add another mutation operator, called local mutation,
applied to the original variables rather than the coded ones. This local mutation operator
is also useful when we do not use binary numbers but use the actual values of the variables
in the string. Subroutine locmut, shown in Figure 5.9, performs such a mutation. The
size of the mutation is dictated by the parameter range.
The mutation coded in subroutine locmut in Figure 5.9 is based on a uniform distribution. When real variables are used in the string, the mutation is often a normally
distributed random number with a zero mean and a specied standard deviation (see, Back
and Schwefel, 1993).
5.4.6 Permutation, Ply Addition and Deletion
For stacking sequence design, several specialized mutation operators have been suggested
in the literature. One class of operators is permutation operators which change the stacking sequence without changing the composition of the laminate. These operators change
the bending stiness of the laminate without changing its in-plane properties. They are
particularly useful for laminate problems with constraints on both in-plane and bending
174
5.4. GENETIC ALGORITHMS
subroutine locmut(lamin,L,pm,range)
dimension lamin(L)
do 100 i=1,L
dodont=rand(iseed)
if (dodont .gt. pm) go to 100
mute=range*rand(iseed)
if (dodont .lt. 0.5) then
lamin(i)=lamin(i)-mute
if (lamin(i) .lt. 0) lamin(i)=0
else
lamin(i)=lamin(i)+mute
endif
100 continue
return
end
Figure 5.9: Fortran subroutine for local mutation which perturbs integer variables by range
with probability pm.
properties as explained below.
In problems of stacking sequence design, there are many laminates with the same inplane properties and dierent bending properties. For example, the laminates 0=902 ]s ,
90=0=90]s , and 902 =0]s have the same in-plane stinesses but dierent bending stinesses.
In fact, any permutation of the stacking sequence preserves the in-plane properties. In particular, if we consider the optimum stacking sequence for a combined in-plane and bending
problem, there may be many laminates with identical layer composition, but with dierent
(non-optimal) stacking sequence. Since there are many possible laminates, the genetic algorithm typically nds laminates with optimal composition of orientation angles early in the
search, and the rest of the search is devoted to shu ing the stacking sequence to produce
the desired bending properties.
Achieving a permutation in stacking sequence by a standard mutation operator is difcult because it calls for two simultaneous mutations, which have a low probability of
occurring. For this reason, various permutation operators have been proposed for stacking
sequence design (e.g., Le Riche and Haftka 1993, 1995 Marcelin et al., 1995 Nagendra et
al., 1996). The simplest, and possibly the most eective permutation operator is the plyswap, where two layers are interchanged. For example, for a symmetric balanced laminate
175
CHAPTER 5. INTEGER PROGRAMMING TECHNIQUES
45= ; 45=0=902 =0=45=02 = ; 45]s with positions 3 and 7 chosen for a ply-swap, we have (0 ,
45 , ;45 , 90 coded as 1,2,3,4, respectively)
before ply-swap :
2314412113
after ply-swap :
2324411113
leading to 45= ; 45=45=902 =04 = ; 45]s laminate.
(5.4.21)
Occasionally, the number of plies of each orientation is xed, and the laminate design requires only to obtain the best stacking sequence with the given orientations. This
is equivalent to nding the best permutation of a baseline laminate. Specialized codings
and crossover have been developed for permutation problems arising in scheduling (e.g.
Michalewicz, 1992). These can be adapted to composite optimization, and have proved to
be highly ecient (Liu et al. 1998).
When the thickness of a laminate is not specied, we use empty layers or stacks with
special code (e.g. zero) to allow for variable thickness. The standard mutation operator
in this case controls the processes of adding layers, deleting layers, and changing their
orientation in a collective manner. These operators are referred to as, the ply-addition, plydeletion, and ply-orientation mutations, respectively. Assigning dierent probabilities to
the three dierent forms of the mutation operator may provide performance improvements.
For example, if a single mutation probability is used, we may change the laminate thickness
more frequently than we need. The optimum laminate thickness is usually achieved early
in the genetic search, so that the probability of adding or subtracting layers should be low
compared to the probability of changing the orientation. Le Riche and Haftka, 1995, show
the benet of using separate ply-addition, ply-deletion, and ply-orientation mutations. Nagendra et al., 1995, show similar gains, and also suggest separate ply-swap operators for
interchanging layers in the same laminate and between dierent laminates in the components of a stiened panel (e.g., between the skin and the stiener laminates).
5.4.7 Computational Cost and Reliability
Genetic algorithms tend to be costly, requiring thousands of analyses. The cost depends on
the size of the design space and the way constraints hinder movement in the design space.
Therefore, to keep the computational cost manageable it is useful to try and keep down
the size of the design space and avoid formulating constraints in such a way that they will
greatly constrain the movement in the design space. The constraint reecting the balanced
laminate requirement is a good example of this principle. Consider for example, the design
of a 48-ply symmetric and balanced laminate to be made of 0 , 90 , and 45 orientations.
The symmetry allows modeling of only half of the laminate, so that the string length is
176
5.4. GENETIC ALGORITHMS
24. With four possible digits to represent the four orientations, the size of the design space
is 424 = 2:8 1014 . As noted in the Crossover Section (Section 5.4.4), even if two parent
laminates are balanced the child laminate is often not balanced. That is, we have a very
large design space, and the balance constraint is violated for many laminates generated by
crossover or mutation.
If we use stacks of two layers each 02 , 45, and 902 , we automatically satisfy the
balance constraint and, for the 48-ply laminate, reduce the string length to 12. With only
three possible digits the size of the design space shrinks to 312 = 531 441. Of course, we
may lose a bit on performance, because we exclude laminates with odd number of layers of
the same orientation in a stack. If we have a problem where this consideration is important
enough, we can still salvage some of the performance gains. We can use, for example, the
digits 1, 2, and 3 to represent the possible layers, with 1 representing 0 and 3 representing
90 layers. The digit 2 represents either a 45 or a ;45 layer, with the understanding that
the outermost 2 in the string corresponds to 45 , the next 2 corresponds to ;45 , and so on.
The size of the design space is now 324 = 2:8 1011 , which is still 1000 times smaller than
the original design space. Also, now we can never have more than a single layer violation
of the balance condition, and violations are less common as a result of crossover.
The computational cost of genetic algorithms also depends on our requirements in terms
of reliability. It is important to realize that because of the random aspects of the algorithm,
each execution of the algorithm can result in a dierent answer. High reliability means that
almost always the answer is close enough to the global optimum. Le Riche and Haftka (1993)
dened practical reliability as the probability that the optimum is \practically equal" to
the global optimum. For the buckling and strength problems that they solved, they dened
the term \practically equal" to mean within 0.1 percent of the optimum. The reliability
can be increased by increasing the number of generations that the algorithm is run, and by
increasing the number of strings ns. Alternatively, we can simply run the algorithm several
times and take the best answer. All of these strategies cause an increase in computational
cost. However, multiple runs may also produce multiple solutions that could be useful to
the designer. This point is illustrated in the following example.
The reliability of the genetic algorithm is usually established by testing with problems
with known solutions. If the algorithm is run m times and is successful in nding the global
optimum ms of these runs, then the apparent reliability ra is
ra = ms =m :
(5.4.22)
However if m is small, the apparent reliability may be quite dierent from the true reliability
r. In fact, with a bit of statistics, it can be shown that the standard deviation a of the
177
CHAPTER 5. INTEGER PROGRAMMING TECHNIQUES
apparent reliability is
q
a = r(1 ; r)=m :
(5.4.23)
For example, if we have 7 successful runs out of 10, the apparent reliability is 0.7, with a
standard deviation of 0.145.
Example 5.4.4
Use genetic optimization to nd the thinnest balanced symmetric Graphite/Epoxy laminate
made of 0 , 30 , 45 , 60 and 90 layers that satises the strain constraints of Example
4.1.1.
Since this is an in-plane problem, we do not need to design the stacking sequence but only
the number of layers in each orientation. We, therefore, select the design variables as n0 , n30 ,
n45 , n60 , and n90 . With the symmetry and the balance condition the total number of layers in
the laminate, which is the objective function, is
f = 2(n0 + n90 ) + 4(n30 + n45 + n60 ) :
The two constraints are a limit of 0.004 on the axial strain x under a load of Nx = 10 000
lb/in, and a limit of 0.006 on the shear strain xy under a load of Nxy = 3 000 lb/in. We write
the constraints in a normalized form as
g1 =
g2 =
x
0:004 ; 1 0 xy
0:006 ; 1 0 :
For the genetic optimization we use a string of (n0 n30 n45 n60 n90 ), and an augmented
objective function of
f + p max(g1 g2 ) if max(g1 g2 ) > 0 ,
f ; jmax(g1 g2 )j otherwise:
To determine the magnitude of p we note that in Example 4.1.1 the total number of layers
f =
varied between 68 and 158, depending on the choice of orientation angles. For any of these
choices, one constraint is critical, i.e. close to zero. Reducing the number of layers by, say 10
percent, will increase the strains by 10 percent, and so will result in gmax becoming about 0.1.
We need the penalty associated with this violation to result in an increment to the augmented
objective of at least 10 percent of that objective. This means a p of between 68 and 158. To
ensure feasibility we chose p = 300.
To provide bonus for feasible designs with constraint margin, we need to choose to be
small enough so that even a large constraint margin will not overpower a dierence in thickness.
On the other hand, we want it to be large enough to reward constraint margins for designs with
the same thickness. For this we chose = 0:1 (for a discussion of the selection of the bonus
and penalty parameters, refer to Section 5.4.3 and Example 5.4.1). For the initial population
178
5.4. GENETIC ALGORITHMS
we used subroutine init of Figure 5.4, with nmax=20. As can be seen from the equation for
the objective function, this choice permits the initial population to have up to 320 layers, with
an average of 160. We used the averaging crossover of Figure 5.8, and the local mutation of
Figure 5.9. After some experimentation we settled on a mutation rate, pm = 0:15, a mutation
range of 5, and a crossover probability, pc = 0:9.
To determine the population size and number of generations, we ran the optimization
20 times and monitored the reliability of the process. For a population size of 80 and 50
generations, 19 of the 20 optimizations gave the same nal objective. Using Eqs. (5.4.22) and
(5.4.23) this corresponds to a reliability of 0.95 with standard deviation of 0.049. Of course,
for more expensive problems we may not be able to engage in such extensive experimentation.
However, it is important to build up intuition for these parameters from simple problems.
The optimizations yielded 4 designs with practically identical performance. These were
012 = 454 ]s , 010 = 303= 45= 60]s , 09= 304= 45=90]s, and (010 = 304 = 45)s . All
four designs have 40 layers, and the rst three have g1 = ;0:0001, g2 = ;0:0006. The last
design has g1 = ;0:0365, g2 = ;0:0006. This last design is slightly superior in that it has
a minimum margin of 0.06 percent instead of the 0.01 percent obtained for the other three.
However, the dierence is so minute, that it is much smaller than the error associated with
predicting the strains using classical lamination theory (or any other theory).
It is worthwhile to note again that composite stiness design problems often have multiple
optima, and that genetic algorithms help the designer nd all or many of these optima, thus
presenting a choice that could be decided on the basis of other considerations. The example above demonstrates that multiple genetic runs can produce near equivalent
designs. Additionally, it is often computationally advantageous to make multiple runs rather
than a single long genetic optimization. For example, if we nd that optimization runs that
last 100 generations give us 40% reliability, then the probability that we will not nd the
optimum in one run is 60%, the probability that we will not nd the optimum in two runs
is 0:62 = 36%, and the probability that we will not nd the optimum in three runs is
0:63 = 21:6%. That is, two runs give us a reliability of 64%, and three runs a reliability
of 78.4%. We need to compare these numbers with the reliability achieved in a single run
of 200 generations and 300 generations, respectively. In general, if we denote the reliability
achieved by q runs each with n generations as rq (n), then
rq (n) = 1 ; 1 ; r1 (n)]q :
(5.4.24)
This equation can be used to compare the relative eciency of multiple runs for simple
cases for which we can aord to make a large number of runs. Then the results could
serve as guidelines for choosing the number of runs for similar but more computationally
expensive cases. Le Riche and Haftka (1995) found that for designing the stacking sequence
of unstiened panels for strength and buckling constraints, single runs are most ecient
179
CHAPTER 5. INTEGER PROGRAMMING TECHNIQUES
when the desired reliability is below about 80%. For higher reliabilities multiple runs are
more ecient.
Most of the discussion in the section on genetic algorithm focused on integer codings.
However, binary codings are also popular, and we close the chapter with an example of an
application of a genetic algorithm based on binary coding.
Example 5.4.5
The cantilever composite beam shown in Figure 5.10 is subjected to a transverse load P and
a twisting moment Mxy . Use a genetic algorithm to design of a hygrothermally curvaturestable laminate for the beam. The beam is to be designed to maximize extension-twisting and
bending-extension coupling, with constraints on stiness in exure and twist under the applied
loads. The constraints require the tip displacement to be less than 0.1 inch and the tip twist to
be less than 0.01 radians. The couplings as well as the tip displacement and twist are given in
terms of the inverse of the (A,B,D) matrix, with the corresponding locations os submatrices in
the inverse are denoted as aij , bij , and dij , respectively, see Eq. (3.3.3). The tip displacement
wtip is given as
2
3
wtip = d113PL + d16 M2xy L :
The tip twist tip is given as
2
tip = d164PL + d66 M2 xy L :
Assuming that we want to maximize a linear combination of the two coupling coecients b11
and b16 , the objective function is (c1 jb11 j + c2 jb16 j). The coecients c1 and c2 are chosen
depending on how we want to emphasize the two coupling terms. In addition to constraints on
maximum deection and twist at the tip, an additional constraint was imposed in this problem
that limited the number of layers in the laminate to a maximum of 24.
Material properties may assumed to be those corresponding to HT-S/4617 Graphite/Epoxy,
and are dened as follows:
E1 = 20 106 psi E2 = 1:3 106 psi G12 = 0:65 106 psi 12 = 0:304 t = 0:005 in:
A hygrothermally curvature-stable, antisymmetric laminate 3 =(
+ 90)6=
3 = ; 3= ; (
+
90)6 = ; 3 ] provides one solution that would meet the desired objective (see Chapter 3). Finding
the optimum value of is a one dimensional optimization problem, and can be solved by plotting
the objective function and constraints as a function of . The hygrothermal curvature stability
can also be realized in more general unsymmetric composite laminates that are obtained by
stacking two symmetric layer groups =
+ 90]n1s (type-I) and = + 60= + 120]n2s (typeII). Any additional symmetric layer groups with equally spaced angles can also be added to
the laminate without disturbing the hygrothermal curvature stability. The problem formulation
allows for the two layer groups to be assigned to the two available positions on the laminate.
180
5.4. GENETIC ALGORITHMS
P
A
A
L = 10 in
M xy
1.0 in
0.12 in
Section A-A
Figure 5.10: Cantilevered beam with a tip load and a moment
It is possible to have both layer groups be of the same type, with similar or dierent basic
orientation angles. The optimization problem for nding the optimum laminate with the angles
and was formulated as
minimize
b ; (c1jb11 j + c2 jb16j)
such that
n1 p1 + n2 p2 24
10 113
100 164
d PL3 + d16 Mxy L2 ; 1 0
2
d PL2 + d66Mxy L ; 1 0 2
The design variables for this problem are the basic orientation angles and , the number
of layer groups n1 and n2 , and the number of layers in each layer group p1 and p2 . That is,
p1 = 2 if we select the rst layer group to go with n1 , and p1 = 3 if we select the second
layer group to go with n1 . The constant b , which was set to 10 10;4, is used to convert the
maximization problem into a minimization.
The orientation angles and were varied discretely between 0 and 174 in increments
of 6 . The 30 possible values of were each represented by one of the unique combinations
available from a 5-digit binary string the two excess binary string combinations were assigned
to 0 and 90 degrees, respectively. The variables n1 and n2 varied between 1 and 4, and required
a 2-digit binary string to uniquely represent the four possibilities. It is important to indicate that
there is an inherent danger in representing certain variables by more strings than others, in that
the search is biased in favor of the overrepresented variables. In this problem, however, due to
a large number of possible choices of and to select from, this is not a serious concern. The
choice of layer group is assigned to two variables p1 and p2 , which could assume the values of
181
CHAPTER 5. INTEGER PROGRAMMING TECHNIQUES
Table 5.2: Summary of optimization results for weighting coecients c1 = 0:5 c2 = 0:5
Run
ID
1
2
3
4
5
1
126
174
126
126
126
2 Group Type n1 n2
p1 p2
30
168
168
168
168
2
2
3
2
2
2
3
2
3
3
4
3
2
3
3
2
2
3
2
2
b11
;6
b16
10
10;6
-16.210 -26.839
-26.031 18.544
25.743 -17.924
-26.031 18.544
-26.031 18.544
Table 5.3: Summary of optimization results for weighting coecients c1 = 0:75 c2 = 0:75
Run 1 2 Group Type n1 n2
b11
b16
;
6
ID
p1 p2
10
10;6
1
36 168
2 3
3 2 -26.031 18.544
2
0 48
3 2
2 3 28.696 7.1758
3 126 168
2 3
3 2 -26.031 18.544
4
0 48
3 2
2 3 28.696 7.1758
5 168 42
3 2
2 3 28.705 -6.7722
2 or 3. Hence, a single digit string is sucient to represent each of these variables. A 16-digit
binary string is required to represent all design variables for this problem (10 digits for and
, 2 digits each for n1 and n2 , and 1 digit each for p1 and p2 ).
Two variations of the above problem were considered. In each case, a total of 10000 function
evaluations were permitted. A two-point crossover was used with a probability of 0.8. Mutation
with a probability of 0.02 per string was used. The rst test case required the maximization of
an equally weighted sum of the b11 and b16 coecients, with only a constraint on the total
allowable thickness of the beam. The best design obtained for this case was that in each of
the two available slots, layer group I was selected, the basic orientation angles for these groups
were 1 = 108 and 2 = 150 , and the coupling coecients b11 and b16 were 122:44 10;6
in/lb-in and 436:98 10;6 in/lb-in, respectively. The variables n1 and n2 were both obtained as
unity this is to be expected as the thinner laminate would maximize the compliance coecients.
This experiment was repeated for population sizes of 100, 150, and 200, and similar solutions
were identied in each case.
In the second test case, the bending and twist displacement constraints were activated in
addition to the maximum thickness requirement. The population size was selected as 200. For
three distinct choices of weighting coecients c1 and c2 , ve simulations of genetic search were
182
5.5. EXERCISES
Table 5.4: Summary of optimization results for weighting coecients c1 = 0:25 c2 = 0:75
Run 1 2 Group Type n1 n2 b11
b16
;
6
ID
p1 p2
10
10;6
1 144 126
2 2
3 3 0.9194 -36.545
2
36 54
2 2
3 3 0.9194 -36.545
3
36 54
2 2
3 3 0.9194 -36.545
4
36 54
2 2
3 3 0.9194 -36.545
5 144 126
2 2
3 3 0.9194 -36.545
performed. These results are summarized in Tables 5.2{5.4. For the case where c1 = 0:75 c2 =
0:25 and c1 = c2 = 0:5, similar results were obtained. As seen in Tables 5.2 and 5.3, the
solutions corresponded to a use of both Type I and Type II groups in establishing an optimal
laminate for the given design constraints. When, the tension-twist coupling is emphasized to
a greater degree than bending-extension (c1 = 0:25 c2 = 0:75), the Type I group was used
exclusively as shown in Table 5.4. This is easily explained by the observation that the Type
II group is mechanically isotropic, and would not contribute to the extension-twist coupling
coecient. In contrast, the Type I group is mechanically orthotropic, and is the predominant
source of the b16 coupling coecient. It is also worthwhile to note that the presence of the
bending and twisting stiness constraints increases the laminate thickness by introducing n1
and n2 values dierent from unity.
5.5 Exercises
1. Design a minimum thickness laminate with 0 , 45 , and 90 layers such that the
laminate Poisson's ratio is greater than 0.6, the shear modulus is less than 16 GPa, and
the stiness term A22 is greater than 30 MN/m. Formulate the problem as a linear integer
programming problem and use optimization software (e.g. Microsoft Excel) to solve it.
Note that the total laminate thickness is not expected to be larger than 20 layers. Use the
following material properties, E1 = 76 GPa, E2 = 5:5 GPa, G12 = 2:3 GPa, 12 = 0:34,
and t = 0:125 mm.
2. For a 40-ply Graphite/Epoxy laminate under unit axial load, show that as you decrease the number of zeroes in the laminate, from (458 =04 )s to (459 =02 )s and nally
to (4510 )s , the maximum strain in any ber direction increases and then decreases. This
makes the all 45 design singular, in that it cannot be reached by gradually reducing the
183
CHAPTER 5. INTEGER PROGRAMMING TECHNIQUES
number of 0 layers.
3. Solve Problem 1 by genetic optimization.
4. Repeat Example 5.4.4 using binary coding of the design variables.
5. Using genetic optimization, design 16-, 24-, and 32-ply balanced symmetric laminates
to maximize the Poisson's ratio of the laminate subjected to the constraint that Ey >
40GPa. Use the following material constants.
U1 = 57:5GPa U2 = 58:0GPa U3 = 13:6GPa U4 = 17:5GPa and U5 = 20:0GPa:
Study the eects of the probability of mutation and the magnitude of the penalty
multiplier on the progress and nal results of the design optimization.
5.6 References
Arora, J. S., \Introduction to Optimum Design," McGraw{Hill, New York, 1989.
Back, T., and Schwefel, H.-P., \An Overview of Evolutionary Algorithms for Parameter
Optimization," Evolutionary Computation, 1 (1), 1{23, 1993.
Booker, L., \Improving Search in Genetic Algorithms," in Genetic Algorithms and Simulated Annealing, Ed. Davis, L., Morgan Kaufmann Publishers, Inc., Los Altos, CA. 1987,
pp. 61{73.
Callahan, J. K., and Weeks, G. E., \Optimum Design of Composite Laminates Using
Genetic Algorithms," Composites Engineering, 2 (3), pp. 149{160, 1992.
De Jong, K. A., Analysis of the Behavior of a Class of Genetic Adaptive Systems (Doctoral Dissertation, The University of Michigan University Microlms No. 76-9381), Dissertation Abstracts International, 36 (10), 5140B, 1975.
Furuya, H., and Haftka, R.T., \Genetic Algorithms for Placing Actuators on Space
Structures," Proceedings, Fifth International Conference on Genetic Algorithms," July 17{
22, 1993, Urbana, IL., pp. 536{542.
Garnkel, R. S., and Nemhauser, G. L., Integer Programming, John Wiley & Sons, Inc.,
New York, 1972.
Goldberg, D. E., and Samtani, M. P., \Engineering Optimization via Genetic Algorithm," Proceedings of the Ninth Conference on Electronic Computation, ASCE, February
1986, pp. 471{482.
184
5.6. REFERENCES
Goldberg, D. E., Genetic Algorithms in Search, Optimization, and Machine Learning,
Addison-Wesley Publishing Co. Inc., Reading, Massachusetts, 1989.
Hajela, P., \Genetic Search|An Approach to the Nonconvex Optimization Problem,"
AIAA J., 28 (7), July 1990, pp. 1205{1210.
Holland, J. H., Adaptation of Natural and Articial Systems, The University of Michigan
Press, Ann Arbor, MI, 1975.
Johnson, E. L., and Powell, S., \Integer Programming Codes," in Design and Implementation of Optimization Software, Greenberg, H. J. (ed.), pp. 225{240, 1978.
Kogiso, N., Watson, L.T., Gurdal Z., Haftka, R.T., and Nagendra, S., \Design of Composite Laminates by a Genetic Algorithm with Memory," Mechanics of Composite Materials
and Structures, 1(1), pp. 95{117, September 1994.
Kovacs, L. B., Combinatorial Methods of Discrete Programming, Mathematical Methods of Operations Research Series, Vol. 2, Akademiai Kiado, Budapest, 1980.
Land, A. H., and Doig, A. G., \An Automatic Method for Solving Discrete Programming
Problems," Econometrica, 28, pp. 497{520, 1960.
Laarhoven, P. J. M. van. and Aarts, E.,glossaryAarts, E., Simulated Annealing: Theory
and Applications, D. Reidel Publishing, Dordrecht, The Netherlands, 1987.
Lawler, E. L., and Wood, D. E., \Branch-and-Bound Methods|A Survey," Operations
research, 14, pp. 699{719, 1966.
Le Riche, R. Optimization of Composite Structures by Genetic Algorithms, Ph.D. Dissertation, Virginia Polytechnic Institute and State University, Oct.1994.
Le Riche, R., and Haftka, R. T. , \Optimization of Laminate Stacking Sequence for
Buckling Load Maximization by Genetic Algorithm," AIAA/ASME/AHS/ASCE/ ASC
33rd Structures, Structural Dynamics and Materials Conference, Dallas, TX. 1992, also
AIAA Journal, Vol. 31 (5), pp. 951{956, 1993.
Le Riche, R., and Haftka, R.T., \Improved Genetic Algorithm for Minimum Thickness
Composite Laminate Design," Composite Engineering, 5 (2), pp. 143{161, 1995.
Le Riche, R., Knopf-Lenoir, C., and Haftka, R. T., \A Segregated Genetic Algorithm
for Constrained Structural Optimization," in Genetic Algorithms: Proceedings of 6th International Conference on Genetic Algorithms (ICGA95) (L. Eshelman, editor), July 1995.
Liu, B., Haftka R. T., and Akgun, M. A., \Permutation Genetic Algorithm for Stacking
Sequence Optimization," AIAA Paper 98-1830, 1998.
Marcelin, J.-L., Trompette, P., and Dornberger, R., \Optimization of Composite Beam
Structures using a Genetic Algorithm," Structural Optimization, 9(3/4), pp. 236{244, 1995.
185
CHAPTER 5. INTEGER PROGRAMMING TECHNIQUES
Michalewicz, Z., Genetic Algorithms + Data Structures = Evolution Programs, Springer
Verlag, Berlin, 1992.
Nagendra, S., Haftka, R. T., and Gurdal, Z., \ Design of a Blade Stiened Composite
Panel by a Genetic Algorithm," Proceedings, AIAA/ASME/ASCE-/AHS/ASC 34th Structures, Structural Dynamics and Materials Conference, San Diego, CA, April 19{21, 1993,
Part 4, pp. 2418{2436.
Nagendra, S., Jestin, D., and Gurdal, Z.,, Haftka, R. T., and Watson, L. T., \ Improved Genetic Algorithm for the Design of Stiened Composite Panels," Computers and
Structures, 58 (3), pp. 543{555, 1996.
Rao, S. S., Pan, T.-S., and Venkayya, V. B., \Optimal Placement of Actuators in Actively Controlled Structures Using Genetic Algorithms," AIAA J., 29 (6), pp. 942{943, June
1991.
Schmit,L. A., and Farshi, B., \Optimum Laminate Design for Strength and Stiness,"
Int. J. Num. Meth. Engrg., 7, pp. 519{536, 1973.
Schrage, L., Linear, Integer, and Quadratic Programming with LINDO, 4th Edition,
The Scientic Press, Redwood City CA., 1989.
Tomlin, J. A., \Branch-and-Bound Methods for Integer and Non-convex Programming,"
in Integer and Nonlinear Programming, J. Abadie (ed.), pp. 437{450, Elsevier Publishing
Co., New York, 1970.
186