Introduction

Many applications involve nonlinear optimization and thus require sophisticated optimization algorithms to solve. Such applications can be very diverse, spanning many areas and disciplines from engineering designs and scheduling to data mining and machine learning [13, 33, 40, 41, 43]. One of the current trends is to use metaheuristic algorithms inspired by the successful characteristics in nature. Among these new algorithms, cuckoo search (CS) has been shown to be powerful in solving many problems [41, 43]. This standard CS version was mainly designed for single objective optimization problems, which was later extended to multiobjective optimization [46].

Both standard cuckoo search and its multiobjective extension used simplified characteristics to represent the brood parasitism of a single cuckoo species and their interactions with a single host species. However, the reality is far more complicated in the cuckoo-host co-evolution systems [10]. The co-evolution often involves multiple cuckoo species that compete with each other and compete for the resources of host bird species, while the hosts can also have multiple species. Cuckoo species tend to evolve to lay eggs with the mimicry of the size, colours, and texture of the eggs of host birds, often with critical timing advantage. On the other hand, host birds can counter-act such parasitism by developing their defensive strategies to identify potential intruding eggs and minimize the risk of hatching cuckoo eggs. This arms race is both co-evolutionary and ongoing [11, 27], and the co-evolution seems to promote species richness and subspecies variations as well as diversity in parasitic cuckoos [21]. The richness of characteristics in cuckoo-host co-evolution provides us an inspiration to potentially design better optimization algorithms.

One way to model such co-evolution has been proposed by Mishra [22] to use a host-parasite co-evolutionary approach where both parasites and hosts took random flights. The probability of detection or rejection of eggs was dynamic, depending on the accumulative success of the parasites such as cuckoos. This approach has been used to solve both function optimization problems and completing incomplete correlation matrix [22]. However, this approach only captured a very small part of the major characteristics of the cuckoo-host co-evolutionary systems.

In order to capture more detailed characteristics of this co-evolution system, in this paper, we extend the original cuckoo search to a new multi-species co-evolutionary cuckoo search algorithm. The key idea is to simulate the main co-evolutionary behavior of both cuckoo species and host species. The key novelty of this approach is to allow different species of cuckoos (via more than two population groups) to compete and co-evolve with a host species (via a host population). This multi-population system is an intrinsic multi-swarm system, which can increase the selection pressure to drive the system towards better strategies and solutions.

Therefore, the paper is organized as follows. The “The Original Cuckoo Search” section summarizes the original cuckoo search and its main equations. The “Multi-Species Cuckoo Search” section outlines the novel features of the new multi-species cuckoo search, followed by the numerical experiments on 15 different test benchmarks in the “Validation by Numerical Experiments” section. The “Practical Applications” section presents the results of five different case studies concerning engineering designs, inverse parameter estimation and data classification. The paper concludes with discussions about further research directions in the “Discussions” section.

The Original Cuckoo Search

Cuckoo search (CS) is a nature-inspired metaheuristic algorithm, developed in 2009 by Xin-She Yang and Suash Deb [41]. CS is based on the brood parasitism of some cuckoo species. In addition, this algorithm is enhanced by the so-called Lévy flights [28], rather than by simple isotropic random walks. Recent studies show that CS is potentially far more efficient than PSO and genetic algorithms [17, 42]. A relatively comprehensive review of the studies up to 2014 was carried out by Yang and Deb [43].

Cuckoo Search and its Algorithmic Equations

In the natural world, many cuckoo species (59 species among 141 cuckoo species) engage the so-called obligate reproduction parasitism strategy. There is an evolutionary arms race between such cuckoo species and their associated host species [10, 11, 27]. Based on such phenomena, Yang and Deb developed the standard cuckoo search in 2009 [41]. The standard CS uses three simplified rules:

  1. 1.

    Each cuckoo lays one egg at a time and dumps it in a randomly chosen nest. An egg corresponds to a solution vector.

  2. 2.

    The best nests with high-quality eggs (solutions) will be carried over to the next generation.

  3. 3.

    The number of available host nests is fixed, and the egg laid by a cuckoo is discovered by the host bird with a probability pa ∈ [0,1]. In this case, the host bird can either get rid of the egg, or simply abandon the nest and build a completely new nest at a new location.

In the original cuckoo search, there is no distinction between an egg, a nest, or a cuckoo. In this simplified scenario, each nest corresponds to one egg which also represents one cuckoo, which makes it much easier to implement [42]. Mathematically speaking, cuckoo search uses a combination of a local random walk and the global explorative random walk, controlled by a switching parameter pa. The local random walk can be written as

$$ \textbf{x}_i^{t + 1}=\textbf{x}_i^t +\beta s \otimes H(p_a-\epsilon) \otimes (\textbf{x}_j^t-\textbf{x}_k^t), $$
(1)

where \({\textbf {x}_{j}^{t}}\) and \({\textbf {x}_{k}^{t}}\) are two different solutions selected randomly by random permutation. Here, H(u) is a Heaviside function, 𝜖 is a random number drawn from a uniform distribution, and s is the step size. In addition, ⊗ denotes an entry-wise multiplication operator, and β is the small scaling factor.

On the other hand, the global random walk is carried out by using Lévy flights

$$ \textbf{x}_i^{t + 1}=\textbf{x}_i^t+\alpha \otimes L(s, \lambda), $$
(2)

where

$$ L(s, \lambda) \sim \frac{\lambda {\Gamma}(\lambda) \sin (\pi \lambda/2)}{\pi} \frac{1}{s^{1+\lambda}}, \quad (s \gg 0), $$
(3)

where α > 0 is the step size scaling factor, which should be related to the scales of the problem of interest. Here, “∼” highlights the fact that the search steps in terms of random numbers L(s, λ) should be drawn from the Lévy distribution on the right-hand side of Eq. 3. It is worth pointing out that Eq. 3 is an approximation to the Lévy distribution by a power-law distribution with an exponent λ. The use of Lévy flights enables the algorithm with higher ergodicity and explorability, which makes the algorithm more likely to jump out of any local optima [28, 41, 43].

Cuckoo Search in Applications

Since the development of the cuckoo search algorithm in 2009, it has been applied in many areas, including optimization, engineering design, data mining, and computational intelligence with promising efficiency. From the case studies in engineering design applications, it has been shown that cuckoo search has superior performance to other algorithms for a range of continuous optimization problems [16, 17, 42, 43, 50]. A review by Yang and Deb covered the literature up to 2013 [43], while a review by Fister et al. covered the literature up to 2015. Another review by Mohamad et al. focused on applications up to 2014 [24]. The most recent literature review has been carried out by Shehab et al. [32], which covers some of the most recent literature up to 2017. These reviews have highlighted some of the diverse applications using cuckoo search and its variants.

There are many other applications, including vehicle component optimization [15], wireless sensor networks [12], training neural networks [35], runoff-erosion modelling [31], phase equilibrium in thermodynamic calculations [3], network optimization [25], and scheduling [7]. In addition, cuckoo search has also been applied to multilevel color image segmentation [26], biodiesel engine optimization [38], graphic objective feature extraction [39], fractional order PID control design [51], vulnerabilities mitigation [53], and others [45].

From the algorithm development perspective, different cuckoo search variants have been developed by introducing new components or hybridizing with other algorithms. For example, a binary cuckoo search for feature selection has been developed by Pereira et al. [29]. Walton et al. [36] developed a modified cuckoo search for solving complex mesh generation in engineering simulation, while Zheng and Zhou [52] provided a variant of cuckoo search using Gaussian process. Mlakar et al. developed a self-adaptive cuckoo search [23], while Wang et al. enhanced cuckoo search with chaotic maps [37].

As a further extension, Yang and Deb [46] developed a multiobjective cuckoo search (MOCS) algorithm for engineering design applications. Recent studies have demonstrated that cuckoo search can perform significantly better than other algorithms in many applications [17, 45, 50]. However, none of the above variants of cuckoo search use the characteristics of multi-species co-evolution, and one of the main aims of this paper is to explore this area so as to further enhance and improve the CS algorithm.

Multi-species Cuckoo Search

In the original cuckoo search and its many variants, there is only one cuckoo species interacting with one species of host birds. In the standard cuckoo search, a cuckoo is allowed to lay a single egg and each nest contains only a single egg. This is a very simplified scenario. In the real cuckoo-host systems, it is observed that multiple cuckoo species co-evolve with one or more host species to compete for survival of the fittest by brood parasitism [10, 27]. Loosely speaking, cuckoos can evolve to subspecies with speciation, and they can be subdivided into different gentes targeting at different host species [11, 21]. The interaction dynamics can be very complex, forming an on-going, co-evolutionary arms race between cuckoo subspecies and host species as well as different cuckoo species. Field studies have shown that such co-evolution may promote species richness in parasitic cuckoos with the enhanced speciation and extinction rates [21]. Strictly speaking, different species, subspecies and gentes are used in the biological literature and their meaning can be different [21, 27]; however, we will simply use species here for simplicity.

Based on the above characteristics of cuckoo-host co-evolution, we can extend the original cuckoo search to capture more realistic cuckoo-host co-evolution to develop a new multi-species co-evolution cuckoo search, or multi-species cuckoo search (MSCS) for short. In order to describe the MSCS in detail, we use the following idealized rules/assumptions:

  1. 1.

    There are multiple cuckoo species (m species) that compete and co-evolve with a host species. The arms race between cuckoo species and the host species obeys the survival of the fittest. Both the best cuckoos and the best hosts will pass onto the next generation.

  2. 2.

    Each cuckoo of any cuckoo species can lay r eggs inside a randomly selected host nest. Each cuckoo egg has a probability pa to be discovered (and then abandoned) by the host (thus the survival probability is 1 − pa).

  3. 3.

    Each nest contains q eggs. If the fraction/ratio of cuckoo eggs is higher than 1 − pa, the host bird can abandon the nest and then fly away to build a new nest in a new location.

Based on these rules for MSCS, we can represent them more mathematically. Each solution vector xi to an optimization problem in a D-dimensional space is represented by an egg. Therefore, an egg is equivalent to a solution vector, and a nest represents a group of q solutions.

In general, there are m ≥ 1 species with a total population of n, each species has ni (i = 1,..., m) cuckoos such that

$$ \sum\limits_{i = 1}^m n_i =n. $$
(4)

Each cuckoo lays r ≥ 1 eggs. There are w host nests, and each nest can have q ≥ 1 eggs on average. So the total number of eggs in the host nests are Nh = wq, which should be greater than n. That is, Nh ≥ n. In nature, it is estimated that approximately 1/4 to 1/2 of eggs in the host nests are cuckoo eggs. Thus, for simplicity, we can set n = Nh/2 in this study.

Competition can occur at three different levels: intraspecies competition, inter-species competition, and cuckoo-host competition. Even for a single species, cuckoos within the same species can compete for host nests, which is intraspecies competition. For multiple species, one species of cuckoos can compete with cuckoos from other species by their egg-replacing strategy. The most significant competition is the cuckoo-host competition. All these three kinds of competition interact and co-evolve to form a complex system, leading to potential self-organizing intelligent behavior.

In the co-evolutionary system, different cuckoo species compete for the survival of the fittest, and cuckoos from one species can take over other cuckoos’ territory or replace eggs laid by other cuckoo species. This can simply be realized mathematically by random swapping its location vector with another in a dimension-by-dimension manner. This binary random swapping operator can be achieved by the following two equations:

$$ \textbf{x}_a^{(\text{new})}= \textbf{x}_a \otimes (1-\textbf{Q}) + \textbf{x}_b \otimes \textbf{Q}, $$
(5)

and

$$ \textbf{x}_b^{(\text{new})} = \textbf{x}_a \otimes \textbf{Q} + \textbf{x}_b \otimes (1-\textbf{Q}), $$
(6)

where xa is randomly selected from cuckoo species a, while xb is selected from cuckoo species b. Here, Q is a random binary vector with the same length of xa and each of its components is either 1 or 0 [i.e. Qk ∈{0,1} (k = 1,2,..., D)]. For example, Q = [1,0,0,1,0,1,1] is a binary vector in a seven-dimensional space. Again, ⊗ means that the operation is a component-wise or dimension-wise operation.

The main steps for implementing and simulating the above idealized characteristics are as follows:

  1. 1.

    There are two population sets: a total population of n cuckoos for m cuckoo species (each has its own population nj (j = 1,2,..., m)), and a population of Nh host nests. Thus, there are two initial best solutions: \(\textbf {g}_{cs}^{*}\) to denote the best cuckoo among all m cuckoo species (each species has its own best cuckoo \(\textbf {g}_{j}^{*}\)) and \(\textbf {g}_{h}^{*}\) to denote the best host in terms of objective fitness.

  2. 2.

    For each generation of evolution, each cuckoo (say, cuckoo i) from one cuckoo species (say, species j) can lay r eggs in a randomly selected host nest (say, nest k). The newly laid eggs will replace randomly selected eggs in the nest so that the total number of eggs (q ≥ 1) in the nest remains constant. The main equation for this action can be carried out by Eq. 1.

  3. 3.

    For any new egg laid by a cuckoo, there is a probability of pa to be discovered. Among q eggs, if the fraction of cuckoo eggs exceeds 1 − pa, the host can abandon the nest completely and fly away to build a new nest at a new location via Eq. 2.

  4. 4.

    Different species of cuckoos compete for their survival and territories, thus they can lay eggs in the nests that other cuckoos just laid. This competition is equivalent to replacing or swapping its own eggs with another cuckoo’s eggs from different species. Thus, it can be achieved by randomly swapping their components dimension by dimension via Eqs. 5 and 6.

  5. 5.

    Random mixing is carried out in terms of egg-laying and nest choices among different cuckoo species and the host species.

  6. 6.

    Both the best cuckoos and host nests (in terms of their fitness) should pass onto the next generation.

These key steps can be schematically represented as the pseudocode in Algorithm 1. To illustrate the main ideas, for two species of cuckoos with a total population of n = 40, we have m = 2 and n = 40. If two species have the same population size, we have n1 = n2 = n/2 = 20. For simplicity, if all nests have the same number of four eggs in 20 nests, we have q = 4 and w = 20, thus there Nh = 20 ∗ 4 = 80 eggs in all the nests. In addition, if each cuckoo lays one egg at a time (i.e., r = 1), this means that there are n × r = 40 cuckoo eggs in the cuckoo-host system. Thus, in this case, there are exactly 50% of the eggs belong to cuckoos in the combined population of cuckoo species and host nests.

Obviously, the number of cuckoo eggs in a particular nest can be randomly distributed from 1 to q = 4. For pa = 0.25, if there are 3 or 4 eggs in a nest, one egg may typically belong to a cuckoo. If the number of alien eggs is higher, this nest can be abandoned by its host, and thus a new replacement nest with q new eggs (or randomly generated solutions) will be built in a new location. This new location is typically far enough from the original location to minimize the risk of being close to the same cuckoos.

figure a

It is worth pointing out that there seems to have some similarity between multi-species cuckoo interactions and the multi-swarm optimization in the literature [5]. However, there are two key differences here: the multi-species cuckoo search (MSCS) mimics the co-evolution between parasite cuckoo species and host species, while multi-swarms mainly split a population of the same kind into subgroups or subswarms. In addition, the share of information in MSCS is among the same cuckoo species and the same host species, not directly shared among competing species. Such information-sharing structure can potentially enable more extensive exploitation of local information as well as global information. On the other hand, multi-swarms tend to share information among all subswarms. Furthermore, different cuckoo species compete for their own survival, while the multi-swarms do not compete. These differences mean that MSCS is not a simple multi-swarm system, rather it is an interacting co-evolving multi-swarm system. Therefore, different algorithmic characteristics and performance can be expected.

Validation by Numerical Experiments

All new algorithms have to be extensively tested by a diverse range of benchmarks and case studies. As a preliminary test, we will use a subset of 15 function benchmarks and 5 case studies.

Benchmarks

For this purpose, we have selected 15 benchmark functions with different modalities and landscapes. These benchmarks are part of traditional optimization functions, the CEC2005 test suite and most recent CEC2015 test functions. The chosen set of benchmarks have diverse properties so that we can test the proposed algorithm more thoroughly.

The first function is the shifted sphere function f1 from the CEC2005 benchmark suite [34]. This function has the global minimum f1,min = − 450 in the domain − 100 ≤ xi ≤ 100.

The second function is Ackley function

$$ f_2(\textbf{x})=-20 e^{-\frac{1}{5} (\frac{1}{D} \sum\limits_{i = 1}^D x_i^2)^{1/2}} - e^{\frac{1}{D} \sum\limits_{i = 1}^D \cos (2 \pi x_i)} + 20 +e, $$
(7)

which has its global minimum f∗ = 0 at (0,0,...,0). This function is highly nonlinear and multimodal.

The third function is Xin-She Yang’s forest-like function

$$ f_3(\textbf{x})=\left( \sum\limits_{i = 1}^D |x_i| \right) \exp\left[- \sum\limits_{i = 1}^d \sin (x_i^2) \right], $$
(8)

which has the global minimum f∗ = 0 at (0,0,...,0) in the domain of − 2π ≤ xi ≤ 2π. This function is highly nonlinear and multimodal, and its first derivatives do not exist at the optimal point due to the modulus |xi| factor.

The fourth function is the shifted Schwefel’s problem with noise in fitness as given in CEC2005 benchmark suite [34], which has the mean global minimum f4,min = − 450 in the domain − 100 ≤ xi ≤ 100.

The fifth function is Schwefel’s Problem 2.22 [49]

$$ f_5(\textbf{x})=\sum\limits_{i = 1}^D |x_i|+\prod\limits_{i = 1}^D |x_i|, $$
(9)

which has the global minimum f5,min = 0 at x = (0,0,...,0) in the domain − 10 ≤ xi ≤ 10. This function is unimodal.

The sixth function is the shifted Rosenbrock function f6 of CEC2005 benchmark suite with the minimum f6,min = 390 in − 100 ≤ xi ≤ 100.

The seventh function is the shifted and rotated Griewank function with the minimum f7,min = − 180 in the domain of 0 ≤ xi ≤ 600.

The eighth function is Function 23 of the CEC2005 benchmarks [34], which is a non-continuous rotated hybrid composition function with the minimum f8,min = 360 in − 5 ≤ xi ≤ 5.

The ninth function is Function 24 of the CEC2005 benchmarks [34], which is a rotated hybrid composition function with f9,min = 260 in − 5 ≤ xi ≤ 5.

The tenth function is Function 25 of the CEC2005 benchmark suite [34], which is a rotated hybrid composition function without bounds with the minimum of f10,min = 260 in [2,5]D.

The next five functions are taken from the CEC2015 benchmark suite [8, 30]. The 11th function is the rotated bent cigar function with the minimum f11,min = 100, while the 12th function is the rotated Discus function with the minimum of f12,min = 200. The 13th function is the shifted and rotated Weierstrass function with f13,min = 300, and the 14th function is the shifted and rotated Schwefel’s function with f14,min = 400. Finally, the 15th function is the shifted and rotated Katsuura function with f15,min = 500. All these functions have variables in the domain of [-100,100]D where D is the dimensionality of the functions.

Parameter Settings

In our implementations, we have used n1 = n2 = 20, n = 40, r = 1, m = 2, Nh = 80, q = 4 and w = 20 for the two sets of populations. For the parameters in the algorithmic equations, we have used α = β = 0.01, λ = 1.5, pa = 0.25 and a fixed number of iterations tmax = 1000 as the stopping criterion. These parameter settings are based on a preliminary parametric study in our simulations and the suggestions in the literature [41, 43].

In addition, D = 10 is used for all the test functions in the first experiment. Then, D = 50 is used for the second numerical experiment with all other parameter values remaining the same. For both the standard cuckoo search (CS) and the proposed MSCS, we have used ncs = 80 so that the total numbers of function evaluations remain the same for all algorithms. Thus, the fairness of the comparison in terms of function evaluations is ensured.

Results

Each algorithm has been run for 100 trials so as to calculate meaningful statistics such as the best (minimum) objective values and the means of the obtained solutions. The error is defined as the absolute value of the difference between the best f(x∗) found by the algorithm and the true minimum fmin(true). That is

$$ E_f=|f(\textbf{x}_*)-f_{\min}(\text{true})|. $$
(10)

The numerical results are summarized in Table 1 where the best corresponds to the minimum of Ef and the mean corresponds to the average value of Ef.

Table 1 Errors \(|f(\textbf {x}_{*})-f_{\min }(\text {true})|\) for D = 10
Full size table

From Table 1, we can see clearly that MSCS can obtain better results in all the benchmarks. The diversity among the cuckoo-host populations in MSCS is higher than those in CS, and the MSCS can be potentially more robust. This will in general promote the exploration ability of the search process.

Another way of looking at the simulation results is to analyze and compare the convergence behavior. In fact, MSCS converges faster than CS for all the test functions by tracing both the minimum objective values found during iterations. For example, for function f5, its convergence plot is shown in Fig. 1 where we can see that MSCS converges faster even from the very early iterations. Other benchmarks show similar characteristics.

Fig. 1
figure 1

Convergence plot for f5 during iterations

Full size image

In order to test the proposed algorithm for solving higher-dimensional problems, we have also tested the same set of function benchmarks for D = 50. In most studies, researchers tend to use higher numbers of iterations for higher values of D, typically t = 1000D. But we have used the same settings of the parameters as before; that is, tmax = 1000. The results are summarized in Table 2.

Table 2 Errors \(|f(\textbf {x}_{*})-f_{\min }(\text {true})|\) for D = 50
Full size table

As we can see from Table 2 that the MSCS obtained better results for almost all functions, except for the shifted and rotated Weierstrass function f13. Even for this function (f13), the two algorithms obtained the same orders of results, but the variation of MSCS is smaller. This means that the MSCS can obtain optimal solutions with sufficient robustness.

Practical Applications

To test the proposed MSCS algorithm further, we now use five test problems in real-world applications with diverse properties and nonlinearity. Three case studies are engineering design problems and they are mostly mixed integer programming problems. The fourth case study is the parameter estimation problem or an inverse problem, which requires to solve a second-order differential equation to calculate the values of objective function. The final problem is the data clustering using the well-known Fisher’s iris flower data set.

It is worth pointing out that these case studies are seemingly simple, but they are quite hard to solve due to high nonlinearity, multimodality and irregular search domains. They are nonlinear global optimization problems. In addition, the pressure vessel problem is also a mixed integer programming problem, which is much harder to solve, compared its continuous counterpart.

Design of a Spring

Let us start with a simple but nonlinear problem about the design of a spring under tension or compression from a metal wire [2, 9]. There are three design variables: the wire diameter (r), the mean coil diameter (d), and the number (N) of turns/coils. The objective is to minimize the overall weight of the spring

$$ \textrm{minimize } \; f(\textbf{x})=(2+N) r^2 d, $$
(11)

subject to nonlinear constraints:

$$\begin{array}{@{}rcl@{}} g_1(\textbf{x})&=&1- \frac{N d^3}{71785 r^4} \le 0,\\ g_2(\textbf{x})&=&\frac{ d (4 d-r)}{12566 r^3 (d-r)} +\frac{1}{5108 r^2}-1 \le 0, \end{array} $$
(12)
$$ g_3(\textbf{x})= 1-\frac{ 140.45 r }{d^2 N} \le 0, \quad g_4(\textbf{x})=(d+r) -1.5 \le 0. $$
(13)

Some simple bounds or limits for the design variables are

$$ 0.05 \le r \le 2.0, \quad 0.25 \le d \le 1.3, \quad 2.0 \le N \le 15.0. $$
(14)

Using the proposed MSCS with the same parameter settings given in the “Parameter Settings” section, the results of 20 different runs are summarized in Table 3 where comparison is also made. As we can see, MSCS can obtain the best or the same results as the best results in the literature.

Table 3 Comparison of optimal solutions for spring design
Full size table

Pressure Vessel Design

A well-known design benchmark is the pressure vessel design problem that has been used by many researchers. This design is to minimize the overall cost of a cylindrical vessel subject to stress and volume requirements. There are four design variables: the thickness d1 and d2 for the head and body, respectively, the inner radius r, and the length W of the cylindrical section [6, 9]. The main objective is

$$\begin{array}{@{}rcl@{}} \min f(\textbf{x})&=&06224 r W d_1 + 1.7781 r^2 d_2 + 19.64 r d_1^2 \\ &&+ 3.1661 W d_1^2, \end{array} $$
(15)

subject to four constraints:

$$ g_1(\textbf{x})\,=\,-d_1 + 0.0193 r \!\le\! 0, \quad g_2(\textbf{x})\,=\,-d_2 + 0.00954 r \le 0, $$
(16)
$$\begin{array}{@{}rcl@{}} g_3(\textbf{x})&=&- \frac{4 \pi r^3}{3} - \pi r^2 W -1296000 \le 0, \\ g_4(\textbf{x}) &=&W -240 \le 0. \end{array} $$
(17)

The inner radius and length are limited to 10.0 ≤ r, W ≤ 200.0. However, the thickness d1 and d2 can only be the integer multiples of a basic thickness of 0.0625 in. Thus, the simple bounds for thickness are

$$ 1 \times 0.0625 \le d_1, d_2 \le 99 \times 0.0625. $$
(18)

With these additional constraints, this optimization problem becomes a mixed integer programming because two variables are discrete and the other two variables are continuous.

Using the same parameter settings as before, the results of 20 independent runs are summarized and compared in Table 4. In fact, all these algorithms can find the global optimal solution as found by Yang et al. [47].

Table 4 Comparison of optimal solutions for pressure vessel design
Full size table

Speed Reducer Design

The speed reducer design is an engineering design benchmark with seven design variables. These design variables include the face width of the gear, number of teeth, and diameter of the shaft and others [18]. All these variables can take continuous values, except for x3 which is an integer.

The objective to minimize the cost function

$$\begin{array}{@{}rcl@{}} f(\textbf{x})&=&0.7854 \left[x_{1} {x_{2}^{2}} (3.3333 {x_{3}^{2}} + 14.9334x_{3}-43.0934 )\right.\\ &&\quad\quad\quad\left.+ (x_{4} {x_{6}^{2}}+x_{5} {x_{7}^{2}}) \right]\\ &&-1.508 x_1 (x_6^2+x_7^2)+ 7.4777 (x_6^3+x_7^3), \end{array} $$
(19)

subject to 11 constraints:

$$ g_1(\textbf{x})=\frac{27}{x_1 x_2^2 x_3}-1 \le 0, \quad g_2(\textbf{x})=\frac{397.5}{x_1 x_2^2 x_3^2} -1 \le 0, $$
(20)
$$ g_3(\textbf{x})=\frac{1.93 x_4^3}{x_2 x_3 x_6^4}-1 \le 0, \quad g_4(\textbf{x})=\frac{1.93 x_5^3}{x_2 x_3 x_7^4}-1 \le 0, $$
(21)
$$ g_5(\textbf{x}) =\frac{1.0}{110 x_6^3} \sqrt{(\frac{745.0 x_4}{x_2 x_3})^2 + 16.9 \times 10^6}-1 \le 0, $$
(22)
$$ g_6(\textbf{x}) =\frac{1.0}{85 x_7^3} \sqrt{(\frac{745.0 x_5}{x_2 x_3})^2 + 157.5 \times 10^6 }-1 \le 0, $$
(23)
$$ g_7(\textbf{x})=x_2 x_3-40 \le 0, \quad g_8(\textbf{x})= 5 x_2 -x_1 \le 0, $$
(24)
$$ g_9(\textbf{x}) =x_1 -12 x_2 \le 0, \quad g_{10}(\textbf{x})=(1.5 x_6 + 1.9) - x_4 \le 0, $$
(25)
$$ g_{11}(\textbf{x}) =(1.1 x_7 + 1.9) - x_5 \le 0. $$
(26)

In addition, the simple bounds for the variables are 2.6 ≤ x1 ≤ 3.6, 0.7 ≤ x2 ≤ 0.8, 17 ≤ x3 ≤ 28 (integers only), 7.3 ≤ x4 ≤ 8.3, 7.8 ≤ x5 ≤ 8.4, 2.9 ≤ x6 ≤ 3.9, and 5.0 ≤ x7 ≤ 5.5.

The results of 20 independent runs are summarized in Table 5 where comparison has also been made. As we can see, MSCS obtained the best result. Since there is no literature about the analysis of this problem, no one knows what the global best solution should be. Thus, we can only say that 2993.749589 is the best result achieved so far.

Table 5 Comparison of optimal solutions for the speed reducer problem
Full size table

Parameter Identification of Vibrations

For a simple vibration problem, two unknown parameters μ and ν are estimated from the measurements of vibration amplitudes. The governing equation is

$$ \frac{d^2 y(t)}{dt^2} + \mu \frac{dy(t)}{dt}+\nu y(t)= 40 \cos (3 t). $$
(27)

This is a damped harmonic motion problem and its general solution can be quite complex [48]. However, for fixed μ = 4 and ν = 5 with initial values of y(0) = 0 and y′(0) = 0, its analytical solution can be simplified as

$$ y(t)=e^{-2t} [\cos(t)-7 \sin (t)]+ 3 \sin(3 t)-\cos (3 t). $$
(28)

For a real system with a forcing term 40cos(3t), we do not know the parameters, but its vibrations can be measured. For example, in an experiment, there are N = 11 measurements as shown in Table 6.

Table 6 Measured response of a simple vibration system.
Full size table

The task is to estimate the values of the two parameters. However, one of the challenges is that the calculation of the objective function that is defined as the sum of errors squared. That is

$$ f(\textbf{x})=\sum\limits_{i = 1}^{N} (y_{i,\text{predicted}} - y_{i,d})^2, $$
(29)

where the predicted y(t) has to be obtained by solving the second-order ordinary differential (27) numerically and iteratively for every given set of μ and ν. This becomes a series of optimization problems.

Using the MSCS with a population of 40 cuckoos and the same parameter setting given in the “Parameter Settings” section. We have run the algorithm for 20 times so as to obtain meaningful statistics. The mean values of the two parameters obtained from the measured data are μ∗ = 4.025 and ν∗ = 4.981, which are very close to the true values of μ = 4.000 and ν = 5.000.

Iris Classification

To test the MSCS algorithm even further, we use it to solve the classification problem of the well-known Fisher’s Iris flower data set. This data set has 150 data points or instances with 4 attributes and 3 distinct classes [14]. We use the data from the UCI Machine Learning Repository.Footnote 1

We have encoded the centers of clusters as solution vectors so as to minimize the overall intra-clustering distances. Although the parameter settings are the same as before, the number of iterations is limited to 100 so as to be comparable with the results from the literature [4]. The best values obtained are compared with the results obtained by other methods such as the hybrid k-means and PSO approach [19], multiple kernel-based fuzzy c-means with cuckoo search [4], and k-means with improved feature based cluster center initialization algorithm (CCIA) [20].

The optimization results are summarized in Table 7. As we can clearly see, MSCS obtained the best result that is an improvement over the best results obtained by multiple kernel fuzzy c-means based cuckoo search approach (MKF-cuckoo) [4].

Table 7 Accuracy comparison for Iris data set
Full size table

The results and simulation we have obtained so far are indeed encouraging. Obviously, we will carry out more thorough evaluations of the proposed approach in the future work. So let us summarize the work we have achieved so far in this paper.

Discussions

The original cuckoo search has been extended to capture more realistic characteristics of cuckoo-host co-evolution systems. We have developed a multi-species cuckoo search for solving global optimization problems, based on the main characteristics of multiple cuckoo species competing and co-evolving with host species. Then, we have tested the proposed approach using a set of 15 function benchmarks to show that the proposed algorithm can indeed work well. Preliminary results suggest that MSCS can have a higher convergence rate and obtain better results in general. In addition, we have used five different case studies from engineering designs, parameter estimation and data clustering to further test the proposed algorithm. Our simulation results and subsequent comparison have shown that the MSCS can indeed find the optimal solutions that are either better and comparable with the results obtained by other methods.

The essence of multi-species co-evolution is to use more than one species so as to see how different species interact and compete. In the present studies, we have just used two cuckoo species in the cuckoo-host co-evolution. Future work will focus on more than two cuckoo species and more detailed parametric studies with varied population sizes. In addition, it would be useful to gain more insight by tuning the key parameters in the algorithm to see how they may affect the overall performance of the algorithm.

Furthermore, in the real-world cuckoo-host co-evolution systems, there are multiple cuckoo species interacting with multiple host species, which can have much more complex behaviour and characteristics. For example, the common cuckoos can lay eggs in many different host species including garden warblers and reed warblers [27]. In reality, the number of eggs laid by cuckoos and inside nests can be random. The current approach with the preliminary tests consists of only a single host species with multiple cuckoo species. Therefore, a possible extension can include multiple host bird species compete and co-evolve with multiple cuckoo species. In addition, it can also be useful to carry out further tests of this algorithm using a more extensive set of benchmarks and real-world case studies.