A generalized evolutionary metaheuristic (GEM) algorithm for engineering optimization

Abstract

Many optimization problems in engineering and industrial design applications can be formulated as optimization problems with highly nonlinear objectives, subject to multiple complex constraints. Solving such optimization problems requires sophisticated algorithms and optimization techniques. A major trend in recent years is the use of nature-inspired metaheustic algorithms (NIMA). Despite the popularity of nature-inspired metaheuristic algorithms, there are still some challenging issues and open problems to be resolved. Two main issues related to current NIMAs are: there are over 540 algorithms in the literature, and there is no unified framework to understand the search mechanisms of different algorithms. Therefore, this paper attempts to analyse some similarities and differences among different algorithms and then presents a generalized evolutionary metaheuristic (GEM) in an attempt to unify some of the existing algorithms. After a brief discussion of some insights into nature-inspired algorithms and some open problems, we propose a generalized evolutionary metaheuristic algorithm to unify more than 20 different algorithms so as to understand their main steps and search mechanisms. We then test the unified GEM using 15 test benchmarks to validate its performance. Finally, further research topics are briefly discussed.

Keywords:

• Algorithm
• derivative-free algorithm
• evolutionary computation
• metaheuristic
• nature-inspired computing
• swarm intelligence
• optimization

Reviewing Editor:

• Dr Pham D T, Engineering, University of Birmingham, United Kingdom of Great Britain and Northern Ireland

Subjects:

• Computation
• Evolutionary Computing
• Artificial Intelligence
• Optimization
• Algorithms & Complexity

1. Introduction

Many design problems in engineering and industry can be formulated as optimization problems subject to multiple nonlinear constraints. To solve such optimization problems, sophisticated optimization algorithms and techniques are often used. Traditional algorithms such as Newton-Raphson method are efficient, but they use derivatives and calculations of these derivatives, especially the second derivatives in a high-dimensional space, can be costly. In addition, such derivative-based algorithms are usually local search and the final solutions may depend on the starting point if optimization problems are highly nonlinear and multimodal (Boyd & Vandenberghe, 2004; Yang, 2020a). An alternative approach is to use derivative-free algorithms and many evolutionary algorithms, especially recent nature-inspired algorithms, do not use derivatives (Kennedy & Eberhart, 1995; Pham et al., 2005; Storn & Price, 1997; Yang, 2020b). These nature-inspired metaheuristic algorithms are flexible and easy to implement, and yet they are usually very effective in solving various optimization problems in practice.

Algorithms have been important through history (Beer, 2016; Chabert, 1999; Schrijver, 2005). There are a vast spectrum of algorithms in the literature, ranging from fundamental algorithms to combinatorial optimization techniques (Chabert, 1999; Schrijver, 2005). In some special classes of optimization problems, effective algorithms exist for linear programming (Karmarkar, 1984) and quadratic programming (Zdenek, 2009) as well as convex optimization (Bertsekas et al., 2003; Boyd & Vandenberghe, 2004). However, for nonlinear optimization problems, techniques vary and often approximations, heuristic algorithms and metaheuristic algorithms are needed. Even so, optimal solutions cannot always be obtained for nonlinear optimization.

Metaheuristic algorithms are approximation optimization techniques, and they use some form of heuristics with trial and error and some form of memory and solution selections (Glover, 1986; Glover & Laguna, 1997). Most metaheuristic algorithms are evolution-based and/or nature-inspired. Evolution-based algorithms such as genetic algorithm (Holland, 1975; Goldberg, 1989) are often called evolutionary algorithms. Algorithms such as particle swarm optimization (PSO) (Kennedy & Eberhart, 1995), bees algorithm (Pham et al., 2005; Pham & Castellani, 2009) and firefly algorithm (Yang, 2009) are often called swarm intelligence based algorithms (Kennedy et al., 2001).

However, terminologies in this area are not well defined and different researchers may use different terminologies to refer to the same things. In this paper, we use nature-inspired algorithms to mean all the metaheuristic algorithms that are inspired by some forms of evolutionary characteristics in nature, being biological, behaviour, social, physical and chemical characteristics (Yang, 2020a; Yang & He, 2019). In this broad sense, almost all algorithms can be called nature-inspired algorithms, including bees algorithms (Pham & Castellani, 2014, 2015), PSO (Kennedy et al., 2001), ant colony optimization, bat algorithm, flower pollination algorithm, cuckoo search algorithm, genetic algorithm, and many others.

Nature-inspired algorithms have become popular in recent years, and it is estimated that there are several hundred algorithms and variants in the current literature (Yang, 2020a), and the relevant literature is expanding with more algorithms emerging every year. An exhaustive review of metaheuristic algorithms by Rajwar et al. (2023) indicated that there are over 540 metaheuristic algorithms with over 350 of such algorithms that were developed in the last 10 years. Many such new variants have been developed based on different characteristics/species from nature, social interactions and/or artificial systems, or based on the hybridization of different algorithms or algorithmic components, or based on different strategies of selecting candidate solutions and information sharing characteristics (Mohamed et al., 2020; Rajwar et al., 2023; Zelinka, 2015).

From the application perspective, nature-inspired algorithms have been shown that they can solve a wide range of optimization problems (Abdel-Basset & Shawky, 2019; Bekasş et al., 2018; Osaba et al., 2016; Pham & Castellani, 2015), from continuous optimization (Pham & Castellani, 2014) and engineering design optimization problems (Bekasş et al., 2018) to combinatorial optimization problems (Ouaarab et al., 2014; Osaba et al., 2016, 2017), multi-robots systems (Palmieri et al., 2018; Rango et al., 2018) and many other applications (Gavvala et al., 2019; Mohamed et al., 2020; Rajwar et al., 2023; Zelinka, 2015).

Despite the wide applications of nature-inspired algorithms, theoretical analysis in contrast lacks behind. Though there are some rigorous analyses concerning genetic algorithm (Greenhalgh & Marshal, 2000), PSO (Clerc & Kennedy, 2002) and the bat algorithm (Chen et al., 2018), however, many new algorithms have not been analyzed in detail. Ideally, a systematical analysis and review should be carried out in the similar way to convex analysis (Bertsekas et al., 2003) and convex optimization (Boyd & Vandenberghe, 2004). In addition, since there are so many different algorithms, it is difficult to figure out what search mechanisms can be effective in determining the performance of a specific algorithm. Furthermore, some of these 540 algorithms can look very similar, either in terms of their search mechanisms or updating equations, though they may look very different on the surface. This often can cause confusion and frustration to readers and researchers to see what happens in this research community. In fact, there are many open problems and unresolved issues concerning nature-inspired metaheuristic algorithms (Rajwar et al., 2023; Yang et al., 2018; Yang & He, 2019; Yang, 2020b).

Therefore, the purpose of this paper is two-fold: outlining some of the challenging issues and open problems, and then developing a generalized evolutionary metaheuristic (GEM) to unify many existing algorithms. The rest of the paper is organized as follows. Section 2 first provides some insights into nature-inspired computing and then outlines some of the open problems concerning nature-inspired algorithms. Section 3 presents a unified framework of more than 20 different algorithms so as to look all the relevant algorithms in the same set of mathematical equations. Section 4 discusses 15 benchmark functions and case studies, whereas Section 5 carries out some numerical experiments to test and validate the generalized algorithm. Finally, Section 6 concludes with a brief discussion of future research topics.

2. Insights and open problems

Though not much systematical analysis of nature-inspired algorithms exist, various studies from different perspectives have been carried out and different degrees of insights have been gained (Eiben & Smit, 2011; Ser et al., 2019; Yang, 2020b). For any given nature-inspired algorithm, we can analyze its algorithmic components, and their role in exploration and exploitation, and we also study its search mechanism so as to understand ways that local search and global search moves are carried out. Many studies in the literature have provided numerical convergence curves during iterations when solving different function optimization and sometimes real-world case studies, and such convergence curves are often presented with various statistical quantities according to a specific set of performance metrics such as accuracy of the solution and successful rate as well as number of iterations. In addition, stability and robustness are also studies for some algorithms (Clerc & Kennedy, 2002). Such analyses, though very important, are largely qualitative studies of algorithmic features, as summarized in Figure 1.

Figure 1. Analysis of algorithmic features such as components, mechanisms and stability.

The analysis of algorithms can be carried out more rigorously from a quantitative perspective, as shown in Figure 2. For a given algorithm, it is possible to analyze the iterative behaviour of the algorithm using fixed-point theory. However, the assumptions required for such theories may not be realistic or relevant to the actual algorithm under consideration. Thus, it is not always possible to carry out such analysis. One good way is to use complexity theory to analyze an algorithm to see its time complexity. Interestingly, most nature-inspired algorithms have the complexity of $O(\mathit{\text{nt}})$ where n is the typically population size and t is the number of iterations. It is still a mystery that how such low complexity algorithms can solve highly complex nonlinear optimization problems that have been shown in various applications.

Figure 2. Different perspectives for quantitative analysis of algorithms.

From the dynamical system point of view, an algorithm is a system of updating equations, which can be formulated as a discrete dynamical system. The eigenvalues of the main matrix of such a system determine the main characteristics of the algorithm. It can be expected that these eigenvalues can depend on the parameter values of the algorithm, and thus parameter settings can be important. In fact, the analyses on PSO (Clerc & Kennedy, 2002) and the bat algorithm (Chen et al., 2018) show that parameter values are important. If the parameter values are in the wrong ranges, the algorithm may become unstable and become less effective. This also indicates the important of parameter tuning in nature-inspired algorithms (Eiben & Smit, 2011; Joy et al., 2023). However, parameter tuning itself is a challenging task because its aim is to find the optimal parameter setting for an optimization algorithm for a given set of optimization problems.

From the probability point of view, an algorithm can be considered as a set of interacting Markov chains, thus it is possible to do some approximation analysis in terms of convergence using Markov chain Monte Carlo (MCMC) theory (Chen et al., 2018). However, the conditions required for MCMC can be stringent, and thus not all algorithms can be analyzed in this way. From the perspective of the analysis of variance, it is possible to see how the variances may change with iteration to gain some useful understanding (Zaharie, 2009).

An alternative approach is to use Bayesian statistical framework to gain some insights into the algorithm under analysis. Loosely speaking, the initialization of the population in an algorithm with a given probability distribution forms the prior of the algorithm. When the algorithm evolves and the solutions also evolve, leading to a posterior distribution of solutions and parameters. Thus, the evolution of algorithm can be understood from this perspective. However, since Bayesian framework often requires a lot of extensive integral evaluations, it is not straightforward to gain rigorous results in general.

A more ambition approach is to build a mathematical framework so as to analyze algorithms in a unified way, though such a framework does not exist in the current literature. Ideally, a theoretical framework should provide enough insights into the rise of swarm intelligence, which is still an open problem (Yang, 2020b; Yang & He, 2019).

As we have seen, algorithms can potentially be analyzed from different perspectives and there are many issues that need further research in the general area of swarm intelligence and nature-inspired computation. We can highlight a few important open problems.

1. Theoretical framework. Though there are some good theoretical analyses of a few algorithms such as genetic algorithm (Greenhalgh & Marshal, 2000), PSO (Clerc & Kennedy, 2002) and the bat algorithm (Chen et al., 2018), there is no unified theoretical framework that can be used to analyze all algorithms or at least a major subset of nature-inspired algorithms. There is a strong need to build a mathematical framework so that the convergence and rate of convergence of any algorithm can be analyzed with rigorous and quantitative results.

   In addition, stability of an algorithm and its robustness should also be analyzed using the same mathematical framework, based on theories such as dynamical systems and perturbation as well as probability. The insights gained from such a theoretical framework should provide enough guidance for tuning and setting parameter values for a given algorithm. However, how to construct this theoretical framework is still an open problem. It may be that a multidisciplinary approach is needed to ensure to look at algorithms from different perspectives.

2. Parameter tuning. The setting of parameters in an algorithm can influence the performance of an algorithm, though the extent of such influence may largely depend on the algorithm itself and potentially on the problem to be solved (Joy et al., 2023). There are different methods for parameter tuning, but it is not clear which method(s) should be used for a given algorithm. In addition, different tuning methods may produce different results for parameter settings for different problems, which may leads to the question if a truly optimal parameter setting exists. It seems that there are different optimality conditions concerning parameter setting (Joy et al., 2023; Yang et al., 2013), and parameter settings may be both algorithm-dependent and problem-dependent, depending on the performance metric used for tuning. Many of these questions remain unresolved.

3. Benchmarking. All new algorithms should be tested and validated using a diverse of set of benchmarks and case studies. In the current literature, one of the main issues is that most tests use smooth functions as benchmarks, and it seems that these functions have nothing to do with real-world applications. Thus, it is not clear how such tests can actually validate the algorithm to gain any insight into the potential performance of the algorithm to solve much more complicated real-world applications. There is a strong need to systematically investigate the role of benchmarking and what types of benchmarks and case studies should be used.

4. Performance metrics. It can be expected that the performance of an algorithm depends on the performance metrics used to measure the performance. In the current literature, performance measures are mostly accuracy compared to the true objective values, success rate of multiple functions, number of iterations as computational efforts, computational time, and the combination of these measures. Whether these measures are fair or sufficient is still unexplained. In addition, these performance metrics tend to lead to the ranking of algorithms used and the benchmark functions used. Again, this may not be consistent with the no-free-lunch theorems (Wolpert & Macready, 1997). It is not clear if other performance measures should be designed and used, and what theory should be based on to design performance metrics. All these are still open questions.

5. Search mechanism. In many nature-inspired metaheuristic algorithms, certain forms of randomization and probability distributions are used to generate solutions with exploration abilities. One of the main tasks is to balance exploration and exploitation or diversification and intensification using different search moves or search mechanisms. However, how to balance these two components is still an open problem. In addition, exploration is usually by randomness, random walks and perturbations, whereas exploitation is usually by using derivative information and memory. It is not clear what search moves can be used to achieve both exploration and exploitation effectively.

6. Scalability. Most studies of metaheuristic algorithms in the literature are concerned with problems with a few parameters or a few dozen parameters. These problems, though very complicated and useful, are small-scale problems. It is not clear if the algorithms used and the implementation realized can directly be applied to large-scale problems in practice. Simple scale up by using high-performance computing or cloud computing facilities may not be enough. How to scale up to solve real-world, large-scale problems is still a challenging issue. In fact, more efficient algorithms are always desirable in this context.

7. Rise of Swarm Intelligence. Various discussions about swarm intelligence have attracted attention in the current literature. It is not clear what swarm intelligence exactly means and what conditions are necessary to achieve such collective intelligence. There is a strong need to understand swarm intelligence theoretically and practically so as to gain insights into the rise of swarm intelligence. With newly gained insights, we may be able to design better and more effective algorithms.

In addition, from both theoretical perspective and practical point of view, the no-free lunch theorems (Wolpert & Macready, 1997) had some significant impact on the understanding of algorithm behaviour. Studies also indicate that free lunches may exist for co-evolution (Wolpert & Macready, 2005), continuous problems (Auger & Teytaud, 2010) and multi-objective optimization (Corne & Knowles, 2003; Zitzler et al., 2003) under certain conditions. The main question is how to use such possibilities to build more effective algorithms.

3. A generalized evolutionary metaheuristic (GEM) for optimization

From the numerical algorithm analysis point of view (Boyd & Vandenberghe, 2004; Yang, 2020a), an algorithm in essence is a procedure to modify the current solution ${\mathit{x}}^t$ so as to produce a potentially better solution ${\mathit{x}}^{t+1}.$ The well-known Newton’s method at iteration t can be written as (1) $${\mathit{x}}^{t+1}={\mathit{x}}^t-\frac{\nabla f({\mathit{x}}^t)}{{\nabla }^{2}f({\mathit{x}}^t)},$$(1) where $\nabla f$ is the gradient vector of the objective function at ${\mathit{x}}^t$ and ${\nabla }^{2}f$ is the Hessian matrix. Loosely speaking, all iterative algorithms can schematically be written as (2) $${\mathit{x}}^{t+1}={\mathit{x}}^t+\mathit{S}({\mathit{x}}^t,{\mathit{x}}^{*},p_1,\dots ,p_k),$$(2) where S is a step size vector, which can in general depend on the current solution ${\mathit{x}}^t,$ the current best solution ${\mathit{x}}^{*},$ and a set of parameters ($p_1,\dots ,p_k$). Different algorithms may differ only in the ways of generating such steps.

In addition to the open problems highlighted above, the other purpose of this paper is to provide a unified algorithm framework, based on more than 20 existing nature-inspired algorithms. This unification may enable us to understand the links and difference among different algorithms. It also allows us to build a single generic algorithm that can potentially use the advantages of all its component algorithms, leading to an effective algorithm.

As we have mentioned earlier, there are approximately 540 metaheuristic algorithms and variants in the literature (Rajwar et al., 2023), it is impossible to test all algorithms and try to provide a unified approach. This paper is the first attempt to unify multiple algorithms in the same generalized evolutionary perspective. Thus, we have to select over twenty algorithms to see if we can achieve our aim. Obviously, there are two challenging issues: how many algorithms we should use and which algorithms we should choose. For the former question, we think it makes sense that we should choose at least ten different algorithms or more so that we can get a reasonable picture of the unification capabilities. In fact, we have chosen 22 algorithms for this framework. As for the latter question which algorithms to use, it is almost impossible to decide what algorithms to use from 540 algorithms. In the end, the algorithms we have chosen here have different search features or characteristics in terms of their exploration and exploitation capabilities. In addition, in the case of similar exploration and exploitation capabilities, we tend to select the slightly well-established algorithms that appeared earlier in the literature because later/new algorithms may have been based on such mechanisms.

This unified algorithm is called Generalized Evolutionary Metaheuristic (GEM) with multiple parameters and components to unify more than 20 algorithms.

A solution vector x in the D-dimensional space is denoted by (3) $$\mathit{x}=(x_1,x_2,\dots ,x_D).$$(3)

For a set of n solution vectors ${\mathit{x}}_i$ where $i=1,2,\dots ,n,$ these vectors evolve with the iteration t (the pseudo-time) and they are denoted by ${\mathit{x}}_i^t.$ Among these n solutions, there is one solution ${\mathit{g}}_{*}$ that gives the best objective value (i.e. highest for maximization or lowest for minimization). For minimization, (4) $${\mathit{g}}_{*}=\text{argmin}\{f({\mathit{x}}_i^t),f({\mathit{x}}_i^{*}),f({\overline{\mathit{x}}}_g)\},\hspace{1em}(\text{for minimization}),$$(4) where the argmin is to find the corresponding solution vector with the best objective value. Here, ${\overline{\mathit{x}}}_g$ is the average of the top m best solutions among n solutions ($m\le n$). That is (5) $${\overline{\mathit{x}}}_g=\frac{1}{m}\sum _{j=1}^m{x}_j.$$(5)

In case of m = n, this becomes the centre of the gravity of the whole population. Thus, we can refer to this step as the centrality move.

The main updating equations for our proposed unified algorithm are guided randomization and position update. In the guided randomization search step, it consists of (6) $${\mathit{v}}_i^{t+1}=\underset{\text{inertia term}}{\underbrace{p{\mathit{v}}_i^t}}+\underset{\text{motion towards current best}}{\underbrace{q{ϵ}_1({\mathit{g}}_{*}-{\mathit{x}}_i^t)}}+\underset{\text{motion to individual best}}{\underbrace{r{ϵ}_2({\mathit{x}}_i^{*}-{\mathit{x}}_i^t)}}.$$(6)

In the position update step, it means (7) $${\mathit{x}}_{i,\mathit{\text{new}}}^{t+1}=a{\mathit{x}}_i^t+\underset{\text{Centrality}}{\underbrace{(1-a){\overline{\mathit{x}}}_g}}+\underset{\text{similarity convergence}}{\underbrace{b({\mathit{x}}_j^t-{\mathit{x}}_i^t)}}+\underset{\text{kinetic motion}}{\underbrace{c{\mathit{v}}_i^{t+1}}}+\underset{\text{perturbation}}{\underbrace{\Theta h({\mathit{x}}_i^t){\zeta }_i}},$$(7) where $a,b,c,\Theta ,$ p, q, and r are parameters, and ${\mathit{x}}_i^{*}$ is the individual best solution for agent or particle i. Here, $h({\mathit{x}}_i^t)$ is a function of current solution, and in most case we can set $h({\mathit{x}}_i^t)=1,$ which can be a constant. In addition, ζ_i is a vector of random numbers, typically drawn from a standard normal distribution. That is (8) $${\zeta }_i\sim \mathcal{N}(0,1).$$(8)

It is worth pointing out the effect of each term can be different, and thus we can name each term, based on their effect and meaning. The inertia term is $p{\mathit{v}}_i^t,$ whereas the $q{ϵ}_1({\mathit{g}}_{*}-{\mathit{x}}_i^t)$ simulates the motion or move towards the current best solution. The term $r{ϵ}_2({\mathit{x}}_i^{*}-{\mathit{x}}_i^t)$ means to move towards the individual best solution. The centrality term has a weighting coefficient $(1-a),$ which tries to balance between the importance of the current solution ${\mathit{x}}_i^t$ and the importance of the centre of gravity of the swarm ${\overline{\mathit{x}}}_g.$ The main term $b({\mathit{x}}_j^t-{\mathit{x}}_i^t)$ shows similar solutions should converge with subtle or minor changes. $c{\mathit{v}}_i^t$ is the kinetic motion of each solution vector. The perturbation term $\Theta h({\mathit{x}}_i^t){\zeta }_i$ is controlled by the strength parameter Θ where $h({\mathit{x}}_i)$ can be used to simulate certain specialized moves for each solution agent. If there is no specialization needed, $h({\mathit{x}}_i)=1$ can be used.

The selection and acceptance criterion for minimization is (9) $${\mathit{x}}_i^{t+1}=\{\begin{array}{cc}{\mathit{x}}_{i,\mathit{\text{new}}}^t\hfill & \text{if}f({\mathit{x}}_{i,\mathit{\text{new}}}^{t+1})\le f({\mathit{x}}_i^t),\hfill \\ \hfill & \hfill \\ {\mathit{x}}_i^t\hfill & \text{otherwise}.\hfill \end{array}$$(9)

These four main steps/equations are summarized in the pseudocode, shown in Algorithm 1 where the initialization of the population follows the standard Monte Carlo randomization (10) $${\mathit{x}}_i=\mathit{\text{Lb}}+\mathit{\text{rand}}(1,D)(\mathit{\text{Ub}}-\mathit{\text{Lb}}),$$(10) where Lb and Ub are, respectively, the lower bound and upper bound of the feasible decision variables. In addition, rand(1,D) is a vector of D random numbers drawn from a uniform distribution.

Special cases can correspond to more than 20 different algorithms. It is worth pointing out that in many case there are more than one way to represent the same algorithm by setting different values of parameters. The following representations are one of the possible ways for representing these algorithms:

1. Differential evolution (DE) (Price et al., 2005; Storn & Price, 1997): a = 1, b = F, c = 0 and Θ = 0.

2. Particle swarm optimization (PSO) (Kennedy & Eberhart, 1995; Kennedy et al., 2001): a = 1, b = 0, p = 1, c = 1, and Θ = 0. In addition, $q=\alpha$ and $r=\beta .$

3. Firefly algorithm (FA) (Yang, 2009, 2013): a = 1, $b=\beta \hspace{0.17em}\mathrm{\text{exp}}\hspace{0.17em}(-\gamma r_{\mathit{\text{ij}}}^2),$ c = 0 and $\Theta ={0.97}^t.$

4. Simulated annealing (SA) (Kirkpatrick et al., 1983): a = 1, $b=c=0$ and Θ = 1.

5. Artificial bee algorithm (ABC) (Karaboga & Basturk, 2008): a = 1, $b=\Phi \in [-1,1],$ c = 0 and Θ = 0.

6. Artificial cooperative search (ACS) (Civicioglu, 2013): a = 1, b = R. c = 0, Θ = 0 and its two predator keys are drawn from its α and β.

7. Charged system search (CSS) (Kaveh & Talatahari, 2010): a = 1, $b=A(R)$ where R is the normalized distance with the maximum at R = 1. In addition, c = 0 and Θ = 0.

8. Cuckoo search (CS) (Yang & Deb, 2010): a = 1, c = 0, and $b=\alpha \mathit{\text{sH}}(p_a-ϵ)$ where α is a scaling parameter, H is a Heaviside function with a switch probability p_a and a uniformly distributed random number ϵ. The step size s is drawn from a Lévy distribution. The other branch with the switch probability p_a is a = 1, $b=c=0,$ Θ = 1, but ζ is drawn from the Lévy distribution $$L(s,\beta )\sim \frac{\beta \Gamma (\beta )\hspace{0.17em}\mathrm{\text{sin}}\hspace{0.17em}(\pi \beta /2)}{\pi }\frac{1}{s^{1+\beta }},\hspace{1em}\beta =1.5,$$ where Γ is the standard Gamma function.

9. Gravitational search algorithm (GSA) (Rashedi et al., 2009): a = 1, $p=$ rand $\in [0,1],$ $q=r=0,$ c = 1 and Θ = 0. In addition, $b=$ rand $*G(t)$ where $G(t)=G_0\hspace{0.17em}\mathrm{\text{exp}}\hspace{0.17em}(-\alpha t/T).$

10. Gradient evolution algorithm (GEA) (Kuo & Zulvia, 2015): a = 1, c = 0 and Θ = 0, but $$b=r_g\Delta x_{\mathit{\text{ij}}}^t/2(x_{\mathit{\text{ij}}}^w-x_{\mathit{\text{ij}}}^t+x_{\mathit{\text{ij}}}^B).$$ In addition, the parameter is set to r_a = 0 in GEA.

11. Harris hawk optimizer (HHO) (Heidari et al., 2019): a = 1, b = 0, c = 1, Θ = 0, p = 0, r = 0, and $q=-E$ where E varies with iteration t.

12. Henry gas solubility optimization (HGSO) (Hashim et al., 2019): a = 1, b = r, c = 1 and Θ = 0. In addition, p = 1 and r = 0, but q is related to the solubility affected by the Henry constant and parochial pressure. Here, the Henry’s constant changes with iteration t by $H_j^{t+1}=H_j^t\hspace{0.17em}\mathrm{\text{exp}}[-C_j(1/T(t)-1/T_0)]$ where $T_0=298.15$ K, C_j is a given constant and $T(t)=e^{-t/t_{\mathrm{\text{max}}}}.$

13. Harmony search (HS) (Geem et al., 2001): a = 0, $b=c=0,$ Θ = 1, $h(\mathit{x})={\mathit{x}}_i^t$ for pitch adjustment, but for harmony selection b = 1 and Θ = 0 can be used.

14. Ant lion optimizer (ALO) (Mirjalili, 2015): a = 1, b = 0, c = 1, $\Theta =d_i-c_i$ where d_i is the scaled random walk length and c_i is its corresponding minimum. In addition, p = 0, q = 0, r = 1 with some variation of ${\mathit{g}}_{*}$ is just the average of two selected elite ant-lion solutions.

15. Whale optimization algorithm (WOA) (Mirjalili & Lewis, 2016): a = 1, c = 0, $p=q=r=0,b=-A$ where $A=2\mathit{\text{dr}}-a$ with r be drawn randomly from $[0,1]$ and d be linearly decreasing from 2 to 0. In their spiral branch, Θ = 1 with an equivalent $b=e^R\hspace{0.17em}\mathrm{\text{cos}}\hspace{0.17em}(2\pi R)$ where R is uniformly distributed in [[−1, 1].

16. Lion optimization algorithm (LOA) (Yazdani & Jolai, 2016): a = 1, b = 0, c = 1, Θ = 0, p = 0, $q=-\mathit{\text{PI}},$ and r = 0. In the other moving branch in their LOA, Θ is proportional to $\mathit{\text{DR}}$ where D is their scaled distance and R can be drawn either from [0, 1] or [−1, 1].

17. Mayfly optimization algorithm (MOA) (Zervoudakis & Tsafarakis, 2020): a = 1, b = 0, c = 1, Θ = 0, p = g, $q=a_1\hspace{0.17em}\mathrm{\text{exp}}\hspace{0.17em}(-\beta r_p^2),$ and $r=a_2\hspace{0.17em}\mathrm{\text{exp}}\hspace{0.17em}(-\beta r_g^2).$

18. Big bang-big crunch (BBBC) (Erol & Eksin, 2006): the modification of solutions is mainly around the centre of gravity ${\mathit{x}}_g$ of the population with a = 0. $b=c=0,$ and $\Theta =\mathit{\text{Ub}}/t_{\mathrm{\text{max}}}.$

19. Social spider algorithm (SSA) (James & Li, 2015): a = 1, $b=w{e}^{d_{\mathit{\text{ij}}}^2}$ where w is a weight coefficient and d_ij is the distance between two spiders. In addition, c = 0, Θ = 1, $\zeta =\mathit{\text{rand}}-1/2.$

20. Moth search algorithm (MSA) (Wang, 2018): $a=\lambda ,$ b = 0, c = 1, p = 0, $q=\varphi ,$ r = 0, and Θ = 0 in one equation. The other equation corresponds to a = 1, $b=c=0,\Theta =S_{\mathrm{\text{max}}}/t^2$ and $\zeta =L(s)$ drawn from a Lévy distribution.

21. Multi-verse optimizer (MVO) (Mirjalili et al., 2016): a = 1, $b=c=0,$ but $\Theta =1-{(t/t_{\mathrm{\text{max}}})}^{1/p}$ where $t_{\mathrm{\text{max}}}$ is the maximum number of iterations. Its randomized perturbation is given by $\zeta =\pm [\mathit{\text{Lb}}+\mathit{\text{rand}}(\mathit{\text{Ub}}-\mathit{\text{Lb}})].$

22. Water cycle algorithm (WCA) (Eskandar et al., 2012): a = 1, $c=\Theta =0,b=C \mathit{\text{rand}}$ where $C\in [1,2]$ and rand is a uniformly distributed random number in [0, 1] for both water drops in river and stream in the WCA. For the additional search for the new stream step, a = 1, $b=c=0,$ but $\Theta =\sqrt{\mu }$ as its standard deviation and ζ is drawn from a Gaussian distribution with a unity mean.

Algorithm 1:

GEM: A generalized evolutionary metaheuristic for optimization.

Data: Define optimization objective ($f(\mathit{x})$) with proper constraint handling

Result: Best or optimal solution ($f_{\mathrm{\text{min}}}$) with archived solution history

1 Initialize parameter values (n, a, b, c, Θ, p, q, r);

2 Generate an initial population of n solutions using Eq. (10)(10) $${\mathit{x}}_i=\mathit{\text{Lb}}+\mathit{\text{rand}}(1,D)(\mathit{\text{Ub}}-\mathit{\text{Lb}}),$$(10) ;

3 Find the initial best solution ${\mathit{g}}_{*}$ and $f_{\mathrm{\text{min}}}$ among the initial population;

4 while ($t<$MaxGeneration) do

5  Generate random numbers (${ϵ}_1,{ϵ}_2,{\zeta }_i$);

6  for $i=1:n$ (all solutions) do

7   Modify solutions by Eq. (6)(6) $${\mathit{v}}_i^{t+1}=\underset{\text{inertia term}}{\underbrace{p{\mathit{v}}_i^t}}+\underset{\text{motion towards current best}}{\underbrace{q{ϵ}_1({\mathit{g}}_{*}-{\mathit{x}}_i^t)}}+\underset{\text{motion to individual best}}{\underbrace{r{ϵ}_2({\mathit{x}}_i^{*}-{\mathit{x}}_i^t)}}.$$(6) ;

8   Update solution vectors by Eq. (7)(7) $${\mathit{x}}_{i,\mathit{\text{new}}}^{t+1}=a{\mathit{x}}_i^t+\underset{\text{Centrality}}{\underbrace{(1-a){\overline{\mathit{x}}}_g}}+\underset{\text{similarity convergence}}{\underbrace{b({\mathit{x}}_j^t-{\mathit{x}}_i^t)}}+\underset{\text{kinetic motion}}{\underbrace{c{\mathit{v}}_i^{t+1}}}+\underset{\text{perturbation}}{\underbrace{\Theta h({\mathit{x}}_i^t){\zeta }_i}},$$(7) ;

9   Accept a solution by checking criterion Eq. (9)(9) $${\mathit{x}}_i^{t+1}=\{\begin{array}{cc}{\mathit{x}}_{i,\mathit{\text{new}}}^t\hfill & \text{if}f({\mathit{x}}_{i,\mathit{\text{new}}}^{t+1})\le f({\mathit{x}}_i^t),\hfill \\ \hfill & \hfill \\ {\mathit{x}}_i^t\hfill & \text{otherwise}.\hfill \end{array}$$(9) ;

10  end

11  Rank all the solutions to find the current best $f_{\mathrm{\text{min}}};$

12  Update the best solution so far ${\mathit{g}}_{*}$ and ${\overline{\mathit{x}}}_g$ by Eq. (4)(4) $${\mathit{g}}_{*}=\text{argmin}\{f({\mathit{x}}_i^t),f({\mathit{x}}_i^{*}),f({\overline{\mathit{x}}}_g)\},\hspace{1em}(\text{for minimization}),$$(4) ;

13  Save and archive the current population for next generation;

14  Update the iteration counter $t\leftarrow t+1;$

15 end

16 Post-process the solutions for constraint verification and visualization;

As pointed out earlier, there are more than one ways of representing an algorithm under consideration using the unified framework, and the minor details and un-important components of some algorithms may be ignored. In essence, the unified framework intends to extract the key components of multiple algorithms so that we can figure out what main search mechanisms or moves are important in metaheuristic algorithms. Therefore, it can be expected that many other algorithms may be considered as special cases of the GEM framework if the right combinations of parameter values are used.

4. Benchmarks and parameter settings

To test the unified GEM algorithm, we have selected 15 benchmark functions and case studies. There are many different test function benchmarks, including multivariate functions (Jamil & Yang, 2013), CEC2005 test suite (Suganthan et al., 2005), unconstrained benchmark function repository (Al-Roomi, 2015) and engineering optimization problems (Cagnina et al., 2008; Coello, 2000). The intention is to select a subset of optimization problems with a diverse range of properties such as modality, convexity, nonlinear constraints, separability, and landscape variations. The case studies also include a mixed-integer programming pressure vessel design problem, and a parameter estimation based on data for a vibrations system governed by an ordinary differential equation (ODE).

4.1. Test functions

The ten test functions are outlined as follows.

1. Sphere function (11) $$f_1(\mathit{x})=\sum _{i=1}^D{x}_i^2,\hspace{1em}-10\le x_i\le +10,$$(11) its global optimality $f_{\mathrm{\text{min}}}=0$ occurs at ${\mathit{x}}_{*}=(0,0,\dots ,0).$

2. Rosenbrock function (Rosenbrock, 1960) (12) $$f_2(\mathit{x})={(x_1-1)}^2+100\sum _{i=1}^{D-1}{(x_{i+1}-x_i^2)}^2,\hspace{1em}{x}_i\in [-10,10],$$(12) whose global minimum $f_{\mathrm{\text{min}}}=0$ is located at ${\mathit{x}}_{*}=(1,1,\dots ,1).$

3. Ackley function (13) $$f_3(\mathit{x})=-20\hspace{0.17em}\mathrm{\text{exp}}\hspace{0.17em}\left[-0.2\sqrt{\frac{1}{D}\sum _{i=1}^D{x}_i^2} \right]-\hspace{0.17em}\mathrm{\text{exp}}\hspace{0.17em}\left[\frac{1}{D}\sum _{i=1}^D\hspace{0.17em}\mathrm{\text{cos}}\hspace{0.17em}(2\pi x_i)\right]+20+e,$$(13) with (14) $$x_i\in [-32.768,32.768],$$(14) whose global minimum $f_{\mathrm{\text{min}}}=0$ occurs at ${\mathit{x}}_{*}=(0,0,\dots ,0).$

4. Dixon-Price function (15) $$f_4(\mathit{x})={(x_1-1)}^2+\sum _{i=2}^{D}i{(2x_i^2-x_{i-1})}^2,\hspace{1em}{x}_i\in [-10,10],$$(15) whose global minimum $f_{\mathrm{\text{min}}}=0$ at $x_i=2^{-(2^i-2)/2^i}$ for $i=1,2,\dots ,D.$

5. Schwefel function (Schwefel, 1995) (16) $$f_5(\mathit{x})=-x_1{x}_2(72-2x_1-2x_2),\hspace{1em}{x}_i\in [0,500],$$(16) its global minimum $f_{\mathrm{\text{min}}}=-3456$ occurs at ${\mathit{x}}_{*}=(12,12).$

6. Booth function (17) $$f_6(\mathit{x})={(x_1+2x_2-7)}^2+{(2x_1+x_2-5)}^2,\hspace{1em}{x}_i\in [-10,10],$$(17) whose global minimum $f_{\mathrm{\text{min}}}=0$ occurs at ${\mathit{x}}_{*}=(1,3).$

7. Holder table function (18) $$f_7(\mathit{x})=-\left|\hspace{0.17em}\mathrm{\text{sin}}\hspace{0.17em}(x_1)\hspace{0.17em}\mathrm{\text{cos}}\hspace{0.17em}(x_2)e^{\left|1-\frac{\sqrt{x_1^2+x_2^2}}{\pi }\right|}\right|,\hspace{1em}{x}_i\in [-10,10],$$(18) whose four global minima $f_{\mathrm{\text{min}}}=-19.2085$ occur at ${\mathit{x}}_{*}=(\pm 8.05502,\pm 9.66459).$

8. Beale function (19) $$f_8(\mathit{x})={(1.5-x_1+x_1{x}_2)}^2+{(2.25-x_1+x_1{x}_2^2)}^2+{(2.625-x_1+x_1{x}_2^3)}^2,$$(19) where (20) $$x_i\in [-4.5,+4.5].$$(20) The global minimum $f_{\mathrm{\text{min}}}=0$ occurs at ${\mathit{x}}_{*}=(3,0.5).$

9. Trid function (21) $$f_9(\mathit{x})=\sum _{i=1}^D{(x_i-1)}^2-\sum _{i=2}^D{x}_i{x}_{i-1},\hspace{1em}{x}_i\in [-d^2,d^2],$$(21) whose global minimum $f_{\mathrm{\text{min}}}=-D(D+4)(D-1)/6$ occurs at $x_i=i(D+1-i)$ for $i=1,2,\dots ,D.$

10. Rastrigin function (22) $$f_{10}(\mathbf{x})=10D+\sum _{i=1}^D[x_i^2-10\hspace{0.17em}\mathrm{\text{cos}}\hspace{0.17em}(2\pi x_i)],\hspace{1em}{x}_i\in [-5.12,5.12],$$(22) whose global minimum $f_{\mathrm{\text{min}}}=0$ occurs at ${\mathit{x}}_{*}=(0,0,\dots ,0).$

4.2. Case studies

The five design case studies or benchmarks are described as follows.

• 11. Spring design. The three design variables are: the wire diameter w (or x₁), mean coil diameter D (or x₂) and the number N (or x₃) of active coils. (23) $$\mathrm{\text{min }}f(\mathit{x})=(2+x_3)x_1^2{x}_2,$$(23) subject to (24) $$g_1(\mathit{x})=1-\frac{x_2^3{x}_3}{71785x_1^4}\le 0,$$(24) (25) $$g_2(\mathit{x})=\frac{4x_2^2-x_1{x}_2}{12566(x_2{x}_1^3-x_1^4)}+\frac{1}{5108x_1^2}-1\le 0,$$(25) (26) $$g_3(\mathit{x})=1-\frac{140.45x_1}{x_2^2{x}_3}\le 0,$$(26) (27) $$g_4(\mathit{x})=\frac{x_1+x_2}{1.5}-1\le 0.$$(27)

  The simple lower and upper bounds are (28) $$\mathit{\text{Lb}}=[0.05,0.25,2],\hspace{1em}\mathit{\text{Ub}}=[1.00,1.30,15].$$(28)

  The best solution found so far is (Cagnina et al., 2008; Yang, 2013) (29) $$f_{\mathrm{\text{min}}}=0.01266522,\hspace{1em}{\mathit{x}}_{*}=[0.05169,0.35673,11.2885].$$(29)

• 12. For the three-bar truss system design with two cross-section areas x₁ = A₁ and x₂ = A₂, the objective is to minimize (30) $$\mathrm{\text{min\hspace{0.5em}}}f(\mathit{x})=100(2\sqrt{2}{x}_1+x_2),$$(30) subject to (31) $$g_1(\mathit{x})=\frac{(\sqrt{2}{x}_1+x_2)P}{\sqrt{2}{x}_1^2+2x_1{x}_2}-\sigma \le 0,$$(31) (32) $$g_2(\mathit{x})=\frac{x_{2}P}{\sqrt{2}{x}_1^2+2x_1{x}_2}-\sigma \le 0,$$(32) (33) $$g_3(\mathit{x})=\frac{P}{x_1+\sqrt{2}{x}_2}-\sigma \le 0.$$(33) where σ = 2 kN/cm² is the stress limit and P = 2 kN is the load. In addition, $x_1,x_2\in [0,1].$ The best solution so far in the literature is (Bekasş et al., 2018) (34) $$f_{\mathrm{\text{min}}}=263.8958,\hspace{1em}{\mathit{x}}_{*}=(0.78853,0.40866).$$(34)

• 13. Beam design. For the beam design to support a vertical load at the free end of the beam, the objective is to minimize (35) $$\mathrm{\text{min\hspace{0.5em}}}f(\mathit{x})=0.0624(x_1+x_2+x_3+x_4+x_5),$$(35) subject to (36) $$g(\mathit{x})=\frac{61}{x_1^3}+\frac{37}{x_2^3}+\frac{19}{x_3^3}+\frac{7}{x_4^3}+\frac{1}{x_5^3}-1\le 0,$$(36) with the simple bounds $0.01\le x_i\le 100.$ The best solution found so far in the literature is (Bekasş et al., 2018) (37) $$f_{\mathrm{\text{min}}}=1.33997,\hspace{1em}{\mathit{x}}_{*}=(6.0202,5.3082,4.5042,3.4856,2.1557).$$(37)

• 14. Pressure vessel design. The main objective is to minimize (38) $$\mathrm{\text{min\hspace{0.5em}}}f(\mathit{x})=0.6224x_1{x}_3{x}_4+1.7781x_2{x}_3^2+3.1661x_1^2{x}_4+19.84x_1^2{x}_3,$$(38) subject to (39) $$g_1(\mathit{x})=-x_1+0.0193x_3\le 0,$$(39) (40) $$g_2(\mathit{x})=-x_2+0.00954x_3\le 0,$$(40) (41) $$g_3(\mathit{x})=-\pi x_3^2{x}_4-\frac{4\pi }{3}{x}_3^3+1296000\le 0,$$(41) (42) $$g_3(\mathit{x})=x_4-240\le 0.$$(42) The first two design variables must be the integer multiples of the basic thickness h = 0.0625 inches (Cagnina et al., 2008). Therefore, the lower and upper bounds are (43) $$\mathit{\text{Lb}}=[h,h,10,10],$$(43) and (44) $$\mathit{\text{Ub}}=[99h,99h,200,200].$$(44) Its true global optimal solution $f_{\mathrm{\text{min}}}=6059.714335$ occurs at (45) $$x_1=0.8125,x_2=0.4375,x_3=40.098446,x_4=\mathrm{176.636596.}$$(45)

• 14. Parameter estimation of an ODE. For a vibration problem with a unit step input, we have its mathematical equation as an ordinary differential equation (Yang, 2023) (46) $$\frac{\ddot{y}}{{\omega }^2}+2\zeta \frac{\dot{y}}{\omega }+y=u(t),$$(46) where ω and ζ are the two parameters to be estimated. Here, the unit step function is given (47) $$u(t)=\{\begin{array}{cc}0\hfill & \hspace{1em}\text{if}t<0,\hfill \\ 1\hfill & \hspace{1em}\text{if}t\ge 0.\hfill \end{array}$$(47) The initial conditions are $y(0)=y\prime (0)=0.$ For a given system, we have observed its actual response. The relevant measurements are given Table 1.In order to estimate the two unknown parameter values ω and ζ, we can define the objective function as (48) $$f(\mathit{x})=\sum _{i=0}^{10}{[y(t_i)-y_s(t_i)]}^2,$$(48) where $y(t_i)$ for $i=0,1,\dots ,10$ are the observed values and $y_s(t_i)$ are the values obtained by solving the differential equation (46)(46) $$\frac{\ddot{y}}{{\omega }^2}+2\zeta \frac{\dot{y}}{\omega }+y=u(t),$$(46) , given a guessed set of values ζ and ω. Here, we have used $\mathit{x}=(\zeta ,\omega ).$

  The true values are $\zeta =1/4$ and ω = 2. The aim of this benchmark is to solve the differential equation iteratively so as to find the best parameter values that minimize the objective or best-fit errors.

Table 1. Measured data for a vibration problem.

Time ti	1	2	3	4	5
$y(t_i)$	1.0706	1.3372	0.8277	0.9507	1.0848
Time ti	6	7	8	9	10
$y(t_i)$	0.9814	0.9769	1.0169	1.0012	0.9933

4.3. Parameter settings

In our simulations, the parameter settings are: population size n = 10 with parameter values of a = 1, b = 0.7, c = 1, p = 0.7, $q=r=1$ and $\Theta ={\theta }^t$ with $\theta =0.97.$ The maximum number of iterations is set to $t_{\mathrm{\text{max}}}=1000.$

For the benchmark functions, D = 5 is used for f₁, f₂, f₃, f₄, and f₁₀. For f₉, D = 4 is used so as to give $f_{\mathrm{\text{min}}}$ as a nice integer. For all other problems, their dimensionality has been given earlier in this section.

5. Numerical experiments and results

After implementing the algorithm using MATLAB, we have carried out various numerical experiments. This section summarizes the results.

5.1. Results for function benchmarks

For the first ten functions, the algorithm has been run 20 times so that the best $f_{\mathrm{\text{min}}},$ mean values and other statistics can be calculated. The results have been summarized in Table 2. As we can see, the algorithm can find all the true optimal solutions even with a small population size n = 10. This shows that the unified GEM algorithm is very efficient for solving function optimization problems.

Table 2. Numerical experiments for ten test functions.

	Best ($f_{\mathrm{\text{min}}}$)	Worst	Mean ($f_{\mathrm{\text{min}}}$)	True $f_{\mathrm{\text{min}}}$
Fun 1	$+1.4073e-28$	$+1.3985e-27$	$+5.2722e-28$	0
Fun 2	$+1.0192e-26$	$+4.3595e-05$	$+4.3595e-06$	0
Fun 3	$+2.6645e-15$	$+2.3981e-14$	$+9.7700e-15$	0
Fun 4	$+9.8139e-27$	$+6.6667e-01$	$+2.0000e-01$	0
Fun 5	$-3.4560e+03$	$-3.4560e+03$	$-3.4560e+03$	−3456
Fun 6	$+3.1554e-30$	$+1.8302e-28$	$+7.9359e-29$	0
Fun 7	$-1.9209e+01$	$-1.6268e+01$	$-1.8620e+01$	−19.2085
Fun 8	$+1.9586e-29$	$+7.6207e-01$	$+7.6207e-02$	0
Fun 9	$-1.6000e+01$	$-1.6000e+01$	$-1.6000e+01$	−16
Fum 10	$+0.0000e+00$	$+1.9899e+00$	$+1.1940e+00$	0

5.2. Five case studies

To test the proposed algorithm further, we have used it to solve five different case studies, subject to various constraints. The constraints are handled by the standard penalty method with a penalty coefficient λ = 1000 to 10⁵. For the pressure vessel problem, $\lambda ={10}^5$ is used, whereas all other problems use λ = 1000.

For example, in the pressure vessel design problem, the four constraints are incorporated as $P(\mathit{x})$ so that the new objective becomes (49) $$F_p(\mathit{x})=f(\mathit{x})+\lambda P(\mathit{x}),$$(49) where (50) $$P(x)=\sum _{i=1}^4\mathrm{\text{max}}\{0,g_i(\mathit{x})\},\hspace{1em}\lambda ={10}^5.$$(50)

The pressure vessel design problem is a mixed integer programming problem because the first two variables x₁ and x₂ can take only integer multiples of the basic thickness h = 0.0625 due to manufacturing constraints. The other two variables x₃ and x₄ can take continuous real values. For each case study, the algorithm has been run 10 times. For example, the 10 runs of the pressure vessel design are summarized in Table 3. As we can see, Run 2 finds a much better solution $f_{\mathrm{\text{min}}}=5850.3851$, highlighted in bold, than the best solution known so far in the literature 6059.7143. All the constraints are satisfied, which means that this is a valid new solution.

Table 3. Pressure vessel design benchmarks.

	x1	x2	x3	x4	$f_{\mathrm{\text{min}}}$
Run 1	1.2500	0.6250	64.7668	11.9886	7332.8419
Run 2	0.7500	0.3750	38.8601	221.3657	5850.3851
Run 3	1.1875	0.6250	61.5285	26.9310	7273.5127
Run 4	1.0000	0.5000	51.8135	84.5785	6410.0869
Run 5	0.8750	0.4375	45.3367	140.2544	6090.5325
Run 6	0.8750	0.4375	45.3368	140.2538	6090.5262
Run 7	0.7500	0.3750	38.8601	221.3655	5850.3831
Run 8	1.0000	0.5625	51.8135	84.5785	6708.4337
Run 9	0.8125	0.4375	42.0984	176.6366	6059.7143
Run 10	0.7500	0.4375	38.8601	221.3655	6018.2036

Following the exact same procedure, each case study has been simulated 20 times. The results for the five design case studies are summarized in Table 4. As we can see, all the best known optimal solutions have been found by the algorithm with a population size n = 10.

Table 4. Results for the five design benchmarks.

	Best ($f_{\mathrm{\text{min}}}$)	Worst	Mean ($f_{\mathrm{\text{min}}}$)	Best so far
Spring design	$1.2665e-02$	$1.2873e-02$	$1.2729e-02$	$1.2665e-02$
Truss system	$2.6389e+02$	$2.6390e+02$	$2.6390e+02$	$2.6389e+02$
Beam design	$1.3400e+00$	$5.1657e+00$	$2.3158e+00$	$1.3400e+00$
Pressure vessel	$5.8504e+03$	$7.3328e+03$	$6.3685e+03$	$6.0597e+03$
ODE parameters	$6.9479e-09$	$1.5850e-02$	$3.1700e-03$	$6.8900e-09$

The above simulations and results have shown that the unified GEM algorithm performs well for all the 15 test benchmarks, and in some cases it can achieve even better results. This indicates that this unified algorithm is effective and can potentially be applied to solve a wide range of optimization problems. This will form part of our further research.

6. Conclusion and discussion

In this paper, we have proposed a unified algorithm, called generalized evolutionary metaheuristic (GEM), which represents more than 20 different algorithms in the current literature. We have validated the proposed GEM with 15 different test benchmarks and optimal solutions have been obtained with a small population size and fixed parameters.

From the parameter tuning perspective, it can be expected that if the parameters can be tuned systematically, it may be possible to enhance the algorithm’s performance further. In fact, a systematical parameter study and parameter tuning is needed for this new algorithm, which will be carried out in our future work.

In addition, apart from more than 20 algorithms as special cases of this unified algorithm when setting different parameter values, it can be expected that the vast majority of the 540 algorithms can also be rightly represented in this unified algorithm if certain parameter are allowed to vary in certain ways and some minor differences in some algorithms can be ignored. Obviously, for some algorithms such as the genetic algorithm, the algorithm is mainly described as an algorithmic procedure without explicit mathematical formulas. Such type of algorithm may not be easily categorized into the generalized framework. However, the procedure and algorithmic flow may in essence be quite similar to some of the main framework. In addition, a systematic comparison of this general framework can be carried out with various component algorithms. This can be a useful topic for further research.

Declaration of data

No datasets were received/used. All results are simulated and reproducible from the proposed algorithms. MATLAB codes related to this work are available upon request, by emailing the author.

Disclosure statement

The author confirms that there are no relevant financial or non-financial competing interests to report.

Additional information

Funding

No funding was received for this research work.

Notes on contributors

Xin-She Yang

Xin-She Yang obtained his DPhil in Applied Mathematics from the University of Oxford. He then worked at Cambridge University and National Physical Laboratory (UK) as a Senior Research Scientist. Now he is Reader at Middlesex University London, and a co-Editor of the Springer Tracts in Nature-Inspired Computing. He is also an elected Fellow of the Institute of Mathematics and its Applications. He was the IEEE Computational Intelligence Society (CIS) chair for the Task Force on Business Intelligence and Knowledge Management (2015 to 2020). He has published more than 300 peer-reviewed research papers with more than 90,270 citations, and he has been on the prestigious list of highly-cited researchers (Web of Sciences) for eight consecutive years (2016-2023).