A hybrid cuckoo search and genetic algorithm for reliability–redundancy allocation problems

Computers & Industrial Engineering xxx (2013) xxx–xxx

Contents lists available at ScienceDirect

Computers & Industrial Engineering

journal homepage: www.elsevier .com/ locate/caie

A hybrid cuckoo search and genetic algorithm for reliability–redundancyallocation problems q

0360-8352/$ - see front matter � 2013 Elsevier Ltd. All rights reserved.http://dx.doi.org/10.1016/j.cie.2013.08.003

q This manuscript was processed by Area Editor H. Brian Hwarng, Ph.D.⇑ Corresponding author. Tel.: +60 3 55146203; fax: +60 3 55146207.

E-mail addresses: [email protected] (G. Kanagaraj),[email protected] (S.G. Ponnambalam), [email protected](N. Jawahar).

1 Tel.: +60 3 55146203; fax: +60 3 55146207.

Please cite this article in press as: Kanagaraj, G., et al. A hybrid cuckoo search and genetic algorithm for reliability–redundancy allocation problemputers & Industrial Engineering (2013), http://dx.doi.org/10.1016/j.cie.2013.08.003

G. Kanagaraj a,1, S.G. Ponnambalam a,⇑, N. Jawahar b

a School of Engineering, Monash University, Sunway Campus, 46150 Bandar Sunway, Malaysiab Department of Mechanical Engineering, Thiagarajar College of Engineering, Madurai 625 015, India

a r t i c l e i n f o a b s t r a c t

Article history:Received 8 August 2012Received in revised form 15 May 2013Accepted 6 August 2013Available online xxxx

Keywords:Reliability and redundancy allocationCuckoo searchGenetic algorithmHybrid evolutionary algorithm

Solving reliability and redundancy allocation problems via meta-heuristic algorithms has attractedincreasing attention in recent years. In this study, a recently developed meta-heuristic optimization algo-rithm cuckoo search (CS) is hybridized with well-known genetic algorithm (GA) called CS–GA is proposedto solve the reliability and redundancy allocation problem. By embedding the genetic operators in stan-dard CS, the balance between the exploration and exploitation ability further improved and more searchspace are observed during the algorithms’ performance. The computational results carried out on fourclassical reliability–redundancy allocation problems taken from the literature confirm the validity ofthe proposed algorithm. Experimental results are presented and compared with the best known solu-tions. The comparison results with other evolutionary optimization methods demonstrate that the pro-posed CS–GA algorithm proves to be extremely effective and efficient at locating optimal solutions.

� 2013 Elsevier Ltd. All rights reserved.

1. Introduction

It is increasingly necessary to design reliable systems as there isa great demand for products that offer quality and safety. The opti-mal reliability design is to determine a system structure which hasthe highest reliability for the minimum cost of manufacturing.Generally two major ways have been used to achieve higher sys-tem reliability. The first way is by increasing the reliability of sys-tem components, and the second way is by using redundantcomponents in various subsystems. In the first way, the systemreliability can be improved to some degree, but the required reli-ability enhancement may be never attainable even though themost currently reliable components are used. Using the secondway is to choose the optimal component combination and redun-dancy levels; the system reliability can be enhanced, but the cost,weight, volume, etc. will be increased as well. Besides the abovetwo ways, the conjunction of the two approaches and reassign-ment of interchangeable components are alternative feasible waysto enhance the system reliability. Such problems of maximizingsystem reliability through redundancy and component reliabilitychoices are called the ‘‘reliability–redundancy allocation problem’’(RRAP). Various complex systems come out with the development

of industrial engineering, and the reliability designing of these sys-tems are very important. The increasing need for highly reliablesystems further demands the study of reliability optimization.Thus, more accurate and efficient methods are needed in findingthe optimal system reliability, otherwise, the safety and efficiencyof a system cannot be guaranteed (Wu, Gao, et al., 2011).

In order to cope with optimization problems arising in systemreliability, important contributions have been made since 1970.Tillman, Hwang, et al. (1977) and Gopal, Aggarwal, et al.(1978) applied heuristic approaches to solve the reliability prob-lems. Kuo, Lin, et al. (1987) proposed a model using Lagrangemultipliers with branch-and-bound method for a series systemwith five subsystems. Chi and Kuo (1990) formulated mixedinteger nonlinear programming problems for RRAP in softwaresystems and systems involving both software and hardware.The interactive heuristic method and surrogate dual approachare used to solve this mixed-integer reliability design problemsby Xu, Kuo, et al. (1990) and Hikita, Nakagawa, et al. (1992),respectively. However, most of those require derivatives for allnonlinear constraint functions that makes the exact optimalsolutions to the RRAP be not derived easily because of the highlycomputational complexity. For overcome this difficulty, Yokota,Gen, et al. (1995) and Hsieh, Chen, et al. (1998) applied geneticalgorithms (GA) to solve these mixed-integer reliability optimi-zation problems. As they have reported, the solutions obtainedby GAs can solve these problems efficiently and effectively.Gen and Yun (2006) developed a soft computing approach forsolving various reliability optimization problems. This methodcombined rough search techniques and local search techniques,

s. Com-

http://dx.doi.org/10.1016/j.cie.2013.08.003

mailto:[email protected]




http://www.sciencedirect.com/science/journal/03608352

http://www.elsevier.com/locate/caie


Fig. 1. Series system.

2 G. Kanagaraj et al. / Computers & Industrial Engineering xxx (2013) xxx–xxx

which can prevent the premature convergence situation of itssolution. Coelho (2009) developed an efficient particle swarmoptimization algorithm based on Gaussian distribution and cha-otic sequence to solve the RRAPs. Wu et al. (2011) proposedan improved version of particle swarm optimization algorithmfor reliability problems. Kanagaraj and Jawahar (2011) solvedthe RRAPs based on total cost of ownership approach. Kuo andPrasad (2000) presented a good comprehensive survey of previ-ous works. Kuo and Wan (2007) reviewed recent advances inoptimal reliability allocation problem and summarized severaltechniques.

The major focus of recent work in the redundancy allocationproblems is on the development of heuristic/meta-heuristic algo-rithms for solving the redundancy allocation problems. Metaheu-ristic algorithms are often nature-inspired, and they are nowamong the most widely used algorithms for optimization. Theyhave many advantages over conventional algorithms (Yang,2010). Recently, many metaheuristics, such as Immune Algorithm(Chen, 2006), Simulated Annealing Algorithm (Kim, Bae, et al.,2006), Particle Swarm Optimization (Coelho, 2009; Garg & Sharma,2013; Wu et al., 2011), Harmony Search Algorithm (Zou, Gao, et al.,2010; Zou et al., 2011), Artificial Bee Colony Algorithm (Yeh &Hsieh, 2011), Cuckoo Search Algorithm (Valian & Valian, 2012)have been employed in RRAPs. Cuckoo search (CS) is one of themodern metaheuristc algorithm developed by Yang and Deb in2009, and the same has been found to be efficient in solving globaloptimization problems. CS algorithm has attracted more recentattention than most other heuristic/metaheuristic methods in var-ious field of optimization, including the reliability problems.

Nowadays, new algorithms are emerging by combining two orthree algorithms called hybrid algorithms, which uses some com-bination of deterministic and randomness, or combines one algo-rithm with another so as to design more efficient algorithms. Forexample, Genetic algorithm can be hybridized with many algo-rithms such as particle swarm optimization; more specifically,may involve the use of generic operators to modify some compo-nents of another algorithm (Yang & Koziel, 2011). Coello and Cortés(2004) proposed a hybrid between a Genetic algorithm and Artifi-cial Immune System for solving constrained optimization prob-lems. Bernardino and Barbosa (2006) proposed a GA hybridizedwith Artificial Immune System inspired on the clonal selectionprinciple and it is embedded into a standard GA search engine inorder to help moving the population into the feasible region. Mori,de Castro, et al. (2007) developed hybrid algorithm based on sim-ulated annealing and genetic algorithm to reliability–redundancyoptimization. Zhao, Wang, et al. (2012) developed a hybrid GA withflexible allowance technique for solving constrained engineeringdesign optimization problems. Layeb (2011) introduced a newhybridization between quantum inspired and cuckoo search forthe knapsack problem. This hybrid algorithm achieves better bal-ance between exploration and exploitation and experimental re-sults shows convincing results. A new hybrid algorithm of cuckoosearch and Particle Swarm Intelligence (PSO) was introduced byWang and Cai (2009) to remedy the defect of PSO.

In this paper, we have tried to get closer to cuckoo birds real lifeGA’s operators such as selection, crossover and mutation addedinto the standard CS algorithm, a hybrid cuckoo search and geneticalgorithm (CS–GA) is developed. Four mixed-integer reliabilityproblems with multiple nonlinear constraints are considered andsolved by proposed CS–GA approach. The computational resultsshow that the proposed CS–GA algorithm has faster convergence,higher computational precision, and is more effective for solvingRRAPs.

This remaining content of this paper is organized as follows. InSection 2, RRAP is formulated and four bench mark reliability–redundancy allocation problems are briefly explained; in Section 3,

Please cite this article in press as: Kanagaraj, G., et al. A hybrid cuckoo search aputers & Industrial Engineering (2013), http://dx.doi.org/10.1016/j.cie.2013.08.0

the proposed hybrid CS–GA is described; in Section 4, the compu-tational results are discussed and compared with previous meth-ods. Finally, conclusions are summarized in Section 5.

2. Description of reliability–redundancy allocation problems

The goal of reliability engineering is to improve the reliabilitysystem. The reliability–redundancy optimizations are useful forsystem designs that are largely assembled and manufacturedusing off-the-shelf components, and also, have high reliabilityrequirements (Kulturel-Konak, Smith, et al., 2003). Reliabilityoptimization problems are categorized into three typical prob-lems according to the types of their decision variables: reliabilityallocation, redundancy allocation and reliability–redundancyallocation.

In this work, the reliability–redundancy allocation problem ofmaximizing the system reliability subject to multiple nonlinearconstraints can be stated as a nonlinearly mixed-integer program-ming model in general form as follows:

Maximize Rs ¼ f ðr;xÞ ð1Þ

Subject to gðr;xÞ 6 b

0 6 ri 6 1 xi 2 positive integer; 1 6 i 6 n

where Rs is the reliability of system, f(�) is the objective function forthe overall system reliability;g(�) is the set of constraint functionsusually associated with system weight, volume and cost, and b isthe resource limitation; r = (r1,r2,r3, . . . , rn) is the vector of the com-ponent reliabilities for the system, x = (x1,x2,x3, . . . ,xn) is the vectorof the redundancy allocation for the system; ri and xi are the reli-ability and the number of components in the ith subsystem respec-tively; and n is the number of subsystems in the system. Ifcomponent reliabilities, ri’s for all i, are the only variables, the prob-lem is referred to as a reliability allocation problem; if the numberof redundancies, xi’s for all i, is the only variable, the problem be-comes a redundancy allocation problem; if the decision variablesof the problem include both the component reliabilities and redun-dancies, the problem is known as a reliability–redundancy alloca-tion problem (RRAP). The problem belongs to the category ofconstrained nonlinear mixed-integer optimization problems. Thegoal is to determine the number of component and the components’reliability in each system so as to maximize the overall system reli-ability. Some typical examples of RRAP include the series system,complex (bridge) system, series–parallel system and over speedproduction system. These examples were used by many researchersas a bench mark problems to evaluate their optimization ap-proaches. The benchmark of reliability–redundancy optimizationproblems evaluated in this paper is formulated, which are outlinedbelow.

2.1. P1. Series system

The series system configuration is the simplest and perhaps oneof the most common structures. The block diagram in Fig. 1 repre-sents a series system consisting of five subsystems. For optimizingthe system reliability the number of redundant components ineach subsystem and the corresponding component reliabilitiesare to be decided simultaneously.

The mathematical formulation of series system is as follows:

nd genetic algorithm for reliability–redundancy allocation problems. Com-03


Fig. 2. Complex (bridge system).

G. Kanagaraj et al. / Computers & Industrial Engineering xxx (2013) xxx–xxx 3

Max f ðr;xÞ ¼Yn

i¼1

RiðxiÞ ð2Þ

Subject to

g1ðr;xÞ ¼Xn

i¼1

wiv2i x2

i 6 V ð3Þ

g2ðr;xÞ ¼Xn

i¼1

ai�1000lnðriÞ

� �bi

½xi þ expðxi=4Þ� 6 C ð4Þ

g3ðr;xÞ ¼Xn

i¼1

wi½xi expðxi=4Þ� 6W ð5Þ


Here, n is the number of subsystems in the system; xi is the numberof components in subsystem i, (1 6 i 6 n); ri is the reliability of eachcomponent in subsystem i, qi ¼ 1� rxi

i is the failure probability ofeach component in subsystem i; RiðxiÞ ¼ 1� qxi

i is the reliability ofsubsystem i, f(r,x) is the system reliability. wi is the weight of eachcomponent in subsystem i; vi is the volume of each component insubsystem i, and ci is the cost of each component in subsystem i;Furthermore, V is the upper limit on the sum of the subsystems’products of volume and weight; C is the upper limit on the cost ofthe system; W is the upper limit on the weight of the system. Theparameters ai and bi are physical features of system components.Constraint g1(r,x) is a combination of weight, redundancy allocationand volume. g2(r,x) is a cost constraint, while g3(r,x) is a weightconstraint. It may be note that the second constraint involves bothinteger and continuous variables. The input parameters of the seriessystem are given in Table 1.

2.2. P2. Complex (bridge) system

Fig. 2 shows the complex (bridge) system with five subsystems.The problem formulation is as follows:

Max f ðr;xÞ ¼ R1R2 þ R3R4 þ R1R4R5 þ R2R3R5 � R1R2R3R4

� R1R2R3R5 � R1R2R4R5 � R1R3R4R5

� R2R3R4R5 þ 2R1R2R3R4R5 ð6Þ

Subject to g1ðr;xÞ; g2ðr;xÞ and g3ðr;xÞ


The complex (bridge) system has three nonlinear constraints,which are the same as those of the series system. Also, the inputparameters of the complex (bridge) system are the same as thoseof the series system listed in Table 1.

Table 1Data of the problems (P1, P2, P3 and P4).

Parameters P1, P2 P3 P4

105ai (2.330, 1.450, 0.541,8.050, 1.950)

(2.500, 1.450, 0.541,0.541, 2.100)

(1, 2.3, 0.3,2.3)

wiv2i

(1, 2, 3, 4, 2) (2, 4, 5, 8, 4) –

wi (7, 8, 8, 6, 9) (3.5, 4.0, 4.0, 3.5, 4.5) (6, 6, 8, 7)bi (1.5, 1.5, 1.5, 1.5, 1.5) (1.5, 1.5, 1.5, 1.5, 1.5) (1.5, 1.5,

1.5, 1.5)vi – – (1, 2, 3, 2)V 110 180 250C 175 175 400W 200 100 500T - - 1000 h


2.3. P3. Series–parallel system

A series–parallel system with five subsystems is shown in Fig. 3.This problem is also a nonlinear mixed-integer programming prob-lem with the same nonlinear constraints as those of the series sys-tem, but it has different input parameters, given in Table 1.

The problem formulation is as follows:

Max f ðr;xÞ ¼ 1� ð1� R1R2Þð1� ð1� R3Þð1� R4ÞR5Þ ð7Þ

Subject to g1ðr; xÞ; g2ðr; xÞ and g3ðr;xÞ


2.4. P4. Overspeed protection system

Fig. 4 shows an overspeed protection system of a gas turbine.Overspeed detection is continuously provided by the electricaland mechanical systems. When an overspeed occurs, it is necessaryto cut off the fuel supply. For this purpose, four control valves (V1–V4) must close. The control system is modeled as a 4-stage seriessystem. The objective is to determine an optimal level of ri and xi

at each stage i such that the system reliability is maximized.This problem is formulated as the following mixed-integer non-

linear programming problem, i.e., the problem can be stated asfollows:

Fig. 3. Series parallel system.

Mec

han

ical

an

d E

lect

rica

l ove

r sp

eed

det

ecti

on

Gas Turbine

Air Fuel Mixture

V1 V3 V4V2

Fig. 4. Overspeed protection system.




Max f ðr;xÞ ¼Yn

i¼1

½1� ð1� riÞxi � ð8Þ

Subject to

g1ðr;xÞ ¼Xn

i¼1

v ix2i 6 V ð9Þ

g2ðr;xÞ ¼Xn

i¼1

CðriÞ½xi þ expðxi=4Þ� 6 C ð10Þ

g3ðr;xÞ ¼Xn

i¼1

wi½xi expðxi=4Þ� 6W ð11Þ

0:5 6 ri 6 1� 10�6; 1:0 6 xi 6 10; xi 2 positive integer;ri 2 real number

where ri is reliability of component in stage i, and xi is the number ofredundant components in stage i; vi is the volume of each compo-nent at stage i; wi is the weight of each components at the stage i.The exp(xi/4) accounts for the interconnecting hardware. The term

CðriÞ ¼ ai � TlnðriÞ

� �biis the cost of each component with reliability ri

at stage i; ai and bi are constants representing the physical charac-teristics of each component at stage i; T is the operating time duringwhich the component must not fail. The input parameters definingthe overspeed protection system are given in Table 1.

3. Proposed hybrid cuckoo search and genetic algorithm forRRAP

This section describes the proposed hybrid cuckoo search andgenetic algorithm. First, a brief overview of cuckoo search and ge-netic algorithm is provided, and finally the procedures of the pro-posed CS–GA are presented.

3.1. Cuckoo search algorithm

Cuckoo search (CS) algorithm is one of the nature-inspiredpopulation based stochastic global search meta-heuristic algo-rithm, developed by Yang and Deb in 2009. It is based on theobligate brood-parasitic behavior of some cuckoo species in com-bination with the Lévy flight behavior of some birds and fruitflies. These species lay their eggs in the nests of other host birds(almost other species) with amazing abilities such as selectingthe recently spawned nests, and removing existing eggs that in-crease hatching probability of their eggs. On the other hand,some of the host birds are able to combat this parasitic behaviorof cuckoos, and throw out the discovered alien eggs or buildtheir new nests in new location. This cuckoo breeding analogyis used for developing new optimization algorithm. Nature sys-tems are complex and thus, they cannot be modeled exactlyby computer algorithm in its basic form. Simplification of naturalsystem is necessary for successful implementation in computeralgorithm. Yang and Deb simplified cuckoo reproduction processby three idealized rules:

1. Each cuckoo lays one egg at a time, and dumps it in a randomlychosen nest.

2. The nests with high quality of eggs will carry over to the nextgeneration.

3. The number of available host nests is fixed, and a host can dis-cover an alien egg with a probability pa e [0,1]. In this case, thehost bird can either throw the egg away or abandon the nest soas to build a completely new nest in a new location.


The above three rules can be transformed into the followingcuckoo search methodology:

1. An egg represents a solution and is stored in a nest. Artificialcuckoo can lay only one egg at the time.

2. The cuckoo bird searches the most suitable nest to lay eggs(solution) in order to maximize their eggs survival rate. Elitistselection process is applied, so only the high quality eggs (bestsolutions near to optimal value) which are more similar to thehost bird’s eggs have the opportunity to develop (next genera-tion) and become a mature cuckoo.

3. The number of host nests (population) is fixed. The host birddiscover the alien egg (worse solutions away from optimalvalue) with a probabilitypa e [0,1] and these eggs are thrownaway or the nest is abandoned, and completely new nest isbuilt, in a new location. Otherwise, the egg grows up and is alivefor the next generation. New eggs (solutions) lay by a cuckoochooses the nest by Lévy flights around the current bestsolutions.

For the implementation point of view, Yang and Deb (2009)used each egg in a nest represents a solution, and each cuckoocan lay only one egg (thus representing one solution), the aim isto use the new and potentially better solutions (cuckoos) to replacea non-so-good solution in the nests. In this case, there is no distinc-tion between eggs, nest or cuckoo, as each nest corresponds to oneegg which also represents one cuckoo. The new nest is generatedaccording to the law Lévy flight. Lévy flight represents one of theways of motion used by birds for searching for food in theenvironment.

In nature, animals search for food in a random or quasi randommanner. In general, the foraging path of an animal is effectively arandom walk because the next move is based on the current loca-tion/state and the transition probability to the next location.Which direction it chooses depends implicitly on a probabilitywhich can be modeled mathematically. For example, various stud-ies have shown that the flight behavior of many animals and in-sects has demonstrated the typical characteristics of Lévy flights(Pavlyukevich, 2007; Reynolds & Frye, 2007).

Reynolds and Frye (2007) study shows that fruit flies or Dro-sophila melanogaster explore their landscape using a series ofstraight flight paths punctuated by a sudden 90� turn, leading toa Lévy flight-style intermittent scale-free search pattern. Even lightcan be related to Lévy-flights (Barthelemy, Bertolotti, et al., 2008).Subsequently, such behavior has been applied to optimization andoptimal search, and preliminary results show its promising capa-bility (Pavlyukevich, 2007; Shlesinger, 2006). As Lévy flights haveinfinite mean and variance, CS can explore the search space moreefficiently then algorithms by standard Gaussian process. Thisadvantage, combine with both local and search capabilities andguaranteed global convergence, makes cuckoo search very efficient(Yang & Deb, 2013).

3.2. Genetic algorithm

Genetic algorithm (GA) is a search strategy that employs ran-dom choice to guide a highly exploitative search, striking a balancebetween exploration of the feasible domain and exploitation of‘‘good’’ solutions, see Holland (1992). A simple GA is comprisedof three operators: reproduction, crossover, and mutation. Repro-duction is the process of survival-of-the-fittest selection. Crossoveris the partial swapping between two parent strings to produce twooffspring strings. Mutation is the occasional random inversion ofbit values that generates non-recursive offspring. The main charac-teristic of the GA is the simultaneous evaluation of many solutions.




The procedure for implementing this algorithm is given briefly bythe following steps:

Step 1: A random initial population is generated.Step 2: The fitness function for each individual in the currentpopulation is evaluated.Step 3: Predefined stopping criteria is checked.Step 4: Reproduction, crossover, and mutation are performed onthe current population to form new generation.Step 5: Steps 2 to 4 will be repeated until stopping criteria.

The basic concept of GA is designed to simulate processes in anatural system necessary for evolution, specifically those that fol-low the principles first laid down by Charles Darwin of survivalof the fittest. GA have been widely studied, experimented, and ap-plied in many fields in the engineering world (Michalewicz, 1996).

3.3. Hybrid cuckoo search and genetic algorithm

The initial motivation of developing hybrid CS–GA approach isto combine the advantages of both cuckoo search and genetic algo-rithm. To find an optimal solution to an optimization problem is of-ten a very challenging task, depending on the choice and thecorrect use of optimization technique. In general, an ideal globaloptimization technique should have the following characteristics:

� Method should be easy and simple to implement.� Good balance between exploration and exploitation.� True global optimum should be found in each run.� Convergence should be fast.� Algorithm should have minimum control parameters to tune.� Algorithm should require minimum computational power to

run effectively.

In this proposed CS–GA, we strive to achieve the above criteria.Just as CS and GA is both population-based algorithm, the CS–GA isalso a population-based algorithm and uses a population of solu-tions to proceed to the global solution. The initial population isbeing randomly generated so that the initial solution is distributed

Begin

Objective function f(x);

Step 1: Initialization. Set the generation coun

(Initialize Np number of host nests randomly ea

potential solution to the given problem);

Step 2: Fitness evaluation. Evaluate fitness f(x);

While (t< Max Generation) or (stop criterion

Generate new population via genetic operator

Evaluate fitness (the best individual perfor

Generate a new solution (say xnew) via Lévy f

Evaluate its quality/fitness Fxnew;

Choose a solution (say xj) randomly among Np

if(Fxnew < Fj) then

Replace j by a new solution;

end if

Store the best solution;

t = t+1;

Step 3: end while

Step 4: Retrieve the best solution among the curren

End

Fig. 5. Pseudo code of


throughout the solution space. The entire run of the algorithm thepopulation number does not change. In each generation, the popu-lation will first undergo crossover and then mutation. After eachoperation, some form of elitism is applied to select only the bestsolutions. Before end of each generation, the best solution in thecurrent population will perform Lévy flight to increase the explora-tion of the solution space for the next generation. At each genera-tion the algorithm aims to create a new population by replacingpoints in the current population with better points via geneticprinciples. Through a repeated process of reproduction (crossoverand mutation) the population is guided towards the global opti-mum. By considering the above said principles, the pseudo codeof the proposed CS–GA are presented in Fig 5.

In the original CS, one cuckoo lays one egg at a time by perform-ing Lévy flights. In the hybrid CS–GA, every two parent cuckooswill reproduce two cuckoo eggs. As mentioned above, the femalecuckoo bird will mimic the eggs of the host birds. To account forthis behavior, a mutation operator was added to the algorithm.This will reflect the behavior of mutation of the cuckoo eggs’ genesto increase their reproductivity. Even with mutation of their genes,there is still a possibility that the alien egg will be discovered bythe host bird. The discovery of the alien egg is determined by thequality of the eggs reproduced. Therefore, elitism strategy is usedto only keep the high quality eggs while the poor quality eggsare discarded.

3.3.1. Generation of initial populationThe initial population consists of number of host nests, which

are randomly distributed over the search space, is generated first.An egg represents a solution and is stored in a nest. Initially eachnest has only a single egg/solution. Solution of the RRAP is consti-tuted of integer parts representing the redundancy level and realparts representing the components reliability, so it is describedas (x,r) = {(x1,x2,x3,x4, . . . ,xn), (r1,r2,r3,r4, . . . ,rn)}. Fig. 6 shows therepresentation of a solution. The ‘ binary digits for number ofredundancy xi represents an integer mi within [0,� 1] that yieldsthe number of redundancy with in [1,ui] as xi = h1 + mi(ui � 1)/(2‘ � 1)i. The h�i operator denotes rounding to the near integer.Like ‘ binary digits, the k binary digits for component reliability

ter t=1; initialize population randomly.

ch host nest have an egg corresponds to a

); / New population /

s (selection, crossover and mutation)

m Lévy flight)

lights;

new and evaluate its fitness (Fj);

t best solution stored in each generation

proposed CS–GA.



2 1 3 4 0.923783 0.834745 0.723482 0.623838

x( x1,x2,x3,x4) r (r1,r2,r3,r4)

Fig. 6. Solution (egg) representation.


ri represents an integer qi with in [0, 2k � 1] that is transformed tothe component reliability within [0, 1] as ri = qi/(2k � 1). As thecomponent reliabilities are practically more than 0.5, the first posi-tion of thek binary digits is fixed as 1 to search feasible solutionsefficiently. The values of ‘ and k determine the precision of thevariables, and we used ‘ = 8 and k = 16 determined by conductingnumber of trials.

For example a system consists of four subsystems; the solution/egg is look like shown in Fig. 6. The solution explains that a systemconsists of four subsystems (x1,x2,x3,x4). Subsystem x1 has 2 com-ponents with reliability 0.923783; Subsystem x2 having 1 compo-nent with reliability 0.9834745; Subsystem x3 having 3components with reliability 0.723482 and Subsystem x4 having 4components with reliability 0.623838 respectively.

3.3.2. Generation of new populationGenetic operators (selection, crossover and mutation) are used

to create new population. Two parents (cuckoos) are chosen fromthe population using the Roulette Wheel selection involves therecombination or crossbreeding to produce two new offspring(eggs). Crossover is used to recombine genetic material in two par-ent cuckoo to produce two eggs that share the characteristics oftheir parents. The single point crossover technique was adopted.After the crossover operation, each cuckoo mutates on its own.Its purpose is to maintain diversity within the population and inhi-bit premature convergence. Flip mutation scheme is used here.Mutation alone induces a random walk through the search space

Parent 1 1 0 0 1 0 1 0 0 1 0

After Cro

1 0 0 1 1 1 0 1 0 1

After Mu

1 0 1 1 1 1 1 1 0 1

Child 1

Fig. 7. Crossover and m


even better individual’s operator. The typical crossover and muta-tion operation is shown in Fig. 7.

3.3.3. Elitism strategyEach time after the crossover and also after the mutation, a form

of elitism is performed so that the best solutions are selected andmaintained in the population. For the crossover procedure, if thecuckoo egg is better than the parent, the new cuckoo egg will takethe place of their parents; else the parent cuckoo bird retains itsplace. As for the mutation procedure, if the newly mutated cuckooegg is better than the old cuckoo bird, the newly mutated cuckooegg will take the place of the old cuckoo bird. If the mutated cuckooegg is a poorer solution, it is considered to be discovered as an alienegg and is discarded. The elitist strategy guarantees that the bestcandidate solution is always preserved in the next generation. Thisprocedure is summarized with the following equation:

xi;nþ1 ¼yi if f ðyiÞ > f ðxi;nÞxi;n otherwise

�i ¼ 1;2; . . . ;N ð12Þ

In this CS–GA, each cuckoo bird represents a solution in the cur-rent generation, and cuckoo eggs represent the newly generatedsolutions in that generation (either by crossover or mutation).

3.3.4. New solution generationAfter the new population, the eggs that have grown to cuckoo

bird, these mature birds in their real life immigrate to a betterenvironment for their lifetime via Lévy flight and so forth. In addi-tion, the destination place has limit capacity for them to build theirnests. In this paper the best cuckoo in the current population willperform Lévy Flight to generate new egg (solution) stochastically.

xiðt þ 1Þ ¼ xiðtÞ þ a� L�evyðbÞ ð13Þ

where a > 0 is the step size which should be related to the scale ofthe problem of interest. In order to accommodate the difference be-tween solution qualities, we can also use by Yang and Deb (2011).

a ¼ ac½bestnestðtÞ � xiðtÞ� ð14Þ

where ac is a constant, while the term in the bracket corresponds tothe difference of two selected solutions. This mimics the fact thatsimilar eggs are less likely to be discovered and newly generatedsolutions are proportional to their differences. The product �meansentry-wise multiplications. Lévy flight is essentially a Markov chainin which the random steps are drawn from a Lévy distribution(Yang, 2010). In order to implement the Lévy flight, a fast algorithmneeded to be used to approximate the Lévy distribution. The authorof Leccardi (2005) compared three different approaches to generat-ing Lévy distributed values and found that the algorithm publishedin Mantegna (1994) proved to be most efficient. Mantegna’s algo-rithm produces random noise according to a symmetric Lévy stable

Parent 2 0 0 1 0 1 1 0 1 0 1

ssover

0 0 1 0 0 1 0 0 1 0

tation

1 0 1 0 0 1 0 1 1 0

Child 2

utation operation.




distribution (Leccardi, 2005). A symmetric Lévy stable distributionis ideal for Lévy flights as the direction of the flight should be ran-dom (Yang, 2010).

In Mantegna’s algorithm, the step length can be calculated by

L�evyðbÞ � u

jv j1b

ð15Þ

where u and v are drawn from normal distributions. That is

u � N 0;r2u

� �; v � N 0;r2

v� �

ð16Þ

ru ¼Cð1þ bÞ sin pb

2

� �C ð1þbÞ

2

h ib2

b�12

8<:

9=;

1b

; rv ¼ 1 ð17Þ

where the distribution parameter b 2 ½0:3;1:99�. C denotes gammafunction.

It is worth pointing out that the unique features of HCSGA are:In each generation, exploitation around the best solutions by ge-netic operators and exploration by randomization via Lévy flightsglobally work in combination can ensure the efficiency of the pro-posed HCSGA more powerful than other algorithms. By embeddingthe genetic principles reflects the real life of cuckoo birds closer tothe nature. In this HCSGA each cuckoo as a search agent moves allaround the search space to explore the location of the optimum.Table 2 shows the equivalent terms used in hybrid CS–GAapproach.

3.3.5. Constraint handlingThe main task while solving the constrained optimization prob-

lem is to handle the constraints. In the constrained optimizationproblem, it is not easy to find the feasible solution of the problemdue to the presence of both types of constraints in the form of theequalities and inequalities. A suitable method is required to handlethe constraints and guide the optimization to feasible regions andbe able to reach the bounds of the search-space. Over the last fewdecades, several methods have been proposed to handle the con-straints in the evolutionary algorithms (Coello Coello & MezuraMontes, 2002). A common approach when metaheuristics are usedto solve constrained problems is the adoption of penalties. By add-ing a penalized term into the objective function, a constrained opti-mization problem can be transformed to an unconstrained one. Apenalty function method has been used for handling constrainedreliability problems in this paper, and it exerts the penalty oninfeasible solutions based on the distance away from the feasibleregion. As the problems studied in this work are maximizationones, first it can be transformed into minimization one. It is wellknown that the maximization of f(x) can be transformed into theminimization of �f(x), thus the penalty function l

Pnj¼1 maxð0; giÞ

has been added to the objective function. Thus the objective func-tion becomes Min f ðxÞ ¼ �f ðxÞ þ l

Pnj¼1 maxð0; giÞ, where, l repre-

sents penalty coefficient, and it is set to 1010 in this paper. Theabove reliability value is to be minimized when the penalty isminimized.

Table 2Equivalent terminology used in CS–GA.

Features Equivalent terms in CS–GA

Population Number of host nestsChromosome/solution Cuckoo bird/Egg in a nestPopulation size FixedNew solution Cuckoo eggFitness Quality of eggsSearch space Position of nestSearch agent Cuckoo bird


4. Computation results, analysis and discussion

To evaluate the quality and performance of proposed CS–GA forRRAPs, the proposed method is applied to four bench mark reliabil-ity problems. These problems are: a series system, a complex(bridge) system, a series–parallel system and overspeed system.The CA-GA algorithm was coded in C++ and the simulations wereon the Intel(R)-64 Core(TM)2 CPU, [email protected] Ghz having 2 GB ofmemory. The task of optimizing each of the problems was exe-cuted in 20 independent runs, with each run iterated 500 times,or until the better solutions was found. The corresponding popula-tion size and the statistical features of the best results obtained byCS–GA are presented in Table 3 for each problem. From the results,it can be concluded that our approach performs quite well in termsof better solution on four RRAPs with a reasonable computationaltime.

Further, we compare the performance of CS–GA with 15 algo-rithms from the literature, namely:

nd03

GA

genetic algori

–

thm

Genetic Algorithm, Hsieh et al. (1998)
IA – Immune Algorithm, Chen (2006) SCA – Soft computing approach, Gen and Yun (2006) SAA – Simulated Annealing Algorithm, Kim et al.
(2006)
PSO – Particle Swarm Optimization, Coelho (2009) HS – Harmony Search Algorithm, Zou et al. (2010) CDHS – Chaotic Differential Harmony Search
Algorithm, Coelho, Diego, et al. (2010)
IPSO – Improved Particle Swarm Optimization, Wu
et al. (2011)
IBTPA – Immune Based Two–Phase Approach, Hsieh
and You (2011)
ABC – Artificial Bee Colony Algorithm, Yeh and Hsieh
(2011)
GHS – Global Harmony Search Algorithm, Zou et al.
(2011)
CS – Cuckoo Search Algorithm, Valian and Valian
(2012)
MICA – Modified Imperialist Competitive Algorithm,
Afonso, Mariani, et al. (2013)
GA-PSO – Hybrid Genetic Algorithm Particle Swarm
Optimization, Sheikhalishahi, Ebrahimipour,et al. (2013)

ICS
– Improved Cuckoo Search Algorithm, Valian,Tavakoli, et al. (2013).
The numerical results are shown in Tables 4–7, where the bestsolutions of each problem are reported and compared with solu-tions reported previously in the literature. Slack represents the un-used resources. For measuring the improvement, MPI (maximumpossible improvement) can be used to measure the amountimprovement of the solutions found by the proposed algorithmto the previous best know solutions, and it is described as: MPI(%) = (fCS–GA � fother)/(1 � fother), wherefCS–GA represents the bestsystem reliability obtained by CS–GA approach and fother repre-sents the best system reliability obtained by any other method inliterature. By using MPI, it shows the proposed approach made tinyimprovements in P2 and P4. Again, it has to be emphasized thateven small improvements in reliability are often hard to be ob-tained in high reliability applications.

From Tables 4–7, we observe that:For the series system (P1), Table 4 indicates that the best solu-

tion obtained by CS–GA is 0.931682388 which is superior to thoseall by the other typical approaches in the literature. The solution is

for reliability–redundancy allocation problems. Com-


Table 3Statistical features of the results obtained by CS–GA on four RRAPs.

Problem Number ofhost nests

Number of iterations Best Median Mean Worst SD Average CPU time

P1 -Series system 30 1000 0.931682388 0.93015825 0.9315236 0.9297532 8.15E�04 3.252P2 – Complex (bridge) system 30 1000 0.99988964 0.99988962 0.9998854 0.9998836 1.03E�05 1.89P3 – Series parallel system 30 1000 0.99997665 0.99997568 0.9999625 0.9999625 9.18E�03 2.64P4 – Overspeed protection system 30 1000 0.999954675 0.99995453 0.9999535 0.9999523 3.11E�06 1.925

Table 4Comparison of best result for the series system (P1) with other results presented in literature.

Algorithm (x1,x2,x3,x4,x5) r1 r2 r3 r4 r5 f(r,x) Slack (g1) Slack (g2) Slack (g3) MPI

SCA (3,2,2,3,3) 0.777143 0.867514 0.896696 0.717739 0.793889 0.931363 27 0.00000 7.518918 0.4653292GA (3,2,2,3,3) 0.779427 0.869482 0.902674 0.714038 0.786896 0.931578 27 0.121454 7.518918 0.1525650IA (3,2,2,3,3) 0.779266 0.872513 0.902634 0.710648 0.788406 0.931678 27 0.001559 7.518918 0.0064225SAA (3,2,2,3,3) 0.782391 0.866712 0.901747 0.717266 0.783795 0.931460 27 0.053194 7.518918 0.3244645SCA (3,2,2,3,3) 0.780874 0.871292 0.902316 0.711945 0.786995 0.931676 27 0.0033520 7.518918 0.0093496IPSO (3,2,2,3,3) 0.78037307 0.87178343 0.90240890 0.71147356 0.78738760 0.931680 27 0.000101 7.518918 0.0034953ABC (3,2,2,3,3) 0.779399 0.871837 0.902885 0.711403 0.787800 0.931682 27 0.0002184 7.5189182 0.0005679IBTPA (3,2,2,3,3) 0.779462304 0.871883456 0.902800879 0.711350168 0.787861587 0.931682340 27 0.0000005284 7.518918 0.0000703CS (3,2,2,3,3) 0.779416938 0.871833278 0.902885082 0.711393868 0.787803712 0.931682387 27 0.000000265 0.7518918241 0.000146ICS (3,2,2,3,3) 0.779416938 0.871833278 0.902885082 0.711393868 0.787803712 0.931682387 27 0.000000265 7.518918241 0.000146MICA (3,2,2,3,3) 0.779874 0.872057 0.903426 0.710960 0.786902 0.93167939 27 0.000099 7.518918 0.004388CS–GA (3,2,2,3,3) 0.779398871 0.871837021 0.902885355 0.711402515 0.787799488 0.931682388 27 0.000000 7.51891824 0

Bold face indicates the best reliability values.

Table 5Comparison of best result for the complex (bridge) system (P2) with other results presented in literature.


SCA (3,3,2,3,2) 0.814483 0.821383 0.896151 0.713091 0.814091 0.9997894 18 1.854075 4.264770 47.5973409GA (3,3,3,3,1) 0.814090 0.864614 0.890291 0.701190 0.734731 0.99987916 18 0.376347 4.264770 8.6726250IA (3,3,3,3,1) 0.812485 0.867661 0.861221 0.713852 0.756699 0.99988921 19 0.001494 4.264770 0.3881217SAA (3,3,3,3,1) 0.807263 0.868116 0.872862 0.7126673 0.751034 0.99988764 40 0.007300 1.609289 1.7799929SCA (3,3,3,3,1) 0.808258 0.866742 0.861513 0.716608 0.766894 0.999889 18 0.0009 4.2648 0.5765766PSO (3,3,2,4,1) 0.826678 0.857172 0.914629 0.648918 0.715290 0.99988957 5 0.000339 1.560466 0.0633886HS (3,3,2,4,1) 0.82883148 0.85836789 0.91334996 0.64779451 0.70178737 0.99988962 5 0.00004063 1.56046629 0.0181192IPSO (3,3,2,4,1) 0.82868361 0.85802567 0.91364616 0.64803407 0.70227595 0.99988963 5 0.00000359 1.56046629 0.0090604GHS (3,3,2,4,1) 0.82983999 0.85798911 0.91333926 0.64674479 0.70310972 0.99988960 5 0.00000594 1.56046629 0.0362319ABC (3,3,2,4,1) 0.828087 0.857805 0.914240 0.648146 0.704163 0.99988962 5 0.00002500 1.56046628 0.0181192IBTPA (3,3,3,3,1) 0.816624176 0.868767396 0.858748781 0.710279379 0.753429200 0.9998893505 18 0.00000 4.264770 0.2616370CS (3,3,2,4,1) 0.828094038 0.858004485 0.914162924 0.647907792 0.704565982 0.99988964 5 0.00007929 1.560466288 0ICS (3,3,2,4,1) 0.828094038 0.858004485 0.914162924 0.647907792 0.704565982 0.99988964 5 0.00007929 1.560466288 0GA-PSO (3,3,2,4,1) 0.828134 0.857831 0.914192 0.648069 0.704476 0.99988964 5 0.00000 1.560466 0MICA (3,3,2,4,1) 0.82764257 0.85747845 0.91419677 0.64927379 0.70409200 0.99988963 5 0.00004428 1.56046629 0.0090604CS–GA (3,3,2,4,1) 0.82808567 0.85780605 0.91424006 0.64814375 0.70418228 0.99988964 5 0.00000002 1.56046629 0


Table 6Comparison of best result for the series parallel system (P3) with other results presented in literature.


SCA (3,3,1,2,3) 0.838193 0.855065 0.878859 0.911402 0.850355 0.99996875 53 0.00000 7.110849 25.28GA (2,2,2,2,4) 0.785452 0.842998 0.885333 0.917958 0.870318 0.99997418 40 1.194440 1.609289 9.566228IA (2,2,2,2,4) 0.812485 0.843155 0.897385 0.894516 0.870590 0.99997658 40 0.002629 1.609289 0.29889SAA (2,2,2,2,4) 0.812161 0.853346 0.897597 0.900710 0.866316 0.99997631 40 0.007300 1.609289 1.435205IPSO (2,2,2,2,4) 0.81918526 0.84366421 0.89472992 0.89537628 0.86912724 0.99997664 40 0.000561 1.609289 0.042808CDHS (2,2,2,2,4) 0.819632 0.844101 0.895429 0.895976 0.868572 0.99997664 40 0.000474 1.609289 0.042808IBTPA (2,2,2,2,4) 0.819591561 0.844951068 0.895428548 0.895522339 0.868490229 0.999976649 40 0.000000 1.609289 0.004282CS (2,2,2,2,4) 0.819927087 0.845267657 0.895491554 0.895440692 0.868318775 0.999976649 40 0.0000161 1.6092890 0.004282ICS (2,2,2,2,4) 0.819927087 0.845267657 0.895491554 0.895440692 0.868318775 0.999976649 40 0.0000161 1.6092890 0.004282MICA (2,2,2,2,4) 0.82201264 0.84365640 0.89129092 0.89869886 0.86824939 0.99997661 40 0.000396 1.609289 0.171013GA-PSO (2,2,2,2,4) 0.819640 0.845091 0.895482 0.895517 0.868430 0.99997665 40 0.000001 1.609289 0CS–GA (2,2,2,2,4) 0.819660256 0.844981615 0.895519305 0.895492245 0.868447587 0.99997665 40 0.000000017 1.60928897 0



Please cite this article in press as: Kanagaraj, G., et al. A hybrid cuckoo search and genetic algorithm for reliability–redundancy allocation problems. Com-puters & Industrial Engineering (2013), http://dx.doi.org/10.1016/j.cie.2013.08.003


Table 7Comparison of best result for the overspeed protection system (P4) with other results presented in literature.

Algorithm (x1,x2,x3,x4) r1 r2 r3 r4 f(r,x) Slack (g1) Slack (g2) Slack (g3) MPI (%)

IA (5,5,5,5) 0.903800 0.874992 0.919898 0.890609 0.999942 50 0.002152 28.803701 21.85345SAA (5,5,5,5) 0.895644 0.885878 0.912184 0.887785 0.999945 50 0.9380 28.8037 17.59091PSO (5,5,4,5) 0.902231 0.856325 0.948145 0.883156 0.999953 55 0.975465 24.801882 3.56383HS (5,5,4,5) 0.90186194 0.84968407 0.94842696 0.88800590 0.99995467 55 0.00120356 24.8018827 0.01103IPSO (5,5,4,5) 0.90163164 0.84997020 0.94821828 0.88812885 0.99995467 55 0.000009 24.081883 0.01103GHS (5,5,4,5) 0.900925066 0.851636929 0.948079849 0.887654500 0.999955 55 0.00000584 24.80188272 0.72222ABC (5,5,4,5) 0.901614 0.849920 0.948143 0.888223 0.99995468 55 0.0000336 24.801883 0.01103CS (5,5,4,6) 0.901614595 0.888223369 0.948141029 0.849920899 0.99995468 55 0.00000000962 15.36346309 0.01103ICS (5,5,4,5) 0.901614595 0.888223369 0.948141029 0.849920899 0.99995468 55 0.0000000096 15.36346309 0.01103MICA (5,5,4,5) 0.90148988 0.85003526 0.94812952 0.88823833 0.999954673 55 0.00213782 24.8018827 0.004412GA-PSO (5,5,4,6) 0.901628 0.888230 0.948121 0.849921 0.99995467 55 0.000006 15.363463 0.01103CS–GA (5,5,4,6) 0.901613407 0.888223375 0.948142110 0.849920787 0.999954675 55 0.0000001 15.3634631 0



just slightly better than the previous best-known solutions foundby (Valian & Valian, 2012; Valian et al., 2013) using CS and ICSmethods. It implies that the proposed hybrid CS–GA performs wellover CS and ICS with respect to the objective function. For the com-plex (bridge) system (P2), Table 5 shows that the best-known solu-tion reported by Sheikhalishahi et al. (2013) and Valian et al.(2013) is 0.99988964. The CS–GA is also obtained the same solu-tion which is superior to those all by the other typical approachesin the literature. For the series–parallel system (P3), Table 6 showsthat the best solution by CS–GA is 0.99997665, and this solution isprevious best known solution reported by Sheikhalishahi et al.(2013), which is superior to those all by the other typical ap-proaches in the literature. For the overspeed protection system(P4), Table 7 shows that the best solution obtained by CS–GA is0.999954675, which is superior to those all by the other ap-proaches in the literature.

The relative improvements MPI (%) in Tables 4–7 indicate that,for all four benchmark problems, the proposed CS–GA approachcan find better optimal solutions than those by the other ap-proaches in the literature. By using MPI, it shows the proposedCS–GA approach made tiny improvements in P1–P4. It should beemphasized that even very small improvements in reliability areoften hard to obtain in high reliability applications. For the robust-ness analysis of our CS–GA approach, the standard deviation (SD)of system reliabilities in Table 3 reveals that the proposed CS–GAapproach stably searches and explores the near-optimal solutionwith a very small SD value.

5. Conclusion

This paper presented a hybrid cuckoo search and genetic algo-rithm to solve the nonlinear mixed-integer reliability optimizationproblems, which include the series system, the complex (bridge)system, the series–parallel system and the overspeed protectionsystem. In these optimizations problems, both the redundancy(number of redundant components) and the corresponding reli-ability of each component in each subsystem are to be decidedsimultaneously. The results obtained by CS–GA for the RRAPs arebetter than or equal to other existing algorithms available in theliterature. By embedding the genetic operators in standard CS,the balance between the exploration and exploitation ability fur-ther improved. This is partly due to the fact that the CS–GA main-tains the Lamarckian property of the solution (Gen & Cheng, 1999).Having Lamarckian property in the solutions will ensure meaning-ful crossover between parent cuckoo birds. The crossover of thecuckoo birds maintains partial identity of the parent cuckoo birdwhile allowing a diversified search in the solution space. The muta-tion of the cuckoo eggs contributes to the local search of the solu-tion space by making small but logical changes in the genes. In


addition, the elitism strategy used in CS–GA ensures that best solu-tions are always carried forward to the next generation. Lévyflights have as a characteristic of an intensive search around a solu-tion, followed by occasional big steps in the long run enhances theexploration of future generations and greatly reduces the possibil-ity of a premature convergence at local minima. Experimental re-sults illustrate that the proposed CS–GA was more efficient infinding better solutions than the existing methods in literaturewhen used to find the optimal solutions for the four reliabilityproblems.

References

Afonso, L. D., Mariani, V. C., et al. (2013). Modified imperialist competitive algorithmbased on attraction and repulsion concepts for reliability–redundancyoptimization. Expert Systems with Applications, 40, 3794–3802.

Barthelemy, P., Bertolotti, J., et al. (2008). A Lévy flight for light. Nature, 453(7194),495–498.

Bernardino, H. S., H. J. Barbosa, et al. (2006). Constraint handling in geneticalgorithms via artificial immune systems. In Late-breaking paper at Genetic andEvolutionary Computation Conference (GECCO 2006).

Chen, T.-C. (2006). IAs based approach for reliability redundancy allocationproblems. Applied Mathematics and Computation, 182(2), 1556–1567.

Chi, D.-H., & Kuo, W. (1990). Optimal design for software reliability anddevelopment cost. IEEE Journal on Selected Areas in Communications, 8(2),276–282.

Coelho, L. d. S. (2009). An efficient particle swarm approach for mixed-integerprogramming in reliability–redundancy optimization applications. ReliabilityEngineering & System Safety, 94(4), 830–837.

Coello, C. A. C., & Cortés, N. C. (2004). Hybridizing a genetic algorithm with anartificial immune system for global optimization. Engineering Optimization,36(5), 607–634.

Coello Coello, C. A., & Mezura Montes, E. (2002). Constraint-handling in geneticalgorithms through the use of dominance-based tournament selection.Advanced Engineering Informatics, 16(3), 193–203.

Coelho, L., Diego, L. d. A., et al. (2010). Reliability–redundancy optimization using achaotic differential harmony search algorithm. Handbook of swarm intelligence.Springer (pp. 503–516).

Garg, H., & Sharma, S. (2013). Multi-objective reliability–redundancy allocationproblem using particle swarm optimization. Computers & Industrial Engineering,64, 247–255.

Gen, M., & Cheng, R. (1999). Genetic algorithms and engineering optimization. Wiley-Interscience.

Gen, M., & Yun, Y. (2006). Soft computing approach for reliability optimization:State-of-the-art survey. Reliability Engineering & System Safety, 91(9),1008–1026.

Gopal, K., Aggarwal, K., et al. (1978). An improved algorithm for reliabilityoptimization. IEEE Transactions on Reliability, 27(5), 325–328.

Hikita, M., Nakagawa, Y., et al. (1992). Reliability optimization of systems by asurrogate-constraints algorithm. IEEE Transactions on Reliability, 41(3), 473–480.

Holland, J. H. (1992). Adaptation in natural and artificial systems: An introductoryanalysis with applications to biology, control and artificial intelligence. MIT Press.

Hsieh, Y.-C., Chen, T.-C., et al. (1998). Genetic algorithms for reliability designproblems. Microelectronics Reliability, 38(10), 1599–1605.

Hsieh, Y.-C., & You, P.-S. (2011). An effective immune based two-phase approach forthe optimal reliability–redundancy allocation problem. Applied Mathematics andComputation, 218(4), 1297–1307.

Kanagaraj, G., & Jawahar, N. (2011). Simultaneous allocation of reliability &redundancy using minimum total cost of ownership approach. Journal ofComputational and Applied Research in Mechanical Engineering, 1(1), 1–16.


http://refhub.elsevier.com/S0360-8352(13)00257-X/h0005














































Kim, H.-G., Bae, C.-O., et al. (2006). Reliability–redundancy optimization usingsimulated annealing algorithms. Journal of Quality in Maintenance Engineering,12(4), 354–363.

Kulturel-Konak, S., Smith, A. E., et al. (2003). Efficiently solving the redundancyallocation problem using tabu search. IIE Transactions, 35(6), 515–526.

Kuo, W., Lin, H.-H., et al. (1987). Reliability optimization with the Lagrange-multiplier and branch-and-bound technique. IEEE Transactions on Reliability,36(5), 624–630.

Kuo, W., & Prasad, V. R. (2000). An annotated overview of system-reliabilityoptimization. IEEE Transactions on Reliability, 49(2), 176–187.

Kuo, W., & Wan, R. (2007). Recent advances in optimal reliability allocation.Computational intelligence in reliability engineering. Springer (pp. 1–36).

Layeb, A. (2011). A novel quantum inspired cuckoo search for knapsack problems.International Journal of Bio-Inspired Computation, 3(5), 297–305.

Leccardi, M. (2005). Comparison of three algorithms for Lèvy Noise Generation. InProceedings of fifth EUROMECH nonlinear dynamics conference.

Mantegna, R. N. (1994). Fast, accurate algorithm for numerical simulation of Levystable stochastic processes. Physical Review E, 49, 4677–4683.

Mori, B. D., de Castro, H. F., et al. (2007). Development of hybrid algorithm based onsimulated annealing and genetic algorithm to reliability redundancyoptimization. International Journal of Quality & Reliability Management, 24(9),972–987.

Michalewicz, Z. (1996). Genetic algorithms + data structures = evolution programs.Springer.

Pavlyukevich, I. (2007). Lévy flights, non-local search and simulated annealing.Journal of Computational Physics, 226(2), 1830–1844.

Reynolds, A. M., & Frye, M. A. (2007). Free-flight odor tracking in Drosophila isconsistent with an optimal intermittent scale-free search. PloS One, 2(4), e354.

Sheikhalishahi, M., Ebrahimipour, V., et al. (2013). A hybrid GA–PSO approach forreliability optimization in redundancy allocation problem. The InternationalJournal of Advanced Manufacturing Technology, 1–22.

Shlesinger, M. F. (2006). Mathematical physics: Search research. Nature, 443(7109),281–282.

Tillman, F. A., Hwang, C.-L., et al. (1977). Determining component reliability andredundancy for optimum system reliability. IEEE Transactions on Reliability,26(3), 162–165.


Valian, E., Tavakoli, S., et al. (2013). Improved cuckoo search for reliabilityoptimization problems. Computers & Industrial Engineering, 64, 459–468.

Valian, E., & Valian, E. (2012). A cuckoo search algorithm by Lévy flights for solvingreliability redundancy allocation problems. Engineering Optimization, 1–14(ahead-of-print).

Wang, Y., & Cai, Z. (2009). A hybrid multi-swarm particle swarm optimization tosolve constrained optimization problems. Frontiers of Computer Science in China,3(1), 38–52.

Wu, P., Gao, L., Zou, D., & Li, S. (2011). An improved particle swarm optimizationalgorithm for reliability problems. ISA Transactions, 50(1), 71–81.

Xu, Z., Kuo, W., et al. (1990). Optimization limits in improving system reliability.IEEE Transactions on Reliability, 39(1), 51–60.

Yang, X.-S., & Deb, S. (2009). Cuckoo search via Lévy flights. In 2009 World congresson nature and biologically inspired computing (NaBIC 2009). IEEE.

Yang, X. S. (2010). Nature-inspired metaheuristic algorithms. Luniver Press.Yang, X.-S., & Deb, S. (2013). Cuckoo search: Recent advances and applications.

Neural Computing and Applications, 1–6.Yang, X.-S., & Deb, S. (2011). Multiobjective cuckoo search for design optimization.

Computers & Operations Research.Yang, X.-S., & Koziel, S. (2011). Computational optimization and applications in

engineering and industry. Springer-Verlag New York Incorporated.Yeh, W.-C., & Hsieh, T.-J. (2011). Solving reliability redundancy allocation problems

using an artificial bee colony algorithm. Computers & Operations Research,38(11), 1465–1473.

Yokota, T., Gen, M., et al. (1995). System reliability optimization problems withseveral failure modes by genetic algorithm. Journal of Japan Society for FuzzyTheory and Systems (USA), 7(1), 119–132.

Zhao, J.-Q., Wang, L., et al. (2012). An effective hybrid genetic algorithm withflexible allowance technique for constrained engineering design optimization.Expert Systems with Applications, 39(5), 6041–6051.

Zou, D., Gao, L., et al. (2010). A novel global harmony search algorithm for reliabilityproblems. Computers & Industrial Engineering, 58(2), 307–316.

Zou, D., Gao, L., Li, S., & Wu, J. (2011). An effective global harmony search algorithmfor reliability problems. Expert Systems with Applications, 38(4), 4642–4648.
















http://refhub.elsevier.com/S0360-8352(13)00257-X/h0115a


http://refhub.elsevier.com/S0360-8352(13)00257-X/h0115b

http://refhub.elsevier.com/S0360-8352(13)00257-X/h0115b














































A hybrid cuckoo search and genetic algorithm for reliability–redundancy allocation problems

Documents

Transcript of A hybrid cuckoo search and genetic algorithm for reliability–redundancy allocation problems