Author: YehLiang Hsu, TzuChi Liu (20061204);
recommended: YehLiang Hsu (20080527)
Note: This paper is published in Engineering
Optimization, Vol. 39, Iss. 6, pp. 679700, September 2007.
Developing a fuzzy proportionalderivative
controller optimization engine for engineering design optimization problems
Abstract
In realworld engineering design problems, decisions
for design modifications are often based on engineering heuristics and
knowledge. However, when solving an engineering design optimization problem
using a numerical optimization algorithm, the engineering problem is basically
viewed as a pure mathematical problem. Design modifications in the iterative optimization
process rely on numerical information. Engineering heuristics and knowledge are
not utilized at all.
In this paper, the optimization process is analogous
to a close loop control system, and a fuzzy proportionalderivative (PD) controller
optimization engine is developed for engineering design optimization problems
with monotonicity and implicit constraints. Monotonicity between design
variables and the objective and constraint functions prevails in engineering
design optimization problems. In this research, monotonicity of the design
variables and activities of the constraints determined by the theory of
Monotonicity Analysis are modeled in the fuzzy PD controller optimization
engine using generic fuzzy rules. The designer only needs to define the initial
values and move limits of the design variables to determine the parameters in
the fuzzy PD controller optimization engine.
In the optimization process using the fuzzy
PD controller optimization engine, the function value of each constraint is
evaluated once in each iteration. No sensitivity information is required. The
fuzzy PD controller optimization engine appears to be robust in the various
design examples tested in this research.
Keywords: design optimization, monotonicity analysis, fuzzy control.
1.
Introduction
Engineering design optimization problems
often have two characteristics. First, monotonicity between design variables
and the objective and constraint functions prevails in engineering design
optimization problems. The theory of Monotonicity Analysis (Papalambros and
Wilde, 2000) was developed to analyze this type of problems to identify which
constraints must be active at the optimum design point. However, numerical
optimal solution cannot be obtained by Monotonicity Analysis alone.
Secondly, most realworld engineering
design problems have complex phenomena, and the objective and constraint
functions often cannot be expressed analytically in terms of design variables. These
socalled “implicit functions” are evaluated by computer simulation or by
physical experiments, which are usually the major cost of the optimization process.
Moreover, the analytical forms of the first derivatives of the implicit functions
are often not available. This fact hinders the use of formal numerical
optimization techniques to solve these engineering design optimization problems.
An iterative optimization process can be analogous
to a closeloop control system. Figure 1 shows the block diagram of a
closeloop control system. The measured response of the system process being
controlled is fed back and compared with a desired response. The control actions
generated by the controller are determined in an attempt to fix the error
between the system response and the desired response.
Figure 1. A closeloop control system
Figure 2 shows a block diagram for an
optimization process. Initial parameters are input to the optimization
algorithm, which in turn generates a trial design point according to its search
rules. The optimization model is then evaluated at this trial design point, and
the information such as objective and constraint function values and sensitivities
are fed back to the termination test. If the termination test fails, the
optimization algorithm is triggered again to generate the next design point,
using the numerical information from previous iterations. Finally, while a
control system attempts to achieve a stable, predefined output, the
optimization process pursues a converging objective function value. Comparing Figure
1 and 2, an optimization model in an optimization model is analogous to the system
process in a control system, while an optimization algorithm is analogous to
the controllers.
Figure 2. Block diagram for an optimization
process.
Traditional numerical optimization
algorithms are analogous to direct digital controllers. The algorithms are
usually ‘crisply’ designed for well defined mathematical models, and their
numerical rules for generating the next design point are exact and definite. In
realworld engineering design problems, decisions for design modifications are
often based on engineering heuristics and knowledge. However, when solving an
engineering design optimization problem using a numerical optimization algorithm,
the engineering problem is basically viewed as a pure mathematical problem.
Design modifications in the iterative optimization process rely on numerical
information. Engineering heuristics and knowledge are not utilized at all.
This motivates the idea that, in addition
to crisp numerical rules, the engineering heuristics and knowledge should also be
modeled in an optimization algorithm using fuzzy rules. As suggested in Figure 2,
the ‘controller’ in the optimization process may as well be a fuzzy controller!
In this research, a fuzzy proportionalderivative
(PD) controller optimization engine is developed to deal with general engineering
design optimization problems with monotonicity and implicit functions. In
particular, monotonicity of the design variables and activities of the
constraints determined by Monotonicity Analysis are modeled in the fuzzy PD
controller optimization engine using generic fuzzy rules. The structure of an
optimization algorithm is still maintained to guide the engineering decision
process.
Section 2 of the paper further discusses
the concept of the fuzzy PD controller optimization engine. Section 3 describes
the process of using the fuzzy PD controller optimization engine, and Section 4
uses an example to illustrate the process. In Section 5, the fuzzy PD
controller optimization engine is used to solve several engineering design
optimization examples commonly seen in literature. Finally Section 6 concludes
the paper.
2.
The concept of the fuzzy PD
controller optimization engine
Application of fuzzy theory in optimization
problems
Fuzzy theory is primarily concerned with
quantifying and reasoning using natural language in which many words have
ambiguous meanings. Since the introduction of the basic theory of fuzzy sets by
Zadeh (1965), fuzzy theory has been extended and applied to many different
fields, including engineering design optimization.
The application of fuzzy theory in optimization
problems can be categorized in two dimensions:
(1) Using fuzzy theory to formulate the uncertainty of the optimization
model
Bellman and Zadeh (1970) introduced
the fuzzy setbased optimization on decision making in a fuzzy environment
which includes the concept of fuzzy constraint, fuzzy objective and fuzzy decision.
For fuzzy optimization, the objective and constraint functions are
characterized by the membership functions in a fuzzy system. The decision can
be viewed as the intersection of the fuzzy objective and constraint functions.
Once the membership functions are known, the optimization problem can be viewed
as a crisp optimization problem.
Different kinds of mathematical
models have been proposed to solve fuzzy optimization problems in various
engineering fields. Rao et al. (1992)
and Xiong and Rao (2003, 2005) applied the concept of fuzzy optimization on the
design optimization of mechanical and structural systems. Guan et al. (1995) presented the application
of a fuzzy optimization technique to optimal power flow calculations. Sarma and
Adeli (2000) presented a fuzzy discrete multiobjective optimization model for
space steel structures design, subjected to constraints of commonlyused design
codes. Inuiguchi and Ramik (2000) reviewed some fuzzy optimization methods and
techniques from a practical point of view.
(2) Implementing fuzzy theory into the optimization algorithms
In this research area, fuzzy theory
is used to adjust or control the parameters of the numerical optimization
algorithm, such that engineering knowledge and human supervision process is
integrated into the optimization process.
Arakawa and Yamakawa (1990)
demonstrated an optimization method using qualitative reasoning, which makes
use of qualitative information to give an approximate direction of the optimum
search. Trabia and Lu (2001) proposed a fuzzy adaptive simplex search
optimization algorithm to minimize a function of n variables. This method uses fuzzy logic to decide the next move
of the simplex.
Hsu et al. (1995a,
b) proposed a fuzzy algorithm for determining the move limits in sequential
linear programming algorithm. Arabshahi et
al. (1996) pointed out that many optimization techniques involve parameters
that are often adapted by the user through trial and error, experience, and
other insight. Instead, they applied neural and fuzzy ideas to adaptively
select these parameters. Mulkay and Rao (1998) proposed a modified sequential
linear programming algorithm using fuzzy heuristics to control the optimization
parameters.
Some researchers also tried to
develop intelligent optimization algorithms based on fuzzy theory to solve optimization
problems. Xiong and Rao [2003] combined fuzzy lformulation with a hybrid
genetic algorithm to solve the mixeddiscrete design optimization problem.
Mukuda et al. (2005) combined a fuzzy
logic controller with a hybrid genetic algorithm and a local search technique
to solve the multiobjective optimization problems.
The research presented in this paper falls
to the second category. In implementing fuzzy theory into the optimization
algorithms, most research focused on implementing optimization process
knowledge into the numerical optimization algorithms using fuzzy theory. Few
researches emphasize on implementing engineering knowledge to develop
optimization algorithm specifically for solving certain type of engineering
optimization problems.
Fuzzy PD controller
Fuzzy control is similar to the classic closedloop
control approaches, but differs in that it substitutes imprecise, symbolic
notions for precise numeric measures. The fuzzy controller takes input values
from the real world. These crisp input values are mapped to the linguistic
values through the membership functions in the fuzzification step. A set of
rules that emulates the decisionmaking process of the human expert controlling
the system is then applied using certain inference mechanism to determine the
output. Finally the output is mapped into crisp control actions required in practical
applications in the defuzzification step.
In the closeloop control system shown in
Figure 1, the measured response of the system process being controlled is fed back
to be compared with a desired response. The control actions generated by the
controller are determined in part by the system response in an attempt to fix this
error. The output of a proportional controller is a control signal u which
is proportional to the error expressed in Equation (1), where K_{p}
is the gain.
_{} (1)
Derivative
control is used to anticipate the future behavior of the error signal by using
corrective actions based on the rate of change in the error
signal. The output of a derivative controller is a
control signal u which is proportional to the derivative of error
expressed in Equation (2), where K_{d} is the gain.
_{} (2)
The control action in a PD controller is in
the form of Equation (3), which combines proportional and derivative control
modes. The PD controller makes a control loop respond faster and with less
overshoot, and is the most popular method of control by a great margin.
_{} (3)
The fuzzy counterpart of the PD controller
also has two inputs: system error e and error change _{}. Fuzzy inference is used to compute the control signal u.
Table 1 shows a typical rule base for a fuzzy PD controller with 25 rules. Five
linguistic terms are used for each variable, NB (Negative Big), NS (Negative
Small), ZE (Zero), PS (Positive Small), and PB (Positive Big). For example, the
5th rule in Table 1 (row 1, column 5) states that, ‘IF e is NB AND _{} is PB, THEN the
control action is NS’.
Table 1. A typical rule base for a fuzzy PD
controller (25 rules)

e

_{}

PB

PS

ZE

NS

NB

PB

PB

PB

ZE

NS

NS

PS

PB

PS

ZE

NS

NS

ZE

PS

PS

ZE

NS

NB

NS

PS

PS

ZE

NS

NB

NB

PS

PS

ZE

NB

NB

The concept of the fuzzy PD
controller optimization engine
As discussed in the previous section, the
iterative optimization process can be analogous to a closeloop control system.
In the authors’ previous work (Hsu et. al, 2005), the fuzzy PD controller was
used as the optimization engine in an optimization process to handle the
specific type of objective function in Equation (4),
min. _{} (4)
that is, to minimize the differences between system outputs y_{i} and the target values Y_{i}. As shown in Figure 3, initial
errors e and change of errors De are input to
the fuzzy PD controller, which generates the changes of design variables Dx for the next iteration. Then, the system inputs are updated (x^{q}^{+1} = x^{q} + Dx^{q}) and the new system process
outputs y^{q+1} are fed back to compare with the set
point Y again.
System outputs y are functions of
design variables x. In engineering design optimization problems, the monotonicity
of design variables in system outputs are often known empirically. This
monotonicity is modeled in the fuzzy PD controller optimization engine in order
to correctly update the design variables in the next iteration. The
optimization process terminates when e and De approach zero, that is, when no change in design variables Dx will be generated by the fuzzy PD controller optimization engine.
Figure 3. Using the fuzzy PD controller in an optimization
process
The objective function in Equation (4) is
rather restricted. In the next section, the application of the fuzzy
PD controller optimization engine is extended to more general engineering
optimization problems with monotonicity and implicit functions.
As discussed earlier, monotonicity between
design variables and the objective and constraint functions prevails in
engineering design optimization problems. Monotonicity is often known through
engineering knowledge or experience without knowing the explicit mathematical
form of the optimization model. The idea of analyzing the monotonicity of
objective function and constraints was first introduced by Wilde (1975) for
checking the model boundedness. Papalambros (1979) then developed Monotonicity
Analysis as a generalized systematic methodology. Monotonicity Analysis seeks
to identify rigorously, in advance to any extensive numerical computation, in which
combinations of inequality constraints can be active. The active constraints
are to be satisfied with strict equality at the optimum.
There are two Monotonicity Principles (Papalambros
and Wilde, 2000). The First Monotonicity Principle (MP1) states that, ‘in a
wellconstrained minimization problem, every (strictly) increasing (decreasing)
variable is bounded below (above) by at least one active constraint’. The
Second Monotonicity Principle (MP2) deals with variables which are not in the
objective function: ‘every monotonic nonobjective variable in a wellbounded
problem is either (a) irrelevant and can be deleted from the problem together
with all constraints in which it occurs, or (b) relevant and bounded by two
active constraints, one from above and one from below’.
Figure 4 shows the conceptual structure of
how to use the output of Monotonicity Analysis to construct the fuzzy PD
controller optimization engine in this research. In general, Monotonicity Analysis can be carried
out by explicit algebraic substitution for the
constraints that are identified active. In this research, Monotonicity Analysis is done by a computer program
MONO developed by Hsu [1993], which implements
Monotonicity Analysis into an automated computerized process.
The input of MONO is a monotonicity table
which only contains the monotonicity signs of the design variables with respect
to the objective function and constraints. The explicit mathematical form of
the optimization model is not required. In MONO, the Monotonicity Principles
are applied to the design variables one by one. When a constraint is identified
as a critical constraint by the Monotonicity Principles, MONO uses “implicit
elimination” to eliminate the critical constraint using only the monotonicity
signs in the monotonicity table. The monotonicity table is then updated
according to the implicit elimination rules, and the size of the table is
reduced. The new table is then passed to the next analysis cycle.
In some cases, the monotonicity of a design
variable with respect to the objective function or certain constraint cannot be
determined after implicit elimination. The monotonicity sign of the variable in
the monotonicity table is marked ‘i’
for ‘indeterminate’. MONO terminates when all design variables have been analyzed,
or the monotonicity table has only ‘i’
in the objective function row and cannot be analyzed further. Details of
implicit elimination are described in Hsu (1993).
Figure 4. The conceptual
structure of using the output of Monotonicity Analysis to construct the fuzzy PD
controller optimization engine
The complete output from MONO includes
rigorous Monotonicity Analysis steps, the reduced monotonicity tables after
each step, and the monotonicity analysis results. After Monotonicity Analysis,
some of the constraints are identified as ‘critical constraints’ by MP1. These
constraints have to be satisfied with strict equality at the optimum. If more
than one constraint can be critical for a design variable x by MP1, these constraints form a ‘conditionally critical set’ (Papalambros
and Wilde, 2000). That is, at least one of the constraints in the set must be
critical at the optimal design point. Some constraints are identified as ‘uncritical’
by MP1, while other constraints are identified as ‘irrelevant’ by MP2. These
constraints can be temporarily eliminated from the optimization model. Finally,
some constraints may remain undecided by either MP1 or MP2.
As shown in Figure 4, the inactive (uncritical
or irrelevant) constraints are temporarily eliminated from the optimization model.
It is necessary to check the inactive constraints again after the optimal
design point is obtained. The critical, conditionally critical and undecided
constraints, as well as the monotonicity signs of the design variables in the
original objective function are implemented into the fuzzy PD controller
optimization engine.
There are 4 possible situations of
implementing the analysis results from MONO into the Fuzzy PD controller
optimization engine:
For a design variable x with only one critical constraint g_{k}, the change of the design
variable Δx in the next iteration is
decided by the current value of g_{k}.
Since the target value for g_{k}
is zero, e and _{} of constraint g_{k} can
be calculated, and are converted into fuzzy membership in the fuzzyfication
step using a ‘quantization table’ defined by the user. The definition of the
quantization table will be described in details in the following section. From
the two inputs, the membership of control action
contributed by constraint g_{k}
can be determined using a rule base similar to Table 1. Finally, Δx in the next iteration is calculated by:
Δx = defuzzification(m_{gk}(x)), (6)
where m_{gk} is the membership of control action contributed by the critical
constraint g_{k}, and ‘defuzzification(
)’ defuzzifies the membership function into crisp value of Δx, again using a quantization table.
For a design variables x with a conditionally critical set, at
least one of the constraints in the set must be critical at the optimal design
point. In this situation, the change of the design variable Δx in the next iteration is decided by
the current values of these constraints. At the current design point, if
constraints g_{1}, g_{2}, …, g_{i} in the conditionally critical set are violated, Δx is decided by
Δx =defuzzication_{} (7)
The ‘max’ and union operators are used to pick the strongest
membership among all violated constraints in order to force the design point
back to the feasible domain. On the other hand, if all constraints are
satisfied, Δx is decided by the
monotonicity sign of x in the
original objective function. In this case, Δx
will be equal to the move limit defined by the user in the proper direction
which reduces the value of the objective function.
For a design variable x whose monotonicity sign is ‘indeterminate’
in the objective function of the final monotonicity table output by MONO, all
constraints in which the variable appears can be active. Thus, the change of the
design variable Δx in the next
iteration is decided by the current values of these constraints in the same
fashion described in (2).
(4) For design variables that do not appear in the objective function
If a design variable does not appear
in the objective function, and is proved to be ‘relevant’ by MP2, all
constraints in which the design variable appears can be active according to MP2.
Thus, if some constraints are violated, Δx
is decided by the current values of the violated constraints in the same
fashion described in Equation (7). On the other hand, if all constraints in
which the nonobjective variable appears are satisfied, the amount of change of
the design variable Δx for the next
iteration is zero to maintain the current value of the design variable.
In the following section, an air tank
design optimization example is used to describe the complete process of
applying the fuzzy PD controller optimization engine on general engineering
optimization problems with monotonicity and implicit constraints.
Monotonicity Analysis using
MONO
Figure 5 and Equation (8) show the optimal
design problem for a cylindrical air tank (Papalambros and Wilde, 2000,
Unklesbay et al., 1972). The
objective is to minimize the quantity of material used, which depends on the inner
radius r, the shell thickness s, the shell length l, and the head thickness h.
The volume of the tank has to be larger than the specified volume (constraint g_{1});
the thicknesses of the head and the wall have to satisfy the ASME code (g_{2},
g_{3}), and there are constraints on the size of the tank (g_{4},
g_{5}, g_{6}).
Figure 5. The air tank
design problem
_{}
_{}
_{}
_{}
_{}
_{} (8)
Table 2 is the corresponding monotonicity
table for Equation (8) which is the only input required for the computer
program MONO. In the air tank design optimization example, MONO concludes that constraints
g_{1}, g_{3}, and g_{2}
are critical to design variables r, s, and h, respectively. The monotonicity sign of design variable l is ‘indeterminate’ in the objective
function of the final monotonicity table in the output from MONO. Note that this
analysis result is obtained using only the monotonicity table in Table 2.
Explicit formulations of the objective function and the constraints are not
required. The complete Monotonicity Analysis of this example using explicit
substitution of the active constraints can be found in (Papalambros and Wilde,
2000).
Table 2. Monotonicity table
of the air tank example

r

s

l

h

F

＋

＋

＋

＋

g_{1}

－

.

－

.

g_{2}

＋

.

.

－.

g_{3}

＋

－

.

.

g_{4}

.

.

－

.

g_{5}

＋

＋

.

.

g_{6}

.

.

＋

.

Four simple generic rules are used to
describe how to adjust the values of the monotonic design variables in order to
find the design point that satisfies the critical (active) constraints with
strict equality. For monotonically increasing variables,
l
Rule I: ‘IF the constraint
function value is positive, THEN the variable must be decreased’.
l
Rule II: ‘IF the constraint
function value is negative, THEN the variable must be increased’.
Similarly, for monotonically decreasing variables,
l
Rule III: ‘IF the constraint
function value is positive, THEN the variable must be increased’.
l
Rule IV: ‘IF the constraint
function value is negative, THEN the variable must be decreased’.
For example, constraint g_{1}
is critical for design variables r,
which is monotonically decreasing with respect to g_{1}. At the
initial design point, if _{} is positive, design
variable r must be increased by Rule III
in the next iteration so that g_{1} will be pushed to zero.
The function value of the critical
constraint (such as g_{1}) is the errors e in the fuzzy PD controller optimization engine. The error change Δe (the change in the constraint function
values) reflects the trend of the constraint function. Considering the error
change, the rules can be extended as follows:
For monotonically increasing variables,
l
Rule Ia: ‘IF the constraint function value is positive and is increasing,
THEN decrease the variable strongly’.
l
Rule Ib: ‘IF the constraint
function value is positive and is decreasing, THEN decrease the variable softly’.
l
Rule IIa: ‘IF the constraint
function value is negative and is increasing, THEN increase the variable softly’.
l
Rule IIb: ‘IF the constraint
function value is negative and is decreasing, THEN increase the variable
strongly’.
For monotonically decreasing variables,
l
Rule IIIa: ‘IF the constraint
function value is positive and is increasing, THEN increase the variable
strongly’.
l
Rule IIIb: ‘IF the constraint
function value is positive and is decreasing, THEN increase the variable softly’.
l
Rule IVa: ‘IF the constraint
function value is negative and is increasing, THEN decrease the variable softly’.
l
Rule IVb: ‘IF the constraint
function value is negative and is decreasing, THEN decrease the variable
strongly’.
Similar to
the typical rule base for a fuzzy PD controller in
Table 1, the rules discussed
above are further interpreted into the fuzzy rule base in Table 3 and 4 using 5
linguistic terms: negative big (NB), negative small
(NS), Zero (ZE), positive small (PS), and positive big (PB).
Table 3. Rule base for the monotonically
increasing variables

e

Δe

PB

PS

ZE

NS

NB

PB

NB

NB

ZE

PS

PS

PS

NB

NS

ZE

PS

PS

ZE

NB

NS

ZE

PS

PB

NS

NS

NS

ZE

PS

PB

NB

NS

NS

ZE

PB

PB

Table 4. Rule base for the monotonically
decreasing variables

e

Δe

PB

PS

ZE

NS

NB

PB

PB

PB

ZE

NS

NS

PS

PB

PS

ZE

NS

NS

ZE

PS

PS

ZE

NS

NB

NS

PS

PS

ZE

NS

NB

NB

PS

PS

ZE

NB

NB

In the air tank
design optimization example, design variables r, s, h have only one critical constraint (g_{1}, g_{3}, and g_{2},
respectively), which is the situation (1) in the 4 possible situations discussed
in Section 3. Therefore, the change of
design variable r, s, h in the next
iteration can be defined as
Δr = defuzzification (m_{g}_{1}(r)),
Δs = defuzzification (m_{g}_{3}(s)),
Δh = defuzzification (m_{g2}(h)), (9)
The
monotonicity sign of design variable l
is ‘indeterminate’ in the objective function of the final monotonicity table
output from MONO, which is the situation (3) discussed in Section 3. The change
of design variable l in the next iteration
is decided by constraints (g_{1},
g_{4} and g_{6}) in which l appears using Equation (7), and can be
written as
Δl=defuzzification_{}, (10)
The inputs of the fuzzy PD controller
optimization engine are the constraint function values (e) and the change of the constraint function values (Δe). Table 5 gives the quantitative
definitions for the error inputs (e:
g_{1}, g_{2}, g_{3},
g_{4} and g_{6}), and Table 6 gives the
quantitative definitions for the error change inputs (Δe: Δg_{1}, Δg_{2}, Δg_{3}, Δg_{4}
and Δg_{6}). As discussed in the previous
section, these quantization tables are used in the fuzzification step to
convert e and Δe into fuzzy membership for the rule base
in Table 3 and 4.
Table 5. The quantization table
of error inputs of the air tank example
Quantized level

g_{1}

g_{2}

g_{3}

g_{4}

g_{6}

2

_{}

_{}

_{}

_{}

_{}

1

_{}/2

_{}/2

_{}/2

_{}/2

_{}/2

0

0

0

0

0

0

1

_{}/2

_{}/2

_{}/2

_{}/2

_{}/2

2

_{}

_{}

_{}

_{}

_{}

Table 6. The quantization
level of error change inputs of the air tank example
Quantized level

Δg_{1}

Δg_{2}

Δg_{3}

Δg_{4}

Δg_{6}

2

Δg_{1}(x_{0})_{max}

Δg_{2}(x_{0})_{max}

Δg_{3}(x_{0})_{max}

Δg_{4}(x_{0})_{max}

Δg_{6}(x_{0})_{max}

1

Δg_{1}(x_{0})_{max}/2

Δg_{2}(x_{0})_{max}/2

Δg_{3}(x_{0})_{max}/2

Δg_{4}(x_{0})_{max}/2

Δg_{6}(x_{0})_{max}/2

0

0

0

0

0

0

1

Δg_{1}(x_{0})_{max}/2

Δg_{2}(x_{0})_{max}/2

Δg_{3}(x_{0})_{max}/2

Δg_{4}(x_{0})_{max}/2

Δg_{6}(x_{0})_{max}/2

2

Δg_{1}(x_{0})_{max}

Δg_{2}(x_{0})_{max}

Δg_{3}(x_{0})_{max}

Δg_{4}(x_{0})_{max}

Δg_{6}(x_{0})_{max}

As shown in Table 5, the values of the
error inputs at different quantized levels are determined by the initial values
of the constraint functions. In this example, the initial values of the
variables are:
h = 10cm, l = 800cm, r = 150cm,
s = 3cm. (11)
The constraint function values can be evaluated at the initial
design point, which give:
_{} = 0.63, _{} = 0.95, _{} = 0.52, _{} = 0.99, _{} = 0.31. (12)
In Table 6, the quantization level value of
error change (Δe: Δg_{1}, Δg_{2}, Δg_{3}, Δg_{4} and Δg_{6}) are determined by
_{} (13)
where x_{0} is a
vector of initial values of the design variable, and Δx_{max} is the vector of ‘move limits’ of the variables.
The ‘±’ sign depends on the monotonicity of the variable to ensure that Δg_{i}(x_{0})_{max} is always positive. If the
variable is monotonically increasing in the constraint function, the sign will
be ‘+’, and vice versa.
The move limit of a design variable is the
maximum amount of change of the variable allowed in one iteration. In this example, the
move limits are:
(Δh)_{max} = 2, (Δl)_{max} = 160, (Δr)_{max} = 30, (Δs)_{max} =
0.6. (14)
Therefore, from Equation (14)
Δg_{1}(r,
l)_{max} = 0.36, Δg_{2}(r, h)_{max} = 0.98, Δg_{3}(r, s)_{max} = 0.24, Δg_{4}(l)_{max}
= 3.1×10^{3}, Δg_{6}(l)_{max} = 0.26. (15)
The outputs from the fuzzy PD optimization
engine are the changes of the design variables in the next iteration. Table 7
shows the quantization level of the outputs, which are also determined by the
move limits defined by the designer. As discussed in the previous section, this
quantization table is used to ‘defuzzify’ the outputs into crisp values of Δh, Δl,
Δr, and Δs for the next iteration (Equation (9) and (10)).
Table 7. The quantization
level of fuzzy outputs in the air tank example
Quantized
level

Δh

Δl

Δr

Δs

2

(Δh)_{max}

(Δl)_{max}

(Δr)_{max}

(Δs)_{max}

1

(Δh)_{max}/2

(Δl)_{max}/2

(Δr)_{max}/2

(Δs)_{max}/2

0

0

0

0

0

1

(Δh)_{max}/2

(Δl)_{max}/2

(Δr)_{max}/2

(Δs)_{max}/2

2

(Δh)_{max}

(Δl)_{max}

(Δr)_{max}

(Δs)_{max}

Using the
initial design point and move limits described above, the
fuzzy PD controller optimization engine terminates after 49 iterations, when the
change in objective function value in consecutive iterations is less than
0.01%, and all constraints are satisfied within a tolerance of 0.01% of the
initial values of the constraints. The numerical results h =13.67cm, l = 610.00cm, r
= 105.18cm, s = 1.01cm are identical to the analytical solution. At
this optimal design point, the values of the active constraints are g_{1} = 4.02×10^{10}, g_{2} = 9.17×10^{5}, g_{3 }= 2.20×10^{10},
and g_{6} = 7.83×10^{10}.
The values of other constraints are g_{4}
= 0.98 and g_{5} = 0.29.
The value of the objective function is 1.38×10^{6}.
Note that in this optimization process, the
function value of each constraint is evaluated 51 times, including two
evaluations to construct Table 5 and Table 6. No sensitivity information is
required. The designers only need to define the initial values and the move
limits of the design variables in the optimization process.
Figure 6 shows the iteration history of the
objective function of the air tank example. The objective function value drops
rapidly in the first several iterations, and shows stable converging trend
afterward. Different initial values and different move limits are also tested
in this example (Tables 8 and 9). As expected, the number of iterations
increases when the starting design point is farther from the optimal design
point. In some tests, larger move limits help to reduce the number of iterations,
while in other tests, larger move limits cause overshoot and the number of
iterations increases. In all 19 tests shown in Table 8 and 9, the fuzzy PD
controller optimization engine appears to be robust. Same numerical solutions are
obtained though the number of iterations required varies. The iteration
histories of all 19 tests also show converging trend similar to that in Figure
6. Table 8 also compares the number of iterations required for different
termination criteria. Note that in these tests, 1/3 to 1/2 of the iterations
are used to drive the optimal solution from a 0.1% tolerance to a 0.01%
tolerance.
Figure 6. The iteration
history of the objective function of the air tank example
Table 8. Using different initial values in the air
tank example

r (cm)

s (cm)

h (cm)

l (cm)

Iteration (0.01%)

Iteration (0.1%)

Original

150

3

10

800

49

34

Test 1

200

3

10

800

48

21

Test 2

50

3

10

800

51

38

Test 3

150

5

10

800

49

34

Test 4

150

0.1

10

800

138

81

Test 5

150

3

15

800

17

13

Test 6

150

3

5

800

154

104

Test 7

150

3

10

1000

63

45

Test 8

200

5

15

1000

44

29

Test 9

50

0.1

5

100

214

135

Optimal

105.0

1.0

13.6

610.0



Table 9. Using different move limits in the air
tank example
Variables

r (cm)

s (cm)

h (cm)

l (cm)

Iteration


150

3

10

500

49

Move limits

Δr (cm)

Δs (cm)

Δh(cm)

Δl (cm)


Original

30

0.6

2

160

49

Test 1

15

0.6

2

160

34

Test 2

45

0.6

2

160

52

Test 3

30

0.3

2

160

49

Test 4

30

0.9

2

160

49

Test 5

30

0.6

1

160

107

Test 6

30

0.6

3

160

22

Test 7

30

0.6

2

80

56

Test 8

30

0.6

2

200

49

Test 9

15

0.3

1

80

102

Test 10

45

0.9

3

200

32

The fuzzy PD controller optimization engine
has been tested in various engineering optimization problems with implicit
functions and monotonicity. Three representative design examples are described
in the following section to demonstrate the practicality of this approach.
5.
Design Examples
A tension/compression spring
design optimization problem
Figure 7 and Equation (16) show an example
in which the weight of a tension/compression spring is to be minimized, subject
to constraints on minimum deflection (g_{1}), shear (g_{2}), surge frequency (g_{3}) and limits on outside diameter (g_{4}) (Coello and Monts, 2002; Arora,
1989; Belegundu and Arora, 1985). The design variables are the mean coil
diameter D, the wire diameter d and the number of active coils N.
Figure 7. The tension/compression spring design
optimization problem
_{},
_{},
_{},
_{}. (16)
Table 10 shows the monotonicity table of
the spring design example. After Monotonicity Analysis by the computer program
MONO, it is concluded that design variable D
has only one critical constraint g_{1.} One of the constraints in the conditionally critical set g_{2} and g_{3} must be critical for design variable d. The monotonicity sign of design variable N is ‘indeterminate’ in the objective function at the end of
Monotonicity Analysis.
Table 10. Monotonicity
table of the spring design example

d

D

N

f

+

+

+

g_{1}

+

－

－

g_{2}

－

+

.

g_{3}

－

+

+

g_{4}

+

+

.

In this example, the initial values of the
design variables are:
d = 0.1, D
= 0.25, N = 13, (17)
The move limits are:
(Δd)_{max} = 0.001, (ΔD)_{max} = 0.01, (ΔN)_{max} = 0.1. (18)
Similar to Tables 57, these userdefined values are used to
determine the quantization levels of the error inputs, change of error inputs,
and outputs in this example.
The fuzzy PD controller optimization engine
terminates after 225 iterations, when the change in objective function value in
consecutive iterations is less than 0.01%, and all constraints are satisfied
within a tolerance of 0.01% of the initial values of the constraints. Table 11
shows the comparison of the optimization results by the fuzzy PD controller
optimization engine with those obtained in the literature. Note that only
constraints g_{1} and g_{2} are active at the optimum
design point, though there are 3 design variables. Figure
8 shows the iteration histories of the objective function. In this process, the
function value of each constraint is evaluated 227 times, and no sensitivity
information is required.
The purpose of the comparison in Table 11 is
to confirm the quality of the solution obtained by the fuzzy PD controller
optimization engine. The information and computational cost required in one
iteration are different for the 4 algorithms listed in Table 11. Therefore the
number of iterations of the algorithms in literature cannot be compared
directly.
Table 11. Comparison of the results for the spring
design example

Fuzzy PD

Coello and Monts (2002)

Arora (1989)

Belegundu (1982)

Objective function value

0.0126503

0.0126810

0.0127303

0.0128334

Iteration

225







d

0.052362

0.051989

0.053396

0.050000

D

0.373153

0.363965

0.399180

0.315900

N

10.36486

10.89052

9.185400

14.25000

g_{1}

0.001987

0.000013

0.000019

0.000014

g_{2}

0.000084

0.000021

0.000018

0.003782

g_{3}

0.803753

4.061338

4.123832

3.938302

g_{4}

0.716237

0.722698

0.698283

0.756067

Figure 8. The iteration history of objective
function of the spring design example
Figure 9 shows an example for designing a
uniform column of tubular section to carry a compressive load P = 2500 kgf for
minimum cost (Rao, 1996). Equation (19) shows the optimization model of this
problem. The column is made up of a material that has a yield stress (s_{y}) of 500 kgf/cm^{2},
modulus of elasticity (E) of 0.85×106
kgf/cm^{2}, and density (r) of 0.0025 kgf/cm^{3}. The length of the
column (L) is 250 cm. The stress included in the column
should be less than the bucking stress (constraint g_{1}) and the yield stress (constraint
g_{2}). The mean diameter of the column is restricted between 2 and 14 cm (constraint g_{3} and g_{4}), and columns with thickness
outside the range 0.2 to 0.8 cm
are not available in the market (constraint g_{5} and g_{6}). The cost of the column includes material and construction costs
and can be taken as 9.82dt+2d, where d is the mean diameter of the column in centimeters, and t is tube thickness.
Figure 9. Tubular column under compression design
problem
_{}
_{}
_{}
_{}
_{}
_{} (19)
After Monotonicity Analysis by the computer
program MONO, it is concluded that there are two conditionally critical sets.
One of the constraints in the conditionally critical set {g_{1}, g_{2}, g_{3}} must be critical for design
variable d, and one of the
constraints in the other conditionally critical set {g_{1}, g_{2}, g_{5}} must be critical for design
variable t.
In this example, the initial values of the
design variables are:
d = 14.0 cm, t = 0.8 cm (20)
The values of the move limits are:
(Δd)_{max} = 1.0, (Δt)_{max} = 0.1. (21)
Using the same termination criteria of the
previous example, the fuzzy PD controller optimization engine terminates after 53
iterations. Table 12 compares the results obtained from the fuzzy PD controller
optimization engine with that from the literature. Figure 10 shows the
iteration histories of the objective function.
Table 12. Comparison of the result for the tubular
column design problem

Fuzzy PD

Rao (1996)

Objective Function

25.5316

26.5323

Iteration

53


d

5.4507

5.4400

t

0.2920

0.2930

g_{1}

7.8×10^{5}

0.8579

g_{2}

7.8×10^{5}

0.9785

g_{3}

0.6331

0.8571

g_{4}

0.6107

0.0000

g_{5}

0.3151

0.7500

g_{6}

0.6350

0.0000

Figure 10. The iteration histories of the
objective function of the tubular column example
The design of the speed reducer (Golinski,
1973), shown in Figure 11, is considered with the face width (b), module of teeth (m), number of teeth on pinion (z), length of shaft 1 between bearings (l_{1}), length of shaft 2 between bearings (l_{2}), diameter of shaft 1 (d_{1}), and diameter of shaft 2 (d_{2}). The objective is to minimize the total weight of the speed
reducer. The constraints include limitations on the bending stress of gear
teeth, surface stress, transverse deflections of shafts 1 and 2 due to
transmitted force, and stresses in shafts 1 and 2. The design optimization
model can be summarized in Equation (22).
Figure 11. Speed reducer design problem
_{}
_{}
_{}
_{}
_{}
_{},
_{}
_{}
_{},
_{}
_{}
_{}
_{}
_{}
_{},
_{},
_{},
_{},
_{},
_{},
_{},
_{},
_{},
_{},
_{},
_{}. (22)
There are 7 design variables and 25
constraints in this model. After Monotonicity Analysis by the computer program
MONO, it is concluded that there are 7 conditionally critical sets for the 7
design variables in this problem.
In this example, the initial values of the
design variables are:
b = 3.6, m = 0.8, z = 28, l_{1} = 8.3, l_{2} = 8.3, b_{1} = 3.9, b_{2}, = 5.5. (23)
The values of the move limits are:
(Δb)_{max} = 0.1, (Δm)_{max} = 0.01, (Δz)_{max} = 1.0, (Δl_{1})_{max} =
0.1, (Δl_{2})_{max} =
0.01, (Δb_{1})_{max} =
0.01, (Δb_{2})_{max} = 0.01. (24)
Following the same process, the fuzzy PD
controller optimization engine terminates after 302 iterations. Table 13 compares
the results obtained from the fuzzy PD controller optimization engine with that
from the literature. Figure 12 shows the iteration history of the objective
function.
Table 13. Comparison of the results for the speed
reducer example

Fuzzy PD

Golinski (1973)

Objective function value

3007.8

2985.2

Iteration

302



x_{1}

3.5197

3.5

x_{2}

0.7039

0.7

x_{3}

17.3831

17.0

x_{4}

7.3000

7.3

x_{5}

7.7152

7.3

x_{6}

3.3498

3.35

x_{7}

5.2866

5.29

g_{1}

0.1095

0.0739

g_{2}

0.2458

0.1980

g_{3}

0.5127

0.4990

g_{4}

0.9073

0.9194

g_{5}

0.0000

0.0001

g_{6}

0.0000

0.0020

g_{7}

0.6941

0.7025

g_{8}

0.0000

0.0000

g_{9}

0.5833

0.5833

g_{10}

0.2613

0.2571

g_{11}

0.0223

0.0278

g_{12}

0.0056

0.0000

g_{13}

0.1201

0.1250

g_{14}

0.0220

0.0000

g_{15}

0.3792

0.3929

g_{16}

0.0000

0.0000

g_{17}

0.1205

0.1205

g_{18}

0.0538

0.0000

g_{19}

0.0705

0.1205

g_{20}

0.1343

0.1343

g_{21}

0.1411

0.1410

g_{22}

0.0542

0.0548

g_{23}

0.0388

0.0382

g_{24}

0.0514

0.0514

g_{25}

0.0000

0.0574

Figure 13. The iteration history of objective
function of the speed reducer example
6.
Conclusions and discussion
In realworld engineering design problems,
engineering heuristics often relate to the monotonic behavior of certain design
variables. Indeed, monotonicity between the design variables and the objective
and constraint functions prevails in engineering design optimization problems. Monotonicity
Analysis can generate valuable qualitative information for this type of
optimization models, such as the activity of the constraints at the optimum
design point. However, numerical optimal solution cannot be obtained by
Monotonicity Analysis alone.
The fuzzy PD controller optimization engine
developed in this research utilizes the monotonicity of the design variables
and the activity of the constraints concluded from Monotonicity Analysis in the
optimization process to obtain the numerical optimum solution. The basic
structure of this optimization process is actually very similar to the
traditional line search algorithms. In a numerical line search algorithm, the
search direction and step length are decided by numerical information, such as
the gradients of the objective function and constraints. In the optimization
process presented here, the search direction and step length are generated by
the fuzzy PD controller optimization engine using the information on the
monotonicity of the design variables and the activity of the constraints, as
well as the initial values and move limits of the design variables defined by
the user. In the optimization process, the objective and constraint functions
only need to be evaluated once in each iteration. No sensitivity information is
required. This characteristic makes the optimization algorithm especially
suitable for engineering optimization problems with implicit constraints. The
fuzzy PD controller optimization engine appears to be robust in the various
design examples tested in this research.
In this research, the optimization process
is analogous to a close loop control system, and the fuzzy PD controller
optimization engine was developed following the general concept of developing a
fuzzy PD controller for a close loop control system. In the future development,
concepts and methods commonly used for improving fuzzy PD controllers, for
example, how to speed up the response, reduce the overshoot, and improve the
transient response, etc., can also be tested to further improve the performance
of the fuzzy PD controller optimization engine. Moreover, many design variables
are discrete in nature in engineering optimization problems. This should also
be considered in the future development of the fuzzy PD controller optimization
engine.
References
Arabshahi, P., Choi, J. J., Marks, R. J.
II, and Caudell, T. P., Fuzzy parameter adaptation in optimization: some neural
net training examples, IEEE Computational
Science & Engineering, 1996, 3(1),
5767.
Arakawa, M. and Yamakawa, H., Study on the
optimum design applying qualitative reasoning, Transactions of the Japan
Society of Mechanical Engineers, Part C, 1990, 56(522), 398403.
Arora, J. S. Introduction to Optimum Design, 1989 (McGrawHill: New York).
Bellman, R.E. and Zadeh, L.A., Decisionmaking in a fuzzy environment,
Management Science, 1970, 17(4), 141164.
Belegundu, A. D., Arora, J. S, Study of
mathematical programming methods for structural optimization. Part II:
Numerical results, International Journal
for Numerical Methods in Engineering, 1985, 21(9), 16011623.
Coello, C. A. C., and Montes, E. M.,
Constrainthandling in genetic algorithm through the use of dominancebased
tournament selection, Advanced
Engineering Informatics, 2002, 16(3),
193203.
Golinski, J. An adaptive optimization
system applied to machine synthesis, Mechanism
and Machine Synthesis, 1973, 8(4),
419436.
Guan, X., Liu, W.H., and Papalexopoulos,
A.D., Application of a fuzzy set method in an optimal power flow, Electric Power Systems Research, 1995, 34(1), 1118.
Hsu, Y. L., 1993, Notes on Interpreting
Monotonicity Analysis using Karush Kuhn Tucker Conditions, and MONO  A Logic
Program for Monotonicity Analysis, American Society of Mechanical Engineers,
Design Engineering Division (Publication) DE, 65(2), Advances in Design Automation, 1993, 243251.
Hsu, Y. L., Lin, Y. F. and Guo, Y. S., Fuzzy
sequential linear programming algorithm for engineering design optimization, American
Society of Mechanical Engineers, Design Engineering Division (Publication) DE,
82(1), Advances in Design Automation, 455462.
Hsu, Y. L., Lin, Y. F. and Sun, T. L.,
Engineering design optimization as a fuzzy control process, Proceedings of
1995 IEEE International Conference on Fuzzy Systems, 1995, 4, 20012008.
Hsu, Y. L., Liu, T. C., Liu, TsoLung, A
Fuzzy Proportional Derivative Controller for Engineering Optimization Problems
Using Optimality Criteria Approach, Engineering
Optimization, 2005, 37(6),
649661.
Inuiguchi, M., and Ramil, J., Possibilistic
linear programming: a brief review of fuzzy mathematical programming and a comparison
with stochastic programming in portfolio selection problem, Fuzzy Sets and Systems, 2000, 111(1), 328.
Mukuda, M., and Tsujimura, Y., and Gen, M.,
Optimization of multiobjective system reliability design using FLC controller
GA, Transactions of the Institute of
Electrical Engineers of Japan, Part C,
2005, 125c(4), 623630.
Mulkay, E. L. and Rao, S. S., Fuzzy
heuristics for sequential linear programming, Journal of Mechanical Design, Transactions of the ASME, 1998, 120(1), 1723.
Papalambros, P., Monotonicity Analysis in
Engineering Design Optimization, PhD thesis, Stanford University,
1979.
Papalambros, P., and Wilde D. J., Principles
of Optimal Design – Modeling and Computation, 2nd ed., 2000 (Cambridge University
Press).
Rao, S.S., Sundararaju, K., Prakash, B.G.,
and Balakrishna, C., Fuzzy goal programming approach for structural
optimization, AIAA Journal, 1992, 30(5), 14251432.
Sarma, K.C. and Adeli, H., Fuzzy discrete
multicriteria cost optimization of steel structures, Journal of Structural Engineering, 2000, 126(11), 13391347.
Trabia, M.B. and Lu, X.B., A fuzzy adaptive
simplex search optimization algorithm, Journal
of Mechanical Design, Transactions of the ASME, 2001, 123(1), 1723.
Unklesbay, K., Staats, G.E., and Creighton,
D.L., Optimal design of pressure vessels, Soviet Atomic Energy (English
translation of Atomnaya Energiya), Sep 17 21, 1972, 10p.
Wilde, D. J., Monotonicity and Dominance in
Optimal Hydraulic Cylinder Design, Journal
of Engineering for Industry, Transactions of the ASME, 1975, 97(4), 13901394.
Xiong Y., and Rao, S.S., Fuzzy nonlinear
programming for mixeddiscrete design optimization through hybrid genetic
algorithm, Fuzzy Sets and Systems, 2003,
146(2), 167186.
Xiong Y., and Rao, S.S., A fuzzy dynamic
programming approach for the mixeddiscrete optimization of mechanical systems,
Journal of Mechanical Design, Transactions of the ASME, 2005, 127(6), 10881099.
Zadeh, L.A., Fuzzy sets, Information and Control, 1965, 8,
338353.