Surrogate-Assisted Slime Mould Algorithm Considering a Dual-Based Merit Criterion for Global Database Management

Abstract

Metaheuristic algorithms, including evolutionary approaches, are vital for solving non-trivial and non-convex optimization problems. However, real-world engineering often involves high-dimensional, expensive problems that deteriorate performance due to the substantial amount of required fitness evaluations. To address this, a growing trend utilizes evolutionary algorithms assisted by surrogate models, which limit the computational burden by providing alternatives to expensive evaluations. Leveraging the exploration capabilities of the recently developed Slime Mould Algorithm—a metaheuristic with only one tuning parameter that ignores personal best information—this work develops its surrogate-assisted counterpart: the Surrogate-Assisted Slime Mould Algorithm (SASMA). This new approach features an original database management strategy and surrogate building mechanism. To confirm its effectiveness and versatility, SASMA is tested on benchmark mathematical functions for 30 and 100 dimensions, as well as a classical truss design problem, against several surrogate-assisted and metaheuristic algorithms. The proposed SASMA achieved statistically significant improvements in both case studies, outperforming the selected benchmark algorithms on most test functions.

1. Introduction

The proliferation of population-based metaheuristic optimization algorithms, a type of stochastic optimization, and their application has been a trend in mathematical and computer optimization for the last few decades [1]. The working principle of these algorithms is to explore subsets of the search space domain, which is otherwise too large to be fully surveyed, using a population of potential solutions rather than a single candidate solution, guided by a series of heuristics that hopefully lead the search towards an optimal solution with a lower computational cost than other traditional optimization algorithms, like iterative methods [2]. Furthermore, unlike many traditional methods, metaheuristic algorithms can also handle non-continuous problems. Nevertheless, depending on the problem complexity and the specific algorithm search space mechanisms, namely the corresponding convergence properties, there is no guarantee that the global optimal solution(s) can always be found [3].

In this crowded field, swarm intelligence (SI) and evolutionary algorithms (EAs) are among the most popular choices given their ability to improve several candidate solutions in a decentralized manner, mirroring diversified types of cooperative strategies observed in nature [4]. In addition, many of these population-based metaheuristics rely on a set of randomly generated variables (within the set of heuristics/strategies) [5]. This stochastic character (randomness) has proven to be effective in the search space task by avoiding an early concentration of search agents in the same space regions, therefore mitigating the possibilities of being trapped in local optima. From the wide range of options, particle swarm optimization (PSO) [6], cuckoo search (CS) [7], differential evolution (DE) [8], whale optimization algorithm (WOA) [9], and gray wolf optimization algorithm (GWO) [10] are amidst the preferred choices to solve many engineering problems. Another feature of these algorithms is the influence of different control parameters and the population size itself, which can greatly influence global search capabilities [11], and consequently, together with the stopping criteria, determine the convergence rate towards the optimal solution.

The search space is surveyed by the population of these metaheuristic algorithms by using mechanisms that balance exploration and exploitation of the domain space [12] until the desired stopping criteria is met, and it is typically defined by a fixed number of fitness evaluations (FEs). Still, the required number of FEs can be considerable: the algorithm heuristics actively explore different regions of space to avoid a premature convergence (exploration) before engaging in the exploitation of potential optimal solutions, thus incurring a significant computation cost when dealing with expensive optimization problems. Nonlinear and non-explicit equations, computational electromagnetics analysis, mechanical design, and finite element analysis, as well as fluid dynamics, are well-known instances of the numerous engineering problems that require costly fidelity simulations [13]. Hence, in these situations the use of metaheuristics that rely upon a sizable number of FEs can be unbearable, a problem known as the curse of dimensionality.

To lessen this time-consuming burden, an increasing amount of research works have been gradually shifting their attention towards the use of surrogate models, i.e., relatively computationally cheap approximated models (surrogates) that in turn replace expensive FEs using the real model/function [14]. These models work by approximating the output from a set of input data based on the behavior of a relatively complex system, yet given the deviation between the actual model and the surrogate model output, it is often necessary to run the original model in a few instances [15].

Accordingly, several surrogate-assisted evolutionary algorithms (SAEAs) have been developed [16,17], and these typically employ polynomial regression models [18]; Gaussian processes (GPs), also known as Kriging models [19,20,21]; support vector machines (SVMs) and support vector regression (SVRs) [22,23]; radial basis functions (RBFs) and radial basis function neural networks (RBFNNs) [24,25]; and other types of neural networks (ANNs) [26,27] to construct the surrogate model. The different traits of these approximation models are explored in a comprehensive manner. In [28], an SAEA is proposed where a more global model with faster convergence is achieved through an RBFNN, whereas a Kriging model is employed to obtain a more local model.

Other examples of SAEAs include a two-layer surrogate-assisted PSO, where by managing a database of historical (particle) positions, a global surrogate is employed in conjunction with several local surrogates to perform the model approximation, and RBFNNs are used to build these surrogates [13]. A similar two-level optimum search approach is followed in [29], where the water cycle algorithm is assisted by a hierarchical surrogate. In addition, a multi-RBF high-fidelity surrogate model is developed in [30] as a suitable option for expensive problems. A decision space partition, where different surrogates are built for different clusters of positions, is suggested in [31] as an effective global search strategy, which is then smoothly complemented with an adaptive selection strategy for the local search. Fuzzy logic has also been applied to this field, and a hierarchical surrogate with a probabilistic PSO search based on global and local assist models is proposed in [32]. The algorithm begins by clustering all precisely evaluated samples to divide the search space into meaningful regions. It then builds dedicated surrogate models within each region, enabling a more accurate representation of the overall fitness landscape and enhancing the algorithm’s exploratory power. Analogously, the generalized multi-factorial evolutionary algorithm was also used in a clustered-based approach, where all the true function evaluations divide the search space into meaningful regions. It then builds dedicated surrogate models within each region, enabling a more accurate representation of the overall fitness landscape and enhancing the algorithm’s exploratory power. Finally, an ensemble surrogate is then used to speed up convergence around the local minima [33].

An engineering application of SAEAs is shown in [34], where the wireless sensor network coverage problem is solved by employing an add-point strategy based on the information from historical surrogate models (RBFs), coupled with a restart strategy. With this methodology, the authors were able to select better candidate (promising) multidimensional positions to evaluate through the real objective function. Another issue concerns the scarcity of training data used to build the surrogate models associated with hard engineering problems; as such, the authors in [35] present a global transfer optimization framework, where similar information is inherited. While the opposite can also occur, for instance in [36], the data samples taken from the feasible design region are abundant, and so they are used to create three surrogate models, capturing the different fitness evaluation traits with an automated multiobjective surrogate-based Pareto finder.

Due to the fitting capabilities of radial basis functions and their fast training, RBFNNs are a common choice to build the dynamically updated surrogate models [37,38,39,40]. A two-phase optimization framework that fuses the exploitation capabilities of surrogates with the exploration of metaheuristics is proposed in [37]. This constitutes another trend in this field, since the combined use of different metaheuristics or surrogate types is often a strength in achieving higher accuracies [13,24,41,42,43]. An uncertainty-based criterion considering the distance and fitness value information simultaneously is proposed in [44], with two prescreening criteria to balance exploration and exploitation, and the surrogate is assisted by the PSO algorithm. A novel evolutionary strategy based on two co-evolutionary mechanisms has been proposed to improve the performance of the Jaya algorithm by replicating optimal directional guidance and historical learning [45], while in [17], the authors propose a separation of the swarms for the different optimization stages during the search space as a better alternative. Additional features like a prescreening criterion, evolution control strategies, and restart strategies are also a trend in the field, as illustrated by the authors in [46].

Considering all of these contributions and development paths, this work proposes a new surrogate-assisted algorithm, designated as SASMA, that explores the balanced Slime Mould Algorithm’s exploration and exploitation capabilities and is applied for the first time in an SAEA variant, coupled with novel thinking behind the database management strategy based on a dual-based update criterion and the surrogate building stages, i.e., the way in which the swarm positions are stored (added and removed) from the global database and how they are subsequently selected to assemble the training data for building the surrogate at each iteration.

The remainder of this paper is organized as follows: Section 2 introduces key aspects of the surrogate model working principles, particularly when coupled with evolutionary algorithms, introducing also pivotal aspects behind the radial basis function neural network model as the (commonly) chosen surrogate model. Section 3 describes the main mechanisms and presents the mathematical formulation behind the chosen metaheuristic, the Slime Mould Algorithm. Section 4 is where the proposed methodology is shown in great detail, together with the subjacent reasoning behind each of the steps. Section 5 introduces both case studies followed by a formal analysis of the different error/test results, where high-dimensional expensive functions and a classical constrained optimization problem are used to evaluate the performance of SASMA against well-known metaheuristics and state-of-the-art SAEAs. Finally, Section 6 outlines the major inferences of the presented work and provides potential research directions.

2. Surrogate Models

Function approximation is an important task in engineering problems. Following the Weierstrass approximation theorem, one can state that for a continuous function $f\left(x\right)$ over a closed domain interval $\left[a,b\right]$, $f\left(x\right)$ can be approximated by a polynomial $\phi \left(x\right)$ of a sufficiently large degree n, such that $\left|f\left(x\right)-{\phi }_n\right|\le \epsilon$, where $\epsilon >0$ is an acceptable threshold. With this theoretical background, approximation or surrogate models $\widehat{f}\left(x\right)$ are built upon previously evaluated/known training individuals using the real (objective) function $f\left(x\right)$, and depending on the quality and representativeness of the training dataset, as well as the chosen method’s ability to properly map the corresponding training space, different magnitudes of the surrogate error ${\Delta }_f=\left|\widehat{f}\left(x\right)-f\left(x\right)\right|$ will emerge. As seen in the Introduction, these models have attracted researchers from a wide range of fields due to their ability to substitute expensive simulations/complex (real) models [47].

In terms of the surrogate optimization, meaning the use of the approximated model to find good estimates for candidate solutions, there are two main approaches [48]. The first is the offline (direct) approach, where the surrogate $\widehat{f}$ is initially constructed by using a sufficiently large set of well-distributed (expensive) individuals (quite a few pairs of candidate solutions and their corresponding real fitness). For the remainder of the optimization search, the model is kept unchanged (static), which means the optimization is made offline (without further information on the real function/simulation). In contrast, in an online (dynamic) approach, a coarse surrogate model is built initially, i.e., with a relatively small amount of training data, and then, as the iterations progress, the model is augmented with additional (expensive) training samples. This online training procedure is generically illustrated in Figure 1, constituting a type of infill strategy, where the primary objective is to balance between the exploration of unknown search space regions and the exploitation of the present promising regions.

With both approaches to surrogate optimization, it is important to have pairs of training data that are well distributed across the entire search space in order to navigate between the different local optima fairly rapidly, i.e., without the need for extensive exploration, and being less prone to being trapped in one of these optima [13]. This smoothness feature in the approximation curve, which “blinds” the search to the existence of several local optima in comparison with the real objective function, is shown in Figure 2, and it illustrates the “blessing of uncertainty” principle. On the flip side, the “curse of uncertainty” translates the downside due to a bad approximation, where $\widehat{f}$ leads to a wrong (nonexistent) minimum, as can be seen by the cross-sign point highlighted in the same figure.

Radial Basis Function Neural Network

When dealing with higher-dimensional approximation problems, a common trend in SAEAs is to use RBFNNs to build the surrogate model—a supervised machine learning architecture—rather than relying on more conventional ANNs or polynomial-based techniques. As the name suggests, these universal approximators take advantage of the well-documented ability of radial basis functions (RBFs), $\phi$, to adequately interpolate a scattered set of points [49]. This being said, finding an optimal value of the shape parameter in radial basis function interpolation is not a trivial task by any means, as shown by [50].

The fully connected feedforward architecture of RBFNNs, depicted in Figure 3, typically consists of an input layer, a hidden layer in which every neuron implements a radial basis function, and a traditional linear output layer [51]. The single hidden layer is therefore the central component of these networks, containing multiple hidden neurons—commonly referred to as “RBF units” or “radbas”—that implement RBFs upon their activation. By definition, an RBF is any real-valued function $\varphi (\parallel ·\parallel )$ that depends solely on the distance of certain points from fixed center coordinates [52], where each $\phi :{\mathbb{R}}^n\to \mathbb{R}$ attains its maximum activation when the input coincides with the neuron’s center. This contrasts with the activation of a conventional ANN hidden neuron, which is computed from a weighted sum of the input followed by a nonlinear activation function. Together, this distance-based activation mechanism and the characterization of each hidden neuron by its center and width [53] are what distinguish RBFNNs from standard feedforward ANNs [13].

In this regard, the Gaussian RBF is the classic choice for the activation of hidden-layer neurons, also known as the Gaussian kernel, which corresponds to the exponential part of the normal distribution’s probability density function; its canonical form for a given input vector x, Equation (1), is given below:

$${\phi }_j\left(x\right)=exp\left(-{\left({\displaystyle \frac{d_j\left(x\right)}{\sqrt{2}{\sigma }_j}}\right)}^2\right)=exp\left(-{\displaystyle \frac{d_j{\left(x\right)}^2}{2{\sigma }_j^2}}\right)$$

(1)

where ${\phi }_j\left(x\right):{\mathbb{R}}^n\to (0,1]$ is the $j^{\mathrm{th}}$ hidden neuron response; $d_j\left(x\right)=\parallel x-u_j\parallel$ denotes the Euclidean distance between the input and the center (or prototype) $u_j$ of the Gaussian RBF, which plays a role analogous to the mean of a Gaussian distribution; and ${\sigma }_j>0$ is the spread (width) of the Gaussian, a role analogous to the standard deviation in the Gaussian distribution, determining how quickly the function decays away from its center.

In practical RBFNN implementations, the parameters that define the connection from the input layer to the hidden layer correspond to these two intrinsic quantities of each RBF unit [53]. When expressed in the general ANN notation—where neuron parameters are represented as weights and biases—each radbas unit, from a total of P in the hidden layer, is equipped with trainable center coordinates directly encoded as an input-weight vector $u_j={[{\omega }_{1j},\dots ,{\omega }_{nj}]}^{\top }$. The spread, on the other hand, is not encoded through a direct substitution; instead, it is conveniently represented by a trainable bias parameter $b_j$ that captures the inverse width of the basis function, i.e., $b_j={\displaystyle \frac{1}{\sqrt{2}{\sigma }_j}}$. Under this representation, the activation of the $j^{\mathrm{th}}$ radbas neuron is given by the following [54]:

$${\phi }_j\left(x\right)=exp\left(-b_j^2\sum _{i=1}^n{(x_i-{\omega }_{ij})}^2\right)$$

(2)

Consequently, as we saw in Equation (1), for a Gaussian RBF, ${\phi }_j\left(x\right)=1$ if and only if $x_i={\omega }_{ij}$ for all i. Meanwhile, the weights connecting the hidden layer to the output layer $w={[w_1,\dots ,w_P]}^{\top }$ form a conventional single-node shifted linear combination, producing the network’s scalar output $y\left(x\right)={\sum }_{j=1}^P{w}_j{\phi }_j\left(x\right)+b$ [55].

Nevertheless, due to the shape–parameter sensitivity inherent to Gaussian kernels on the one hand, and the polyharmonic smoothness of cubic splines that enables robust interpolation in complex multimodal, higher-dimensional landscapes on the other, most SAEA implementations—including the one adopted in this work—employ an RBF with a cubic kernel [56,57], i.e., ${\phi }_j\left(x_i\right)=d_j{\left(x_i\right)}^3$.

For completeness, we note that the surrogate training procedure is used to approximate the input data by a least-squares RBF approximant [58] and follows the standard RBFNN fitting workflow: all input vectors are first normalized to $[0,1]$ per dimension to improve numerical conditioning; the hidden-layer centers are taken directly from the selected training positions; and the output weights are obtained through a least-squares solution of the linear system, defined by the RBF activations. In the publicly available RBFNN construction routine (‘rbfcreate’) commonly used in the SAEA literature, the so-called ‘RBFConstant’ parameter, later codified in Section 4 as $\sigma$, does not represent a Gaussian width; instead, it acts as a numerical regularization constant in the generalized cubic kernel $\varphi \left(r\right)={(r^2+c^2)}^{3/2}$, which improves stability when the interpolation matrix becomes ill-conditioned. Likewise, the ‘RBFSmooth’ parameter corresponds to the (linear) regularization term added to the least-squares system, functioning as the approximation error goal ${\epsilon }_{\mathrm{RBF}}$ and providing an implicit stopping criterion that prevents overfitting when the training set is sparse.

3. Slime Mould Algorithm

The Slime Mould Algorithm (SMA) is a fairly recent swarm intelligence metaheuristic proposed in [59]. It mimics the morphological and foraging behaviors of an acellular slime mould protist organism, Physarum polycephalum, that inhabits humid and cold places. Particularly of interest is its food-seeking mechanism, where the cytoplasmic flux of slime mould surrounds and digests food by searching with a front end that resembles a fan shape, interconnected trough a venous network. Then, through a sequence of negative and positive feedback, depending on the odor, the slime mould finds its way to the target food by adjusting its propagation wave to alter the cytoplasmic flow in its veins, as is illustrated in Figure 4.

In terms of mathematical modeling, the SMA replicates the two main stages of this foraging behavior, namely food approach and food wrapping. In accordance, the algorithm begins $\left(iter=0\right)$ by randomly initializing the population, $X\left(iter\right)=X\left(0\right)=lb+\mathrm{rand}\left(ub-lb\right)=X_{nPop\times nDims}$, in a search space defined by the respective problem’s lower and upper bounds at each dimension, $lb$ and $ub$, with a total of $nPop$ (different) search agents (population size) spread all across the problem’s dimensions, $nDims$. To improve clarity, we explicitly highlight that this initialization corresponds to a uniform sampling of the entire search space, ensuring that the initial slime mould positions are well distributed before the algorithm begins its exploration–exploitation dynamics.

The slime mould position update is then modeled by the expressions in Equation (3), where $X_{i,d}\left(iter+1\right)$ indicates the updated position of the i^th search agent (swarm individual) in a given dimension d; $l{b}_d$ and $u{b}_d$ represent the lower and upper bound of the search space in a given dimension $d\in \left[1,nDims\right]$; $r_1,r_2$ and $\mathrm{rand}$ denote uniformly distributed random values in the interval of $\left[0,1\right]$; z is a sensitive small threshold parameter that ensures diversification in the population by assigning a newly generated random value to the aforementioned updated position; $X_{best,d}\left(iter\right)$ utilizes the index $best$, which stands for the best swarm individual (the slime mould position with the highest odor concentration) encountered so far, and the index d, which refers to a specific dimension of this individual; and $DF$ is its corresponding (swarm’s best) fitness value. This separation between the best-known position and the remaining agents is essential, as it defines the attraction mechanism that drives the population towards promising regions of the search space.

$v_b$ is a randomly uniformly distributed vector that is generated for each ith search agent for all $nDims$ dimensions (implying a different $v_b$ when updating different slime mould positions), oscillating within the range of $\left[-a,a\right]$, such as $v_b=-a+2a·\mathrm{rand}$, where $a={tanh}^{-1}\left({\displaystyle \frac{-iter}{ite{r}_{max}}}+1\right)$, which means it gradually decreases towards zero, $\underset{iter\to ite{r}_{max}}{lima\left(iter\right)}=0$; $v_c$ is an analogous vector to $v_b$ since it also converges to zero and is generated for each swarm individual, but instead oscillates in the range of $\left[-1,1\right]$, i.e., $v_c=-b+2b·\mathrm{rand}$, where $b={\displaystyle \frac{ite{r}_{max}-iter}{ite{r}_{max}}}$. Both $v_b$ and $v_c$ control the oscillatory movement characteristic of slime mould behavior, gradually reducing their amplitude as the algorithm converges, which naturally shifts the search from exploration to exploitation.

$W_i$ is a weight vector assigned to each slime mould position and is computed using Equation (4). Together with $v_b$ and $v_c$, it is one of the parameters that drives the swarm individual’s search; $X_A\left(iter\right)$ and $X_B\left(iter\right)$ represent the notation used to denote two randomly selected (current) swarm individuals, i.e., with indexes $A\wedge B\in \left[1,nPop\right]$, which are selected to update each current position when $r_2<p_i$. Lastly, $p_i$ is an individual threshold value that determines which of the two main position update equations is selected to perform the position update, given by $p_i=tanh\left(\left|S\left(i\right)-DF\right|\right)$, where $S\left(i\right)$ denotes the fitness value of the ith agent. This probability term $p_i$ is central to SMA: it adaptively controls whether an agent is attracted toward the best solution or contracts around its current position, effectively balancing global and local search. An overview of the SMA space search mechanisms and the balance between exploration and exploitation is given in Figure 5.

$$X_{i,d}\left(iter+1\right)=\left\{\begin{array}{c}l{b}_d+\mathrm{rand}·\left(u{b}_d-l{b}_d\right),r_1<z.\hfill \\ X_{best,d}\left(iter\right)+v_{b,d}·\left(W_i·X_{A,d}\left(iter\right)-\right.\hfill \\ \left.X_{B,d}\left(iter\right)\right),r_2<p_i\wedge r_1\ge z.\hfill \\ v_{c,d}·X_{i,d}\left(iter\right),r_2\ge p_i\wedge r_1\ge z.\hfill \end{array}\right.$$

(3)

$$W_i=W\left(SmellIndex\left(i\right)\right)=\left\{\begin{array}{c}1+r_3{log}_{10}\left({\displaystyle \frac{bF-SmellIndex\left(i\right)}{bF-wF}}\right),\hfill \\ \mathrm{if}i\le ⌊po{p}_{size}/\phantom{po{p}_{size}2}2⌋.\hfill \\ 1-r_3{log}_{10}\left({\displaystyle \frac{bF-SmellIndex\left(i\right)}{bF-wF}}\right),\hfill \\ \mathrm{otherwise}.\hfill \end{array}\right.$$

(4)

In turn, to calculate the weight vector for each search agent, the variable $SmellIndex\left(i\right)$, which is nothing more than the sorted fitness values of the entire population, namely $SmellIndex=\mathrm{sort}\left(S\right)$, is introduced, and then the log of the quotient between its difference to the current worst fitness $wF$ and the difference between the current best, $bF$, and the same $wF$ is obtained. The random value $r_3$ is responsible for the uncertainty in the venous contraction phase and is multiplied by the log of the quotient. For the swarm individuals ranked in the best/higher half of the population, this term is added by 1 for a larger weight and subtracted from 1 for the lower half of the population. This weighting mechanism reinforces the influence of better-performing agents while still allowing weaker agents to contribute stochastic perturbations, which is a key biological analogy of slime mould pulsation behavior.

Bound Checking

An important implementation detail concerns the bound checking after each position update (Equation (3)), given the possibility of agents traveling beyond the established (test problem) bounds $\left(lb,ub\right)$, i.e., the defined search space. As such, in this work, the commonly used deterministic back confinement [60], given by Equation (5), is considered not only for the SASMA but also for the benchmark algorithms.

$$\begin{array}{c}{X}_{i,d}\left(iter+1\right)=min\left(X_{i,d}\left(iter+1\right),u{b}_d\right),i=\left[1,nPop\right]\wedge d=\left[1,nDims\right]\hfill \\ X_{i,d}\left(iter+1\right)=max\left(X_{i,d}\left(iter+1\right),l{b}_d\right),i=\left[1,nPop\right]\wedge d=\left[1,nDims\right]\hfill \end{array}$$

(5)

4. Proposed Methodology

In terms of methodology, an overall view of the SASMA main mechanisms and the flow of information between them is provided in Figure 6. This starts with the familiar Latin hypercube sampling (LHS) initialization of the search agents’ positions (shared with the benchmark algorithms), followed by the computation of their respective real objective value, which is then assigned to the global database, forming the initial set of training data for the first surrogate build. Thus, emphasizing this throughout the iterations, only positions deemed as “promising” are assigned their real objective value, and from these, only a handful will enter the DB, grounded on a dual-based criterion explained in Section 4.1, a key feature to ensure a more accurate function approximation.

The subsequent stage involves the chosen metaheuristic model, SMA, which is used in an adapted manner to find the optimal solution of each test problem, while the surrogate model is tasked with replacing the objective function, meaning that the swarm agents navigate through the search space based on approximate model information, $\widehat{f}\left(x\right)$, rather than the usual expensive real test problem. Section 4.2 dives into the specifics of the surrogate’s construction and how the training (positions) and target (real objective values) are selected. These stages will run in a cyclic way until the chosen stop criterion is met, which, as is common in the SAEA literature, is a maximum number of function evaluations $\left(maxFEs\right)$. Additionally, as we saw in Section 2, the added uncertainty of using an estimate of the real value can also work in our benefit by “flattening” some of the real model’s “valleys” during the search space process, i.e., minimizing the local minima phenomena.

4.1. Global Database Management Strategy

To build a surrogate model that evaluates the different potential solutions (slime mould positions), it is necessary to have a dynamic database, working as a stack of (available) positions at each iteration. As illustrated in Figure 1, these stored (search agents) positions, as well as their respective fitness, constitute the input data and are the target data. In this work, a fixed length, $lengthDB$, is considered for the DB, independent of the test problem dimension (after performing several test runs). As we saw earlier, the database is initialized with the initial positions and their respective real fitness, as well as the stored position age, i.e., the iteration number in which this given position entered the database. This control variable is used to evaluate the possible stagnation of the stored swarm agents, and thus, it can also work as a secondary update criterion if needed.

Then, with these iterations, new positions are added/replaced in the DB, which means the accuracy of the surrogate model will improve over time; otherwise, it would require a very large population size. Unlike more traditional surrogate-assisted approaches, the criteria used to add/replace positions in the DB are based on a best weighted metric [61] that considers two different factors rather than only one. The first criterion takes into consideration the surrogate value of the recently updated search agents (via SMA), $\widehat{f}\left(X_i\left(iter+1\right)\right)$ or simply $\widehat{f}\left(X_i\right)$, whose objective is to minimize, and it scales this value based on the current best, ${\widehat{f}}_{min}=min\left(\left\{\widehat{f}\left(X_1\right),\widehat{f}\left(X_2\right),\dots ,\widehat{f}\left(X_{nPop}\right)\right\}\right)$, and worst, ${\widehat{f}}_{max}=max\left(\left\{\widehat{f}\left(X_1\right),\widehat{f}\left(X_2\right),\dots ,\widehat{f}\left(X_{nPop}\right)\right\}\right)$, surrogate values, i.e., the current positions that achieved the minimum and maximum fitness approximation values. So, for each swarm agent, i, its scaled surrogate value, $S\left(X_i\left(iter+1\right)\right)$, is given by Equation (6).

$$S\left(X_i\right)={\displaystyle \frac{\widehat{f}\left(X_i\right)-{\widehat{f}}_{min}}{{\widehat{f}}_{max}-{\widehat{f}}_{min}}},S\in \left[0,1\right]\wedge i\in \left[1,nPop\right]$$

(6)

The second criterion is centered around the distance to the existing DB positions, since when evaluating the potential of an updated search agent to enter the global DB, it is not only important to have a low (estimated) fitness value but also to be as far away as possible from the previously evaluated positions, consequently promoting a more global search space, which in turn helps avoid local minima problems. Thence, we start off by obtaining the Euclidian distance of every position of the current swarm with respect to all DB stored positions, i.e., for each swarm position, $X_i\left(iter+1\right)$, compute its distance to every j position in the DB, $X_j^{DB}$, such that $d_{ij}=∥X_i\left(iter+1\right)-X_j^{\mathrm{DB}}∥$. Then, from this matrix of Euclidean distances, we not only find the overall minimum and maximum distances, $d_{min}=min\left(\left\{d_{11},d_{21},\dots ,d_{nPop,1},d_{1,2},\dots ,d_{nPop,lengthDB}\right\}\right)$ and $d_{max}=max\left(\left\{d_{11},d_{21},\dots ,d_{nPop,1},d_{1,2},\dots ,d_{nPop,lengthDB}\right\}\right)$, respectively, but we also obtain a vector with the minimum distances of every i^th position of the current swarm to any given stored position in the DB, i.e., $d_{single}\left(X_i\right)=min\left(\left\{d_{i,1},d_{i,2},\dots ,d_{i,lengthDB}\right\}\right)$. With this, a scaled distance metric, $D\left(X_i\right)$, can be obtained using Equation (7).

$$D\left(X_i\right)={\displaystyle \frac{d_{max}-d_{single}\left(X_i\right)}{d_{max}-d_{min}}},D\in \left[0,1\right]$$

(7)

With both metrics, a value closer to zero indicates a better candidate to enter the DB; however, they can be somewhat conflicting, i.e., a certain position can have a small (good) scaled surrogate value but at the same time have a large scaled distance value (be very close to the existing DB positions), or vice-versa. For this reason, the merit function, $f_{\mathrm{merit}}$, is a combination of the two metrics, as seen in Equation (8), where through a weight, $0<\varphi <1$, it is possible to modulate which metric should receive higher priority.

$$f_{\mathrm{merit}}\left(X_i\right)=\varphi S\left(X_i\right)+\left(1-\varphi \right)D\left(X_i\right)$$

(8)

A small value of $\varphi$ denotes a greater importance to the more distant positions, which is key to the exploration stage, while a larger value of $\varphi$ implies a prioritization of the smaller scaled surrogate values, which in turn favors the later exploitation phase. To achieve this outcome, a linear increasing function, $\varphi ={\varphi }_{min}+{\displaystyle \frac{{\varphi }_{max}-{\varphi }_{min}}{ite{r}_{max}}}iter$, is considered in this work, rather than the often-suggested four cycles of constant $\varphi$ values.

Calculating the $f_{\mathrm{merit}}$ is just the first step. The entire DB management, as a key feature of the proposed SAEA, comprises a series of steps that must be carried out at each iteration in order to initiate and dynamically update the DB, i.e., the variables $X^{DB}$, $fitnes{s}^{DB}$ and $ag{e}^{DB}$. These recurring steps are fully described in a flowchart form in Figure 7, and they involve the following: sorting the current SASMA swarm based on the respective $f_{\mathrm{merit}}\left(X_i\right)$, which leads to a sorted set of positions, $X^{sort}$; a verification to see if the position is already stored in the DB; and two “semi-elitist” conditions that verify if the potential DB entries are “worthy”. So, the updated search agents ranked in the first 15% in terms of $f_{\mathrm{merit}}$, and 25% of the time, comprising the top quarter, the ranked positions were deemed as valid thresholds, which strengthens the diversity in the DB management strategy.

Finally, even if it passes these conditions, the DB is checked to see if it is already full (having reached its $lengthDB$ limit), and, if so, we need to decide which position to remove, or conversely, maintain, in the DB. Accordingly, the considered criterion is to use the real fitness value as an indicator of the position potential to the subsequent surrogate building stage, so the worst-ranked stored position, $max\left(fitnes{s}^{DB}\right)$, arbitrarily identified by an index k, $X_k^{DB}$, is compared with the real fitness value of the potential DB entry, $f\left(X_i^{sort}\right)$, and in case it is higher, the position is replaced; otherwise, $X_i^{sort}$ is disregarded.

4.2. Surrogate Building

A crucial factor when assembling the surrogate model is the chosen training data, meaning what positions are handpicked to fit the RBFNNs. In other words, as we saw previously, it is important to have a dispersed set of positions to “accurately map” the search space regions, particularly in the exploration phase, which means that the training data length also matters. But also, the “worthiness” of those positions also matters to properly narrow in on the optimum during the exploitation phase, i.e., in regions with bigger slopes in terms of fitness accuracy (smaller variations in the positioning leading to bigger fitness variations), it is more important to have more scattered positions around these, thus ensuring a better fitted surrogate model, which in turn can mitigate the “curse of uncertainty”.

Understanding that the global DB tends (through the course of the iterations) to have a much wider distribution of positions, given its “global nature”, it is important to narrow down the search space defined to effectively fit the surrogate. This implies that after the first iteration, having concluded the first position update, probably only a portion of the global DB data is used to train the surrogate model, which also saves some computational time. This is an adequate approach to find the balance between the current swarm positioning and the overall upper and lower limits of the minimization problem, therefore allowing the surrogate model to shift its global nature to a more local nature in the closing stages of the search, i.e., with a concentration of swarm agents around the most promising subspace regions. This methodology also includes a safeguard mechanism: when no surrogate-suggested improvement is confirmed by real FEs, all agents are evaluated with the real objective function to prevent misleading surrogate drift during early iterations, ensuring robustness without significantly compromising the computational budget.

To accomplish this outcome, and inspired by the fitness approximation strategy proposed in [13], we start by finding the upper and lower limits of the current swarm agents, $X\left(iter+1\right)$, i.e., the subspace defined by the current maximum and minimum values of all the $nPop$ agents at each dimension d, denoted as $Xcur{r}_{ub}$ and $Xcur{r}_{lb}$, and computed as in Equations (9) and (10).

$$\begin{array}{cc}\hfill Xcur{r}_{ub}\left(iter+1\right)& =\left\{max\left(\left\{X_{1,d}\left(iter+1\right),X_{2,d}\left(iter+1\right),\dots ,\right.\right.\right.\hfill \\ \hfill & \left.\left.\left.X_{nPop,d}\left(iter+1\right)\right\}\right),d=1,2,\dots ,nDims\right\}\hfill \end{array}$$

(9)

$$\begin{array}{cc}\hfill Xcur{r}_{lb}\left(iter+1\right)& =\left\{min\left(\left\{X_{1,d}\left(iter+1\right),X_{2,d}\left(iter+1\right),\dots ,\right.\right.\right.\hfill \\ \hfill & \left.\left.\left.X_{nPop,d}\left(iter+1\right)\right\}\right),d=1,2,\dots ,nDims\right\}\hfill \end{array}$$

(10)

Then, we can compute the subspace, $Xsspace$, used to select the training data from the global DB, i.e., the positions of the DB that are within certain upper, $Xsspac{e}_{ub}$, and lower, $Xsspac{e}_{lb}$, bounds, as computed in Equations (11) and (12).

$$\begin{array}{cc}\hfill Xsspac{e}_{ub}\left(iter+1\right)=& min\left(Xcur{r}_{ub}\left(iter+1\right)+\right.\hfill \\ \hfill & \left.\alpha \left(Xcur{r}_{ub}\left(iter+1\right)-Xcur{r}_{lb}\left(iter+1\right)\right),ub\right)\hfill \end{array}$$

(11)

$$\begin{array}{cc}\hfill Xsspac{e}_{lb}\left(iter+1\right)=& max\left(Xcur{r}_{lb}\left(iter+1\right)-\right.\hfill \\ \hfill & \left.\alpha \left(Xcur{r}_{ub}\left(iter+1\right)-Xcur{r}_{lb}\left(iter+1\right)\right),lb\right)\hfill \end{array}$$

(12)

where $\alpha$ is a spread coefficient (and should not be confused with the RBFNN spread parameter mentioned in Section 2), between 0 and 1, that determines how farmbeyond the current positioning the selected subspace goes. A value of 1 implies that the entire DB (all positions in the search space) is considered for building the surrogate, while a value of 0 implies that only the current swarm positioning determines the subspace bounds.

Modifying the original approach to this spread coefficient, we opted for an exponentially decreasing coefficient, i.e., $\alpha ={\alpha }_{max}{e}^{-\gamma \left(iter+1\right)}$, hence, fulfilling the objective of a wider subspace in the exploration phase versus a reduced promising region in the later exploitation stages. In addition, the minimum and maximum functions in Equations (9) and (10) tend to usually return the first term (expression), constituting the bound values, and this explains why we said earlier that the surrogate model neglects the less “interesting” positions of the DB and is driven by the current swarm evolution.

An illustration of how Equations (11) and (12), with their varying spread coefficient, determine the subspace used to build the surrogate is provided in Figure 8. Importantly, this figure showcases the difference between the resultant subspace domain bounds, $Xsspace$, and the effective training domain, $Xtrai{n}^{space}$, which is defined by the range between the upper and lower bounds per dimension of the n selected DB positions inside the computed subspace, i.e., $\left\{max\left(\left\{X_{1,d}^{train},X_{2,d}^{train},\dots ,X_{n,d}^{train}\right\}\right)-min\left(\left\{X_{1,d}^{train},X_{2,d}^{train},\dots ,X_{n,d}^{train}\right\}\right)\right\}$, where $d=1,2,\dots ,nDims$. To ensure that the resultant training subspace leads us to a balanced training domain for the surrogate model, i.e., there are sufficient data points without a very expensive computation cost in the RBF model fitting, a verification of the $X^{train}$ length, given by the index n, is made (as stated in Algorithm 1). A failure to comply with the established (balanced) length limits leads to either a truncation or an extension of the $Xtrai{n}^{space}$.

When employing the RBFNN as the surrogate model, an important control parameter concerns its spread, ${\sigma }_j$, given in Equation (1). A larger spread will require many neurons to find a rough fitness function approximation, while, for a smaller spread, the large number of neurons is the prerequisite to get a smooth function approximation, but it risks overfitting. To achieve this fine balance, an adaptative $spread$, as shown in Equation (13), based on the current training set $\left(X^{train}\right)$ subspace (bounds) is used [13].

$$\begin{array}{cc}\hfill \sigma =& min\left(\left\{max\left(\left\{X_{1,d}^{train},X_{2,d}^{train},\dots ,X_{n,d}^{train}\right\}\right)-\right.\right.\hfill \\ \hfill & \left.\left.min\left(\left\{X_{1,d}^{train},X_{2,d}^{train},\dots ,X_{n,d}^{train}\right\}\right)\right\}\right),d=1,2,\dots ,nDims\hfill \end{array}$$

(13)

Moreover, as hinted in Section 3, an error goal is defined as a proxy of the approximation accuracy of the surrogate model. In this regard, a typical approach is to use two surrogate levels [13,42], i.e., a more global surrogate model where a greater error is allowed, and a more refined model for each or individual parts of the swarm agents, often defined as the local surrogate model, where accuracy is targeted, to find a nearby solution. Acknowledging the benefits of this approach, in this work, we opted for a single global surrogate that transmutes to a more local type of surrogate model by defining a linearly decreasing error goal, as shown in Equation (14). Hence, our model constitutes a slightly different approach that shares the same principle. In other words, the model targets a lower accuracy when the DB is filled with a more dispersed set of positions (exploration phase), while favoring more accuracy in its later stages, when the DB is composed of neighboring positions, given the convergence properties of the SMA.

$${\epsilon }_{RBF}={\epsilon }_{max}-{\displaystyle \frac{{\epsilon }_{max}-{\epsilon }_{min}}{ite{r}_{max}}}iter$$

(14)

Algorithm 1 Pseudocode of the Surrogate-Assisted Slime Mould Algorithm (SASMA) and the employed parameters.

Input:  $nPop=30$; $nDims=30$ or $nDims=100$; $maxFEs$, f, $lb$, $ub$ are test function/problem dependent; $iter=FEs=0$; $z=0.03$ (SMA parameter); $lengthDB=1000$; ${\varphi }_{min}=0.35$ and ${\varphi }_{max}=0.95$; ${\alpha }_{max}=0.305$ and $\gamma =1.5\times {10}^{-3}$; $lenghtXtrai{n}_{lb}=min\left(\mathrm{length}\left(Xtrai{n}^{space}\right)\right)=nPop$ and $lenghtXtrai{n}_{ub}=max\left(\mathrm{length}\left(Xtrai{n}^{space}\right)\right)=5\times nPop$; ${\epsilon }_{min}=0.01$ and ${\epsilon }_{max}=0.1$ 1: Initialize (using LHS) the population, X, where the search agents or positions are denoted as $X_i,i\in \left[1,nPop\right]$; $X^{temp}=X$ 2: Evaluate the real fitness of the initialized agents $S_i=f\left(X_i\right)$; $X_{best}|best=arg\underset{i\in \left[1,nPop\right]}{min}\left(S_i\right)$; $SmellIndex=\mathrm{Sort}\left(S\right)|SmellIndex\left(i\right)\le SmellIndex\left(i+1\right),i\in \left[1,nPop\right]$; $DF=bF=\underset{i\in \left[1,nPop\right]}{min}\left(S_i\right)$; $wF=\underset{i\in \left[1,nPop\right]}{max}\left(S_i\right)$ 3: Store this information into the DB $\left(X^{DB},fitnes{s}^{DB},ag{e}^{DB}\right)$, according to the flowchart in Figure 7 4: Assemble the training set, $X^{train}$ using Equations (9)–(12); Compute the spread, $\sigma$, using Equation (13); Compute the error goal, ${\epsilon }_{RBF}$, using Equation (14); Build the cubic RBF surrogate (approximation) model, $\widehat{f}$ 5: while $\left(FEs<maxFEs\right)$ do 6:     if $\left(iter>0\right)$ then 7:         $SmellIndex=\mathrm{Sort}\left(S\right)|SmellIndex\left(i\right)\le SmellIndex\left(i+1\right),i\in \left[1,nPop\right]$ 8:         $bF=\underset{i\in \left[1,nPop\right]}{min}\left(S_i\right)=SmellIndex\left(1\right)$; $wF=\underset{i\in \left[1,nPop\right]}{max}\left(S_i\right)=SmellIndex\left(nPop\right)$ 9:     end if 10:     if $\left(SmellIndex\left(1\right)<DF\right)$ then 11:         $DF=SmellIndex\left(1\right)$ 12:     end if 13:     for $i=1:nPop$ do 14:         Compute the weight of each individual slime mould, $W_i$, using Equation (4) 15:     end for 16:     Compute the auxiliary SMA variables: $a,b$ 17:     for $i=1:nPop$ do 18:         Calculate the variables $p,v_b,v_c$ 19:         Update each swarm agent (position) and store it in a temporary variable, $X_i^{temp}$, according to Equation (3) 20:         Bound checking of the updated position $X_i^{temp}$, using Equation (5) 21:     end for 22:     $realF{E}_{counter}=0$ 23:     for $i=1:nPop$ do 24:         Compute the surrogate value for each updated position, $\widehat{f}\left(X_i^{temp}\right)$ 25:         if $\left(\widehat{f}\left(X_i^{temp}\right)<S_i\right)$ then 26:            The updated position is deemed as “promising”, so it is accepted, $X_i=X_i^{temp}$ 27:            The real fitness value is therefore computed, $S_i=f\left(X_i\right)$ 28:            $realF{E}_{counter}=realF{E}_{counter}+1$ 29:         end if 30:     end for 31:     if $\left(realF{E}_{counter}==0\right)$ then   ▹ none of the updated positions were deemed as “promising” 32:         for $i=1:nPop$ do 33:            Accept the updated position regardless, $X_i=X_i^{temp}$▹ as in the original SMA code 34:            Compute its real fitness and store the value, $S_i=f\left(X_i\right)$ 35:            $realF{E}_{counter}=realF{E}_{counter}+1$ 36:         end for 37:     end if 38:     for $i=1:nPop$ do 39:         Compute the variables $S\left(X_i\right),D\left(X_i\right),\varphi$, according to Equations (6) and (7) and the inline $\varphi$ equation in Section 4.1 40:         Compute the dual based merit metric, $f_{\mathrm{merit}}\left(X_i\right)$, Equation (8) 41:     end for 42:     Update the DB, i.e., $\left(X^{DB},fitnes{s}^{DB},ag{e}^{DB}\right)$, based on the $f_{\mathrm{merit}}$ and S, according to several stages depicted in the flowchart in Figure 7 43:     Assemble the new training set, $X^{train}$ using Equations (9)–(12); Update the spread, $\sigma$, and the error goal, ${\epsilon }_{RBF}$, using Equation (13) and Equation (14), respectively; Update the cubic RBF surrogate (approximation) model, $\widehat{f}$ 44:     $FEs=FEs+realF{E}_{counter}$ 45:     $iter=iter+1$ 46: end while Output:  $X_{best}$; $f\left(X_{best}\right)$

Overall, the careful fine-tuning of the control parameter $\varphi$ regarding the database management strategy, as well as the surrogate-building-related parameters $\gamma ,\alpha ,\sigma$, and ${\epsilon }_{RBF}$, which, with the exception of the first, all vary along the course of the iterations, allows us to gradually shift from a more global to a more localized surrogate model. This shift is crucial to capture the error differences, with increasingly smaller position updates during the exploitation phase.

4.3. A Novel Surrogate-Assisted Metaheuristic: SASMA

Having described the holistic approach and key aspects behind the proposed SASMA, with a focus on the novelties regarding the DB management strategy and the surrogate-building approach, it is now useful to introduce a more in-depth account of the flow between the main mechanisms illustrated in Figure 6, namely by comprising all the involved variables and the individual stages needed to adapt the original SMA to its SAEA form in pseudocode (as shown in Algorithm 1).

5. Case Studies and Benchmarking

To conduct a fair evaluation of the proposed SASMA, well-known SAEAs with publicly available code—namely TLSAPSO [13], from which many of the SASMA features were inspired, as mentioned in Section 4, SAEA-RFS [62], SHPSO [40], TL-SSLPSO [63], CALSAPSO [64], and GORS-SSLPSO [39]—were selected, and their code was modified accordingly. For verification and fair replication purposes, the same initial positioning is seen by each algorithm for every test run, the main control parameters (for the benchmark algorithms) are shown in

Table 1. Parameter settings for the benchmark algorithms and the proposed SASMA.

Algorithm	Parameter Settings
TLSAPSO	$\begin{array}{c}\omega =0.7,c_1=c_2=2.05,v_{min}=-100,v_{max}=100\hfill \\ fi{t}_{treshold}={10}^{-4},n{b}_{treshold}={10}^{-3}\hfill \\ globalsur{r}_{RBFgoal}={10}^{-1},globalsur{r}_{RBFgoal}={10}^{-2}\hfill \\ RB{F}_{maxneurons}=20,RB{F}_{addneurons}=5\hfill \end{array}$
SAE-ARFS	$\begin{array}{c}F=0.8\left(\mathrm{scaling}\mathrm{factor}\right),CR=1\left(\mathrm{crossover}\mathrm{rate}\right)\hfill \\ \mathrm{Exponential}\mathrm{Crossover},{\phi }_j\left(x_i\right)=d_j{\left(x_i\right)}^3\hfill \\ lenghtXtrai{n}_{lb}=200,nu{m}_{subproblems}=5\hfill \\ maxdimsiz{e}_{subproblem}=20,numiter{s}_{subsubproblem}=5\hfill \end{array}$
SHPSO	$\begin{array}{c}\omega =0.7298,c_1=c_2=2.05,v_{min}=lb,v_{max}=ub\hfill \\ lenghtXtrai{n}_{lb}=100,nDims<100\hfill \\ lenghtXtrai{n}_{lb}=200,nDims\ge 100\hfill \\ M=100,\beta ={10}^{-2}\hfill \end{array}$
TL-SSLPSO	$\omega =1,c_1=c_2=\mathrm{rand},\omega =1,{\phi }_j\left(x_i\right)=d_j{\left(x_i\right)}^3$
CALSAPSO	$\begin{array}{c}\theta ={\displaystyle \frac{g}{100}},\omega =0.9-{\displaystyle \frac{\theta }{2}}\hfill \\ c_1=c_2=1.49445,lenghtXtrai{n}_{lb}=100\hfill \end{array}$
GORS-SSLPSO	$\omega =1,c_1=c_2=\mathrm{rand},\omega =1,{\phi }_j\left(x_i\right)=d_j{\left(x_i\right)}^3$
SASMA (SMA)	$z=0.03$

, and the full test code can be accessed in [65].

With regards to the optimization, a total of 35 runs are performed, which means that the same 35 different initial positions are used to benchmark all the algorithms, thus dismissing initial positioning bias. Moreover, this allows us to assess not only the methodology’s accurateness but also its precision (through the standard deviation), i.e., to judge the ability of each method to consistently find the best solution. The swarm size, $npop$, is set to 30, and these individual agents will survey the problem’s search space up until a total of 330 or 1000 (real) FEs for 30D and 100D, respectively, are reached (following the literature standard). Unlike in traditional metaheuristic algorithms, where there is an equivalence between the number of iterations and the FEs as a stop criterion, this is no longer the case when using surrogate-assisted algorithms, since most of the time, on a given iteration, we end up evaluating only a limited amount of the updated positions, and not the entire population.

The difference between the best (real) fitness value achieved in each run by each algorithm and the problem/test function global minimum, represented as $f_{min}$ in

Table 2. Case Study I: List of unimodal and multimodal test functions.

Function No.	Function Name	fmin	Properties
F1	Sphere	0	Unimodal
F2	Schwefel 2.22	0	Unimodal
F3	Schwefel 1.2	0	Unimodal
F4	Schwefel 2.21	0	Unimodal
F5	Rosenbrock	0	Multimodal with narrow valley
F6	Step	0	Unimodal
F7	Quartic	0	Unimodal
F8	Schwefel 2.26	$-418.9829\times nDims$	Multimodal
F9	Rastrigin	0	Very complicated Multimodal
F10	Ackley	0	Multimodal
F11	Griewank	0	Multimodal
F12	Penalized (1)	0	Multimodal
F13	Penalized (2)	0	Multimodal
F14	Ellipsoid	0	Unimodal
F15	Shifted Rotated Rastrigin (F10 in  [67])	−330	Very complicated Multimodal
F16	Rotated Hybrid Composition (F16 in [67])	120	Very complicated Multimodal
F17	Rotated Hybrid Composition (F19 in [67])	10	Very complicated Multimodal

, is the chosen error metric. To analyze the error performance of the proposed SASMA versus the chosen benchmark algorithms, beyond the common descriptive statistics, i.e., the mean, the standard deviation, and the minimum and maximum error values, we followed the common approach of using the non-parametric Wilcoxon signed rank and the Friedman statistical tests with 5% significance [66].

The first test gauges if there are substantial differences in the central tendency of two competing data series (SASMA vs. all the benchmark algorithms). A one-on-one comparison of the signed errors in the 35 runs for all the problems/test functions allows us to say if the algorithm’s error accuracy differs substantially (null hypothesis), and if so, attributing the symbol “=”, or on the contrary, if there is a definite difference in terms of central tendency (alternative hypothesis). A smaller mean error value for the SASMA versus the benchmarked algorithms means a better performance of the proposed SASMA, and thus, the symbol “+”, whereas the opposite leads us to the symbol “−” in the result analysis (tables). Meanwhile, the second test allows us to perform a multiple-algorithm comparison for the non-normally distributed algorithms’ signed error for each of the 35 runs, revealing if there are any significant differences in the obtained problem/test function errors (alternative hypothesis). The same is conducted by examining the (Friedman) mean rank, rather than the true value. It is expected that for similar distributions, the mean ranks will be approximately identical (null hypothesis).

5.1. Case Study I: Mathematical Test Functions and Optimization Results

Seventeen classical benchmark test functions, shown in Table 2 alongside their global minimum $\left(f_{min}\right)$ and properties, are used to evaluate the proposed SASMA, including its scalability, by considering two different numbers of high dimensions, $nDims=\left[30,100\right]$. Among these test functions, F1–F4 and F14 are continuous unimodal functions; F5 is the Rosenbrock function, which can be considered multimodal when the problem dimension is greater than 3 [68]; F6 is a discontinuous step unimodal function; F7 is a noisy unimodal function; and F8–F13 and F15–F17 are multimodal functions, with many local minima, thus rendering them more difficult to optimize [69]. A detailed account of the optimization bounds and function mathematical expressions is given in

Table A1. Case Study I: Benchmark test functions.

Function	Name	Range $\left(\mathit{n}\right)$	${\mathit{f}}_{min}$
$F_1\left(x\right)={\sum }_{i=1}^n{x}_i^2$	Sphere	$[-100,100]$	0
$F_2\left(x\right)={\sum }_{i=1}^n\left|x_i\right|+{\prod }_{i=1}^n\left|x_i\right|$	Schwefel 2.22	$[-10,10]$	0
$F_3\left(x\right)={\sum }_{i=1}^n{\left({\sum }_{j=1}^i{x}_j\right)}^2$	Schwefel 1.2	$[-100,100]$	0
$F_4\left(x\right)={max}_{i=1,\dots ,n}\left|x_i\right|$	Schwefel 2.21	$[-100,100]$	0
$F_5\left(x\right)={\sum }_{i=1}^{n-1}\left[100{(x_{i+1}-x_i^2)}^2+{(x_i-1)}^2\right]$	Rosenbrock	$[-30,30]$	0
$F_6\left(x\right)={\sum }_{i=1}^n{|x_i+0.5|}^2$	Step	$[-100,100]$	0
$F_7\left(x\right)={\sum }_{i=1}^{n}i{x}_i^4+{\alpha }_i,{\alpha }_i\sim \mathrm{rand}\left([0,1]\right)$	Quartic	$[-1.28,1.28]$	0
$F_8\left(x\right)={\sum }_{i=1}^n\left(-x_{i}sin\sqrt{\left|x_i\right|}\right)$	Schwefel 2.26	$[-500,500]$	$-418.9829\times nDims$
$F_9\left(x\right)={\sum }_{i=1}^n\left(10+x_i^2-10cos\left(2\pi x_i\right)\right)$	Rastrigin	$[-5.12,5.12]$	0
$F_{10}\left(x\right)=-20e^{-0.2\sqrt{{\displaystyle \frac{1}{n}}{\sum }_{i=1}^n{x}_i^2}}-e^{{\displaystyle \frac{1}{n}}{\sum }_{i=1}^{n}cos\left(2\pi x_i\right)}+20+e$	Ackley	$[-32,32]$	0
$F_{11}\left(x\right)=1+{\displaystyle \frac{1}{4000}}{\sum }_{i=1}^n{x}_i^2-{\prod }_{i=1}^{n}cos\left({\displaystyle \frac{x_i}{\sqrt{i}}}\right)$	Griewank	$[-600,600]$	0
$F_{12}\left(x\right)={\displaystyle \frac{\pi }{n}}\left\{10sin\left(2\pi y_1\right)+{\sum }_{i=1}^{n-1}{(y_i-1)}^2\left[1+10{sin}^2\left(\pi y_{i+1}\right)\right]+{(y_n-1)}^2\right\}+{\sum }_{i=1}^{n}u(x_i,10,100,4)$ $y_i=1+{\displaystyle \frac{x_i+1}{4}}$ $u(x_i,a,k,m)=\left\{\begin{array}{cc}k{(x_i-a)}^m,\hfill & x_i>a\hfill \\ 0,\hfill & -a\le x_i\le a\hfill \\ k{(-x_i-a)}^m,\hfill & x_i<-a\hfill \end{array}\right.$	Penalized 1	$[-50,50]$	0
$F_{13}\left(x\right)=0.1\left\{{sin}^2\left(3\pi x_1\right)+{\sum }_{i=1}^n{(x_i-1)}^2\left[1+{sin}^2(3\pi x_i+1)\right]+{(x_n-1)}^2\left[1+{sin}^2\left(2\pi x_n\right)\right]\right\}$ $+{\sum }_{i=1}^{n}u(x_i,5,100,4)$	Penalized 2	$[-50,50]$	0
$F_{14}\left(x\right)={\sum }_{i=1}^{n}i{x}_i^2$	Ellipsoid	$[-100,100]$	0
$F_{15}\left(x\right)={\sum }_{i=1}^n[10+z_i^2-10cos\left(2\pi z_i\right)]+f_{bias}$ $z=(x-o)M,f_{bias}=-330$	Shifted Rotated Rastrigin (F10 in [67])	$[-5,5]$	$-330$
$F_{16}\left(\mathrm{CF}\right):\mathrm{Rotated}\mathrm{Hybrid}\mathrm{Composition}$ $f_{1,2}=\mathrm{Rastrigin},f_{3,4}=\mathrm{Weierstrass},f_{5,6}=\mathrm{Griewank},$ $f_{7,8}=\mathrm{Ackley},f_{9,10}=\mathrm{Sphere};f_{bias}=120;$ ${\sigma }_i=1;\lambda =[1,1,10,10,5/60,5/60,5/32,5/32,5/100,5/100];$ $M_i\mathrm{identity}$	Rotated Hybrid Composition (F16 in [67])	$[-5,5]$	120
$F_{17}\left(\mathrm{CF}\right):\mathrm{Rotated}\mathrm{Hybrid}\mathrm{Composition}$ $f_{1,2}=\mathrm{Ackley},f_{3,4}=\mathrm{Rastrigin},f_{5,6}=\mathrm{Sphere},$ $f_{7,8}=\mathrm{Weierstrass},f_{9,10}=\mathrm{Griewank};f_{bias}=10;$ ${\sigma }_i=[1,2,1.5,1.5,1,1,1.5,1.5,2,2];$ $\lambda =[10/32,5/32,2,1,10/100,5/100,20,10,10/60,5/60];$ $M_i\mathrm{are}\mathrm{rotation}\mathrm{matrices}$	Rotated Hybrid Composition (F19 in [67])	$[-5,5]$	10

.

As mentioned before, key descriptive statistics and two non-parametric tests are used to assess the algorithm’s performance. As such, for all the testing functions F1–F17, the mean, standard deviation (STD), and minimum error values of all the benchmark SAEAs and the proposed SASMA are presented in

Table 3. Statistical results of the proposed SASMA and the benchmark SAEAs on 30D mathematical test functions.

Test Function/Metric		CALSAPSO		GORS-SSLPSO		SAE-ARFS		SHPSO		TL-SSLPSO		TLSAPSO		SASMA
	Mean	$2.212\times {10}^2$		$3.180\times {10}^{-5}$		$2.288\times {10}^4$		$1.492\times {10}^1$		$3.880\times {10}^2$		$2.272\times {10}^4$		$1.226\times {10}^{-2}$
F1	St. Dev.	$4.883\times {10}^2$	+	$2.293\times {10}^{-5}$	−	$5.438\times {10}^3$	+	$1.015\times {10}^1$	+	$9.043\times {10}^2$	+	$4.500\times {10}^3$	+	$3.917\times {10}^{-2}$
	Min	$1.940\times {10}^{-1}$		$4.090\times {10}^{-6}$		$1.362\times {10}^4$		$3.171\times {10}^0$		$1.678\times {10}^0$		$1.282\times {10}^4$		$5.095\times {10}^{-10}$
	Mean	$4.826\times {10}^{12}$		$6.090\times {10}^4$		$5.821\times {10}^5$		$1.142\times {10}^4$		$5.332\times {10}^1$		$1.610\times {10}^9$		$3.258\times {10}^{-4}$
F2	St. Dev.	$9.374\times {10}^{12}$	+	$1.781\times {10}^5$	+	$2.815\times {10}^6$	+	$4.704\times {10}^4$	+	$1.483\times {10}^1$	+	$6.128\times {10}^9$	+	$4.560\times {10}^{-4}$
	Min	$1.762\times {10}^9$		$4.288\times {10}^1$		$7.892\times {10}^1$		$3.304\times {10}^1$		$3.866\times {10}^1$		$7.760\times {10}^1$		$2.777\times {10}^{-6}$
	Mean	$1.417\times {10}^5$		$1.686\times {10}^4$		$7.193\times {10}^4$		$4.247\times {10}^4$		$2.689\times {10}^4$		$5.702\times {10}^4$		$2.470\times {10}^1$
F3	St. Dev.	$4.632\times {10}^4$	+	$1.230\times {10}^4$	+	$1.124\times {10}^4$	+	$1.190\times {10}^4$	+	$7.087\times {10}^3$	+	$1.303\times {10}^4$	+	$7.522\times {10}^1$
	Min	$7.582\times {10}^4$		$5.484\times {10}^3$		$4.358\times {10}^4$		$1.946\times {10}^4$		$1.508\times {10}^4$		$3.447\times {10}^4$		$5.311\times {10}^{-9}$
	Mean	$7.628\times {10}^1$		$4.721\times {10}^1$		$7.398\times {10}^1$		$3.264\times {10}^1$		$4.088\times {10}^1$		$6.386\times {10}^1$		$5.160\times {10}^{-2}$
F4	St. Dev.	$5.811\times {10}^0$	+	$8.021\times {10}^0$	+	$6.278\times {10}^0$	+	$6.421\times {10}^0$	+	$7.809\times {10}^0$	+	$6.450\times {10}^0$	+	$1.317\times {10}^{-1}$
	Min	$6.579\times {10}^1$		$2.850\times {10}^1$		$5.888\times {10}^1$		$2.159\times {10}^1$		$2.957\times {10}^1$		$5.264\times {10}^1$		$1.892\times {10}^{-4}$
	Mean	$6.988\times {10}^5$		$1.346\times {10}^5$		$4.185\times {10}^7$		$7.158\times {10}^4$		$1.015\times {10}^5$		$1.182\times {10}^8$		$2.921\times {10}^1$
F5	St. Dev.	$8.578\times {10}^5$	+	$2.920\times {10}^4$	+	$1.559\times {10}^7$	+	$7.039\times {10}^4$	+	$2.317\times {10}^5$	+	$4.750\times {10}^7$	+	$8.241\times {10}^{-1}$
	Min	$9.871\times {10}^4$		$4.274\times {10}^4$		$1.475\times {10}^7$		$8.585\times {10}^3$		$2.488\times {10}^3$		$3.704\times {10}^7$		$2.895\times {10}^1$
	Mean	$1.646\times {10}^2$		$3.536\times {10}^{-5}$		$2.235\times {10}^4$		$1.842\times {10}^1$		$2.271\times {10}^2$		$2.629\times {10}^4$		6.372 × 100
F6	St. Dev.	$2.796\times {10}^2$	+	$2.435\times {10}^{-5}$	−	$4.153\times {10}^3$	+	$1.129\times {10}^1$	+	$4.275\times {10}^2$	+	$5.763\times {10}^3$	+	1.214 × 100
	Min	$4.659\times {10}^0$		$5.083\times {10}^{-6}$		$1.431\times {10}^4$		$5.132\times {10}^0$		$8.742\times {10}^{-2}$		$1.584\times {10}^4$		5.842 × 10−4
	Mean	$8.883\times {10}^{-1}$		$5.761\times {10}^{-1}$		$2.025\times {10}^1$		$5.772\times {10}^{-1}$		$5.688\times {10}^{-1}$		$1.266\times {10}^2$		$9.476\times {10}^{-3}$
F7	St. Dev.	$4.258\times {10}^{-1}$	+	$2.317\times {10}^{-1}$	+	$8.888\times {10}^0$	+	$3.047\times {10}^{-1}$	+	$3.945\times {10}^{-1}$	+	$2.628\times {10}^1$	+	$7.626\times {10}^{-3}$
	Min	$3.190\times {10}^{-1}$		$2.548\times {10}^{-1}$		$9.262\times {10}^0$		$1.161\times {10}^{-1}$		$1.847\times {10}^{-1}$		$7.957\times {10}^1$		$3.169\times {10}^{-4}$
	Mean	$8.448\times {10}^3$		$5.380\times {10}^3$		$6.428\times {10}^3$		$9.051\times {10}^3$		$5.335\times {10}^3$		$7.651\times {10}^3$		$3.094\times {10}^3$
F8	St. Dev.	$1.371\times {10}^3$	+	$7.296\times {10}^2$	+	$6.831\times {10}^2$	+	$5.593\times {10}^2$	+	$7.648\times {10}^2$	+	$1.056\times {10}^3$	+	2.298 × 103
	Min	$5.041\times {10}^3$		$4.288\times {10}^3$		$5.011\times {10}^3$		$7.926\times {10}^3$		$4.029\times {10}^3$		$5.732\times {10}^3$		$1.372\times {10}^1$
	Mean	$1.282\times {10}^2$		$1.332\times {10}^2$		$3.115\times {10}^2$		$2.749\times {10}^2$		$1.096\times {10}^2$		$3.729\times {10}^2$		$1.432\times {10}^1$
F9	St. Dev.	$4.302\times {10}^1$	+	$3.656\times {10}^1$	+	$3.806\times {10}^1$	+	$3.760\times {10}^1$	+	$2.674\times {10}^1$	+	$2.893\times {10}^1$	+	2.745 × 101
	Min	$4.873\times {10}^1$		$8.159\times {10}^1$		$2.380\times {10}^2$		$1.757\times {10}^2$		$5.623\times {10}^1$		$3.070\times {10}^2$		$1.930\times {10}^{-7}$
	Mean	$2.032\times {10}^1$		$1.434\times {10}^1$		$1.852\times {10}^1$		$8.688\times {10}^0$		$7.867\times {10}^0$		$2.009\times {10}^1$		$3.363\times {10}^{-3}$
F10	St. Dev.	$3.964\times {10}^{-1}$	+	$6.077\times {10}^0$	+	$1.265\times {10}^0$	+	$6.990\times {10}^{-1}$	+	$4.311\times {10}^0$	+	$2.177\times {10}^{-1}$	+	$3.216\times {10}^{-3}$
	Min	$1.913\times {10}^1$		$3.299\times {10}^0$		$1.468\times {10}^1$		$7.183\times {10}^0$		$2.759\times {10}^0$		$1.912\times {10}^1$		$1.120\times {10}^{-4}$
	Mean	$3.796\times {10}^0$		$2.660\times {10}^0$		$1.992\times {10}^2$		$1.116\times {10}^0$		$4.080\times {10}^0$		$2.736\times {10}^1$		$6.739\times {10}^{-4}$
F11	St. Dev.	$2.915\times {10}^0$	+	$1.529\times {10}^1$	+	$3.328\times {10}^1$	+	$7.297\times {10}^{-2}$	+	$4.817\times {10}^0$	+	$7.017\times {10}^0$	+	$1.253\times {10}^{-3}$
	Min	$1.610\times {10}^0$		$1.113\times {10}^{-2}$		$1.197\times {10}^2$		$1.039\times {10}^0$		$9.886\times {10}^{-1}$		$1.636\times {10}^1$		$4.747\times {10}^{-7}$
	Mean	$2.482\times {10}^5$		$1.661\times {10}^3$		$6.228\times {10}^7$		$8.456\times {10}^3$		$1.248\times {10}^4$		$1.921\times {10}^8$		$7.546\times {10}^{-1}$
F12	St. Dev.	$7.293\times {10}^5$	+	$2.571\times {10}^3$	+	$4.416\times {10}^7$	+	$2.719\times {10}^4$	+	$4.020\times {10}^4$	+	$1.090\times {10}^8$	+	$3.324\times {10}^{-1}$
	Min	$2.943\times {10}^1$		$1.662\times {10}^1$		$9.392\times {10}^6$		$5.588\times {10}^0$		$2.555\times {10}^1$		$4.059\times {10}^7$		$2.928\times {10}^{-6}$
	Mean	$8.496\times {10}^5$		$1.283\times {10}^5$		$1.335\times {10}^8$		$4.071\times {10}^4$		$4.430\times {10}^4$		$4.071\times {10}^8$		$2.578\times {10}^0$
F13	St. Dev.	$1.239\times {10}^6$	+	$6.569\times {10}^4$	+	$6.399\times {10}^7$	+	$1.580\times {10}^5$	+	$6.827\times {10}^4$	+	$1.703\times {10}^8$	+	$9.339\times {10}^{-1}$
	Min	$1.676\times {10}^3$		$1.234\times {10}^4$		$3.547\times {10}^7$		$1.971\times {10}^1$		$6.551\times {10}^2$		$1.005\times {10}^8$		$1.252\times {10}^{-1}$
	Mean	$9.632\times {10}^3$		$4.486\times {10}^2$		$2.740\times {10}^5$		$5.951\times {10}^3$		$8.209\times {10}^3$		$3.211\times {10}^5$		$8.987\times {10}^{-2}$
F14	St. Dev.	$1.118\times {10}^4$	+	$3.414\times {10}^2$	+	$7.496\times {10}^4$	+	$2.136\times {10}^3$	+	$9.588\times {10}^3$	+	$6.634\times {10}^4$	+	$2.538\times {10}^{-1}$
	Min	$2.079\times {10}^1$		$3.969\times {10}^1$		$1.296\times {10}^5$		$2.669\times {10}^3$		$4.844\times {10}^2$		$1.932\times {10}^5$		$1.479\times {10}^{-8}$
	Mean	$3.994\times {10}^2$		$2.115\times {10}^2$		$4.647\times {10}^2$		$2.837\times {10}^2$		$1.505\times {10}^2$		$5.226\times {10}^2$		$4.893\times {10}^2$
F15	St. Dev.	$5.489\times {10}^1$	−	$5.557\times {10}^1$	−	$5.948\times {10}^1$	=	$2.471\times {10}^1$	−	$3.792\times {10}^1$	−	$5.321\times {10}^1$	=	$8.253\times {10}^1$
	Min	$3.108\times {10}^2$		$1.294\times {10}^2$		$3.792\times {10}^2$		$2.236\times {10}^2$		$7.785\times {10}^1$		$4.219\times {10}^2$		$3.236\times {10}^2$
	Mean	$6.799\times {10}^2$		$4.803\times {10}^2$		$5.799\times {10}^2$		$4.114\times {10}^2$		$3.548\times {10}^2$		$6.584\times {10}^2$		$5.975\times {10}^2$
F16	St. Dev.	$1.177\times {10}^2$	+	$1.782\times {10}^2$	−	$8.952\times {10}^1$	=	$8.985\times {10}^1$	−	$1.428\times {10}^2$	−	$1.317\times {10}^2$	+	$1.315\times {10}^2$
	Min	$4.811\times {10}^2$		$2.330\times {10}^2$		$4.489\times {10}^2$		$3.057\times {10}^2$		$1.360\times {10}^2$		$4.424\times {10}^2$		$3.607\times {10}^2$
	Mean	$1.190\times {10}^3$		$1.004\times {10}^3$		$1.115\times {10}^3$		$9.806\times {10}^2$		$9.673\times {10}^2$		$1.110\times {10}^3$		$9.620\times {10}^2$
F17	St. Dev.	$1.574\times {10}^2$	+	$6.867\times {10}^1$	=	$5.178\times {10}^1$	+	$2.229\times {10}^1$	=	$3.050\times {10}^1$	=	$5.151\times {10}^1$	+	$8.828\times {10}^1$
	Min	$9.785\times {10}^2$		$9.177\times {10}^2$		$1.022\times {10}^3$		$9.464\times {10}^2$		$9.257\times {10}^2$		$1.017\times {10}^3$		$9.000\times {10}^2$
Win			16		12		15		14		14		16
Tie			0		1		2		1		1		1
Lose			1		4		0		2		2		0

According to the Wilcoxon signed rank test at the 5% significance level, the symbol “+”, “=”, or “−” symbolizes that the performance of SASMA is better, similar, or worse than that of the other SAEAs, respectively. In addition, the best results for all metrics (from the 35 runs) for each test function are highlighted in grey.

and

Table A2. Statistical results of the proposed SASMA and the benchmark SAEAs on 100D mathematical test functions.

Test Function/Metric		GORS-SSLPSO		SAE-ARFS		SHPSO		TL-SSLPSO		TLSAPSO		SASMA
	Mean	$1.429\times {10}^3$		$1.065\times {10}^5$		$6.281\times {10}^{-1}$		$7.452\times {10}^3$		$1.243\times {10}^5$		$9.287\times {10}^{-29}$
F1	St. Dev.	$4.299\times {10}^3$	+	$1.121\times {10}^4$	+	$1.953\times {10}^{-1}$	+	$3.197\times {10}^3$	+	$1.531\times {10}^4$	+	$2.344\times {10}^{-28}$
	Min	$1.069\times {10}^{-4}$		$7.513\times {10}^4$		$2.863\times {10}^{-1}$		$2.312\times {10}^3$		$9.326\times {10}^4$		$3.395\times {10}^{-39}$
	Mean	$6.761\times {10}^{31}$		$2.640\times {10}^9$		$1.826\times {10}^{15}$		$3.132\times {10}^{12}$		$2.640\times {10}^{38}$		$6.749\times {10}^{-15}$
F2	St. Dev.	$4.000\times {10}^{32}$	+	$1.449\times {10}^{10}$	+	$8.767\times {10}^{15}$	+	$1.799\times {10}^{13}$	+	$7.400\times {10}^{38}$	+	$1.480\times {10}^{-14}$
	Min	$1.052\times {10}^2$		$2.908\times {10}^2$		$1.578\times {10}^2$		$2.439\times {10}^2$		$3.492\times {10}^{23}$		$1.595\times {10}^{-20}$
	Mean	$1.442\times {10}^5$		$4.064\times {10}^5$		$2.504\times {10}^5$		$2.285\times {10}^5$		$3.963\times {10}^5$		$9.798\times {10}^{-16}$
F3	St. Dev.	$7.018\times {10}^4$	+	$6.533\times {10}^4$	+	$5.408\times {10}^4$	+	$5.307\times {10}^4$	+	$7.280\times {10}^4$	+	$4.145\times {10}^{-15}$
	Min	$4.291\times {10}^4$		$2.742\times {10}^5$		$1.417\times {10}^5$		$1.212\times {10}^5$		$2.500\times {10}^5$		$2.371\times {10}^{-33}$
	Mean	$7.814\times {10}^1$		$8.319\times {10}^1$		$4.313\times {10}^1$		$7.757\times {10}^1$		$9.266\times {10}^1$		$7.664\times {10}^{-14}$
F4	St. Dev.	$3.531\times {10}^0$	+	$2.529\times {10}^0$	+	$5.503\times {10}^0$	+	$4.761\times {10}^0$	+	$3.424\times {10}^0$	+	$1.466\times {10}^{-13}$
	Min	$6.999\times {10}^1$		$7.760\times {10}^1$		$3.173\times {10}^1$		$6.773\times {10}^1$		$8.292\times {10}^1$		$1.066\times {10}^{-16}$
	Mean	$2.020\times {10}^5$		$2.977\times {10}^8$		$4.839\times {10}^4$		$2.669\times {10}^6$		$6.314\times {10}^8$		$9.651\times {10}^1$
F5	St. Dev.	$3.715\times {10}^4$	+	$6.150\times {10}^7$	+	$3.117\times {10}^4$	+	$2.023\times {10}^6$	+	$8.800\times {10}^7$	+	$1.046\times {10}^1$
	Min	$1.254\times {10}^5$		$1.881\times {10}^8$		$1.328\times {10}^4$		$6.084\times {10}^5$		$4.451\times {10}^8$		$4.343\times {10}^1$
	Mean	$1.426\times {10}^3$		$1.084\times {10}^5$		$6.607\times {10}^{-1}$		$7.415\times {10}^3$		$1.233\times {10}^5$		$1.750\times {10}^1$
F6	St. Dev.	$3.544\times {10}^3$	+	$1.120\times {10}^4$	+	$3.117\times {10}^{-1}$	−	$2.875\times {10}^3$	+	$1.226\times {10}^4$	+	$6.667\times {10}^0$
	Min	$8.937\times {10}^{-5}$		$8.731\times {10}^4$		$2.933\times {10}^{-1}$		$3.330\times {10}^3$		$8.511\times {10}^4$		$9.927\times {10}^{-2}$
	Mean	$1.826\times {10}^0$		$3.976\times {10}^2$		$1.133\times {10}^0$		$1.070\times {10}^1$		$1.070\times {10}^3$		$2.193\times {10}^{-3}$
F7	St. Dev.	$3.753\times {10}^{-1}$	+	$6.799\times {10}^1$	+	$4.985\times {10}^{-1}$	+	$7.321\times {10}^0$	+	$1.514\times {10}^2$	+	$1.736\times {10}^{-3}$
	Min	$1.146\times {10}^0$		$2.651\times {10}^2$		$5.251\times {10}^{-1}$		$3.419\times {10}^0$		$7.234\times {10}^2$		$6.724\times {10}^{-5}$
	Mean	$1.946\times {10}^4$		$2.264\times {10}^4$		$3.159\times {10}^4$		$2.211\times {10}^4$		$3.020\times {10}^4$		$3.056\times {10}^3$
F8	St. Dev.	$1.683\times {10}^3$	+	$1.095\times {10}^3$	+	$1.512\times {10}^3$	+	$2.012\times {10}^3$	+	$1.420\times {10}^3$	+	$4.036\times {10}^3$
	Min	$1.567\times {10}^4$		$2.035\times {10}^4$		$2.854\times {10}^4$		$1.865\times {10}^4$		$2.790\times {10}^4$		$1.903\times {10}^{-1}$
	Mean	$3.447\times {10}^2$		$1.042\times {10}^3$		$7.663\times {10}^2$		$5.165\times {10}^2$		$1.423\times {10}^3$		$4.582\times {10}^{-6}$
F9	St. Dev.	$6.295\times {10}^1$	+	$5.005\times {10}^1$	+	$1.009\times {10}^2$	+	$6.831\times {10}^1$	+	$6.909\times {10}^1$	+	$1.280\times {10}^{-5}$
	Min	$2.129\times {10}^2$		$9.500\times {10}^2$		$5.722\times {10}^2$		$4.049\times {10}^2$		$1.235\times {10}^3$		$0.000\times {10}^0$
	Mean	$1.861\times {10}^1$		$1.951\times {10}^1$		$4.199\times {10}^0$		$1.575\times {10}^1$		$2.039\times {10}^1$		$1.537\times {10}^{-14}$
F10	St. Dev.	$5.462\times {10}^{-1}$	+	$2.553\times {10}^{-1}$	+	$5.341\times {10}^{-1}$	+	$1.145\times {10}^0$	+	$1.293\times {10}^{-1}$	+	$3.398\times {10}^{-14}$
	Min	$1.670\times {10}^1$		$1.897\times {10}^1$		$3.444\times {10}^0$		$1.284\times {10}^1$		$2.006\times {10}^1$		$4.441\times {10}^{-16}$
	Mean	$1.570\times {10}^1$		$9.917\times {10}^2$		$9.750\times {10}^{-1}$		$6.393\times {10}^1$		$9.979\times {10}^1$		$0.000\times {10}^0$
F11	St. Dev.	$4.100\times {10}^1$	+	$8.318\times {10}^1$	+	$4.646\times {10}^{-2}$	+	$2.747\times {10}^1$	+	$1.390\times {10}^1$	+	$0.000\times {10}^0$
	Min	$7.129\times {10}^{-2}$		$8.201\times {10}^2$		$8.485\times {10}^{-1}$		$2.568\times {10}^1$		$7.361\times {10}^1$		$0.000\times {10}^0$
	Mean	$2.859\times {10}^2$		$5.301\times {10}^8$		$2.988\times {10}^3$		$1.379\times {10}^6$		$1.392\times {10}^9$		$5.005\times {10}^{-1}$
F12	St. Dev.	$6.397\times {10}^2$	+	$1.440\times {10}^8$	+	$8.741\times {10}^3$	+	$1.759\times {10}^6$	+	$2.812\times {10}^8$	+	$4.198\times {10}^{-1}$
	Min	$1.425\times {10}^1$		$2.186\times {10}^8$		$8.739\times {10}^0$		$3.766\times {10}^4$		$6.339\times {10}^8$		$4.151\times {10}^{-4}$
	Mean	$6.285\times {10}^4$		$1.173\times {10}^9$		$2.135\times {10}^4$		$5.801\times {10}^6$		$2.573\times {10}^9$		$6.895\times {10}^0$
F13	St. Dev.	$2.217\times {10}^4$	+	$2.290\times {10}^8$	+	$5.463\times {10}^4$	+	$5.531\times {10}^6$	+	$4.791\times {10}^8$	+	$4.174\times {10}^0$
	Min	$1.120\times {10}^4$		$6.274\times {10}^8$		$1.272\times {10}^2$		$4.045\times {10}^5$		$1.666\times {10}^9$		$5.662\times {10}^{-2}$
	Mean	$7.918\times {10}^3$		$4.391\times {10}^6$		$1.662\times {10}^4$		$3.397\times {10}^5$		$5.543\times {10}^6$		$9.533\times {10}^{-26}$
F14	St. Dev.	$1.857\times {10}^4$	+	$4.554\times {10}^5$	+	$3.097\times {10}^3$	+	$1.615\times {10}^5$	+	$6.585\times {10}^5$	+	$3.178\times {10}^{-25}$
	Min	$1.041\times {10}^3$		$3.447\times {10}^6$		$1.041\times {10}^4$		$1.650\times {10}^5$		$4.357\times {10}^6$		$1.228\times {10}^{-40}$
	Mean	$1.464\times {10}^3$		$2.480\times {10}^3$		$1.172\times {10}^3$		$1.491\times {10}^3$		$2.519\times {10}^3$		$2.315\times {10}^3$
F15	St. Dev.	$1.058\times {10}^2$	−	$2.535\times {10}^2$	+	$9.584\times {10}^1$	−	$1.312\times {10}^2$	−	$2.345\times {10}^2$	+	$9.103\times {10}^1$
	Min	$1.272\times {10}^3$		$1.995\times {10}^3$		$1.047\times {10}^3$		$1.223\times {10}^3$		$2.017\times {10}^3$		$2.080\times {10}^3$
	Mean	$6.388\times {10}^2$		$7.446\times {10}^2$		$3.989\times {10}^2$		$4.961\times {10}^2$		$9.037\times {10}^2$		$9.161\times {10}^2$
F16	St. Dev.	$6.302\times {10}^1$	−	$7.359\times {10}^1$	−	$2.929\times {10}^1$	−	$5.488\times {10}^1$	−	$9.710\times {10}^1$	=	$8.486\times {10}^1$
	Min	$5.078\times {10}^2$		$6.188\times {10}^2$		$3.517\times {10}^2$		$3.895\times {10}^2$		$7.458\times {10}^2$		$7.173\times {10}^2$
	Mean	$1.483\times {10}^3$		$1.482\times {10}^3$		$1.409\times {10}^3$		$1.407\times {10}^3$		$1.500\times {10}^3$		$9.000\times {10}^2$
F17	St. Dev.	$4.642\times {10}^1$	+	$3.113\times {10}^1$	+	$3.634\times {10}^1$	+	$3.282\times {10}^1$	+	$3.949\times {10}^1$	+	$0.000\times {10}^0$
	Min	$1.364\times {10}^3$		$1.428\times {10}^3$		$1.331\times {10}^3$		$1.333\times {10}^3$		$1.435\times {10}^3$		$9.000\times {10}^2$
Win			15		16		14		15		16
Tie			0		0		0		0		1
Lose			2		1		3		2		0

According to the Wilcoxon signed rank test at a 5% significance level, the symbol “+”, “=”, or “−” symbolizes that the performance of SASMA is better, similar, or worse than that of other SAEAs, respectively. In addition, the best results for all metrics (from the 35 runs) for each test function are highlighted in grey.

, respectively, for 30D and 100D. CALSAPSO’s very slow convergence for 100D made the simulation cost very heavy, which is why it was not considered in the test case. The best results per metric are shaded in grey, clearly indicating the superior performance of SASMA, which only failed to achieve the best mean error value (lowest value) on four functions for 30D, and on three occasions for 100D, a scenario that is pretty similar in terms of the minimum error value, where we assess the ability of SASMA to be closest to the global function minimum in at least one of the runs. Despite being a harder problem, SASMA’s performance for 100D is even better than for 30D, which is explained by the larger number of function evaluations, and this is why for nine out of the seventeen functions, we see that SASMA is able to consistently find the global minimum (an STD of zero), while also being very close to this target value for F12.

The same can also be confirmed by the results of the Wilcoxon signed ranked test at a 5% significance level, where SASMA is compared against every other algorithm. For both 30D and 100D, SASMA records significantly better error accuracies in most of the seventeen test functions (overwhelmingly scoring wins) against the benchmarked algorithms. The few exceptions mostly occur in the last three test functions.

For 30D, GORS-SSLPSO was the only benchmark algorithm to show a statistically better error performance in four functions, particularly in F1 and F6, with values in the order of ${10}^{-5}$, while the remainder were only able to surpass or tie with SASMA in F15–F17, which means that for at least fourteen out of the seventeen functions, SASMA was better. SHPSO and TL-SSLPSO showed consistent standard deviations, and this last SAEA achieved the best performance in the Shifted Rotated Rastrigin function. Meanwhile, for 100D, the advantage of SASMA is even more clear, overall recording more wins, one less loss, and only one tie. SHPSO is its closest competitor, showing an outstanding performance for F6, F15, and F16, while for the remainder, it is clearly outmatched by SASMA, partially confirming the trend already seen for 30D.

This improved (lower) error accuracy is also attested by the Friedman test, which was performed for each function, taking into consideration each test run error. By analyzing the computed mean rank, we can then individually order each algorithm, where the lowest mean rank score indicates a better performance. The results for 30D are shown in

Table 4. Mean rank scores (based on the Friedman test) of the SASMA and the benchmark SAEAs on 30D mathematical test functions.

Friedman Test		CALSAPSO	GORS-SSLPSO	SAE-ARFS	SHPSO	TL-SSLPSO	TLSAPSO	SASMA
Mean Rank	F1	4.23	1.46	6.49	3.43	4.34	6.51	1.54
	F2	7.00	3.94	4.54	3.46	2.23	5.83	1.00
	F3	6.97	2.31	5.74	4.06	2.83	5.09	1.00
	F4	6.57	3.71	6.23	2.23	3.11	5.14	1.00
	F5	4.83	3.86	6.00	2.83	2.49	7.00	1.00
	F6	4.29	1.00	6.29	3.46	3.97	6.71	2.29
	F7	4.17	3.40	6.00	3.20	3.23	7.00	1.00
	F8	5.80	2.46	3.91	6.57	2.46	5.20	1.60
	F9	3.20	3.06	5.89	5.29	2.69	6.83	1.06
	F10	6.71	4.06	4.63	2.94	2.46	6.20	1.00
	F11	4.66	2.11	7.00	3.17	4.11	5.94	1.00
	F12	4.20	3.71	6.11	2.60	3.49	6.89	1.00
	F13	4.54	4.11	6.06	2.40	2.94	6.94	1.00
	F14	3.77	2.20	6.26	4.03	4.00	6.74	1.00
	F15	4.49	1.97	5.34	2.83	1.20	6.40	5.77
	F16	5.77	3.26	4.54	2.31	1.86	5.46	4.80
	F17	5.94	3.11	5.63	2.97	2.34	5.66	2.34

According to the Friedman test, the best mean rank (of the 35 runs) for each test function is highlighted in grey.

, where we can see that SASMA is consistently the best ranked algorithm, with the exception of four functions (F1, F6, F15, and F16). Nevertheless, for the first of the two, GORS-SSLPSO closely follows as the second-best SAEA in terms of mean rank. For most of the test functions, the top three ranked algorithms are SASMA, GORS-SSLPSO, and TL-SSLPSO. Meanwhile, on the opposite end, TLSAPSO and CALSAPSO are the worst ranked SAEAs.

As for the 100D results, shown in

Table A3. Mean rank scores (based on the Friedman test) of the SASMA and the benchmark SAEAs on 100D mathematical test functions.

Friedman Test		GORS-SSLPSO	SAE-ARFS	SHPSO	TL-SSLPSO	TLSAPSO	SASMA
Mean Rank	F1	2.31	5.23	2.77	3.91	5.77	1.00
	F2	2.11	3.71	4.00	4.17	6.00	1.00
	F3	2.26	5.49	3.46	3.40	5.40	1.00
	F4	3.54	4.80	2.00	3.71	5.94	1.00
	F5	3.00	5.00	2.00	4.00	6.00	1.00
	F6	1.43	5.14	1.91	3.89	5.86	2.77
	F7	2.86	5.00	2.14	4.00	6.00	1.00
	F8	2.17	3.57	5.77	3.26	5.23	1.00
	F9	2.00	5.00	3.94	3.06	6.00	1.00
	F10	4.06	4.94	2.00	3.00	6.00	1.00
	F11	2.37	6.00	2.86	4.03	4.74	1.00
	F12	2.71	5.00	2.29	4.00	6.00	1.00
	F13	2.91	5.00	2.09	4.00	6.00	1.00
	F14	2.06	5.09	2.94	4.00	5.91	1.00
	F15	2.40	5.20	1.06	2.54	5.31	4.49
	F16	3.09	4.00	1.06	2.00	5.34	5.51
	F17	4.63	4.74	2.80	2.69	5.14	1.00

According to the Friedman test, the best mean rank (from the 35 runs) for each function is highlighted in grey.

, the accuracy of SASMA is even better, achieving the best mean rank in fourteen of the test functions, and as was the case for 30D, it is GORS-SSLPSO that achieved the best mean rank for F6, while for F15 and F16, it is now SHPSO that is ranked the best in detriment of TL-SSLPSO. Completing the top three in this test metric are again SASMA and GORS-SSLPSO, which are now joined by SHPSO. Contrariwise, TLSAPSO and SAE-ARFS occupy the lower (ranked) end of the benchmark algorithms. Notwithstanding all the comparisons, the comprehensive error analysis not only confirms SASMA’s ability to mitigate the initial positioning bias but also its ability to substantially outperform TLSAPSO. This is a very significant result given that many of SASMA’s features are inspired by it.

To visually illustrate the aforementioned superiority of SASMA in comparison with the benchmarked SAEAs, the convergence curve of the best SASMA run, i.e., the run where the proposed methodology achieved the minimum error value, is shown together with the convergence curves for all the selected algorithms, thus ensuring that all start from the same initial positioning. Figure 9 depicts the results for 30D and the unimodal test functions, and it is no surprise to see that SASMA, apart from F6 where GORS-SSLPSO excelled, achieves the minimum fitness value (log), and most of the time in far fewer FEs.

For the multimodal test functions, shown in Figure 10, still considering 30D, the picture is very similar, with SASMA consistently reaching the lowest fitness value with a faster convergence (sharp drop) in test functions F8, F12, and F13. It is again followed by GORS-SSLPSO and SAHO. The very complicated multimodal test functions shown in Figure 11 reveal a more challenging scenario where SASMA greatly outperforms all the SAEAs in F9 and, despite slower convergence, achieves the same in F17. Meanwhile, for F15 and F16, it is TL-SSLPSO that shows a greater performance, confirming the Wilcoxon and Friedman test results.

The very complicated multimodal test functions are shown in Figure 11.

For 100D, the convergence curves for the unimodal test functions are shown in Figure A1, the multimodal test functions in Figure A2, and the very complicated multimodal test functions in Figure A3. Likewise, we observe that the superiority of SASMA is even more evident, as the convergence curves for F3, F4, F10, F11, and F9 reveal. An exception occurs in F6 and F16, where GORS-SSLPSO and SHPSO, respectively, are able to outperform it. Noticeably, SASMA maintains its fast convergence characteristics, and it even reaches the global minimum in F11, and so, the log curve vanishes from this point onwards. In all the convergence curve figures, we can also confirm the trend revealed by the several error metrics and non-parametric tests, where GORS-SSLPSO and SHPSO are the closest competitors of SASMA, while the other SAEAs tend to display premature convergence and stagnation features.

In terms of computational cost, a relevant feature in large-scale optimization problems, the relative time taken by the benchmark SAEAs in comparison with SASMA is shown in Figure 12, and is measured as the ratio between the time taken by each of the SAEAs and the time taken by SASMA. As we can see, the x-scale is given in a logarithmic scale, given that most of the algorithms take several orders of magnitude more than SASMA, with the exception of TL-SSLPSO and SAE-ARFS, for 30D and 100D, respectively, which are slower but roughly in the same order of magnitude.

To complement the results analysis, the SASMA DB properties after each individual run for each test function are analyzed via a bivariate histogram in Figure 13. The bar plots on the left side highlight the relative frequency of the final DB length and average age of the stored positions, whereas the bar plots on the right highlight the distribution of the rules activated in order to enter the DB for all the performed runs. The distribution for 30D unveils that the most frequent class for the DB size is between 133 and 144 stored positions, while the average age of the positions is around seven to eight iterations, meaning that they are fairly new, and that with the considered small number of FEs, the DB is being filled with rapidly improving positions. This scenario increases significantly for the 100D case, where the most frequent class for the DB size is between 374 and 401 stored positions, while the average age of the positions is around 26 to 27 iterations, thus indicating a more mature level of stored positions, which translates into more constancy in the surrogate approximation.

These results are in line with the intended semi-elitist nature of the DB entry rules, designed in Algorithm 1 and shown in Figure 7. The same can be verified by the right-side bivariate distributions, where we see that independent of the number of problem dimensions, rule 1 and rule 2 are responsible for roughly between 85/89% and 15/11% of the DB position entries, respectively, for more than half of the times (most frequent classes).

5.2. Case Study II: 25 Truss Bar Design (Continuous) Problem

A truss design problem was chosen to provide an additional real engineering case study, in a field known as structural optimization, to validate the proposed SASMA. As the name suggests, it concerns the design optimization of truss bar structures with the purpose of minimizing its weight while still fulfilling displacement and stress constraints. The underlying mathematical formulation behind the constrained objective function and the penalty method is provided in Appendix B.

The 25-bar transmission tower shown in Figure 14 is one of the most broadly used truss design problems. As such, it is a perfect fit to compare the different algorithms and verify the numerous design methodologies through which each one ensures the minimum weight, while preserving its structural integrity. The elements that form the 25-bar truss are organized into eight groups, meaning eight design variables, and all the members in the same group share the same cross-sectional and material properties. The three-dimensional coordinates for the ten nodes/elements shown in Figure 14, namely unit weight, modulus of elasticity, loading conditions, and the respective member grouping, can be found in [47].

The continuous design variable variant for the 25-bar truss problem assumes that the cross-sectional areas are continuous decision variables (no need to map to a set of feasible discrete design variables) and considers multiple loading conditions, i.e., different stress constraints for each node, with minimum and maximum cross-sectional areas of 0.01 and 3.40 in² [allowable bounds in Equation (A2)], respectively.

Therefore, this constrained continuous truss problem presents a different challenge in comparison with the first case study. That is, although the number of dimensions is smaller, there are now a set of relationships between the different design parameters that imply that even solutions (cross-sectional areas), X, inside the allowable bounds may possibly violate the other restrictions, as shown in Equation (A1). Hence, this problem tests the SASMA exploration capabilities to guide the search agents towards the global optimum based on the changes given by the penalty function, Equation (A2).

Optimization Results

So, to further justify the use of SMA as the base algorithm and to verify that the different SASMA mechanisms enhance the SMA optimization capabilities, regardless of the type of optimization problem, a secondary evaluation is made with a constrained problem with inner relations between the variables, where SASMA is put against the original SMA, as well as with common metaheuristics used to solve the truss design problem, namely, a PSO with an inertia factor and with constriction factor, WOA, GWO, and other ordinary metaheuristics like gravitational search algorithm (GSA) [70], flower pollination algorithm (FPA) [71], bat algorithm (BA) [72], and gaining-sharing knowledge-based algorithm (GSK) [73]. The respective control parameters (

Table A4. Parameter settings for the benchmark algorithms applied in the second case study.

Algorithm	Parameter Settings
PSO w/inertia factor	${\omega }_{min}=0.4,{\omega }_{max}=0.9,c_1=c_2=2.05$
PSO w/constriction factor	$c_1=c_2=2.05$
WOA	$p=0.5,a\mathrm{linearly}\mathrm{decreasing}\mathrm{from}2\mathrm{to}0$
GWO	$a\mathrm{linearly}\mathrm{decreasing}\mathrm{from}2\mathrm{to}0$
GSA	$\alpha =20,G_0=100,R_{\mathrm{power}}=1$ $R_{\mathrm{norm}}=2,\mathrm{ElitistCheck}=1\left(\mathrm{True}\right)$
FPA	$\beta =1.5,s_0=0.01,p=0.8$
BA	$f_{min}=0,f_{max}=2,\alpha =0.95$ $r_{min}=r^0=0.25,\gamma =0.015$
GSK	$K=10,K_r=0.9,K_f=0.5,p=0.1$
SASMA	$z=0.03$

) are used to evaluate, under the same error accuracy metrics/tests assumptions, thus providing an additional comparison of SASMA optimization capabilities. Yet, since we are dealing with a single optimization problem, the results of the two non-parametric statistical tests, which gauge the differences in the errors of the different algorithms, are written together alongside the descriptive statistics in

Table 5. SASMA descriptive statistical errors and non-parametric test results versus other state-of-the-art algorithms on the 25C truss design problem.

Algorithm	Mean	STD	Min	Mean Rank	Signed Rank
PSO w/inertia	$5.534\times {10}^2$	$1.577\times {10}^1$	$5.452\times {10}^2$	4.80	+
PSO w/constr	$5.472\times {10}^2$	$4.508\times {10}^0$	$5.453\times {10}^2$	4.11	+
WOA	$6.233\times {10}^2$	$3.911\times {10}^1$	$5.710\times {10}^2$	8.97	+
GWO	$5.469\times {10}^2$	$9.491\times {10}^{-1}$	$5.455\times {10}^2$	4.83	+
GSA	$5.624\times {10}^2$	$1.443\times {10}^1$	$5.458\times {10}^2$	7.43	+
FPA	$5.500\times {10}^2$	$3.058\times {10}^0$	$5.457\times {10}^2$	6.60	+
BA	$6.883\times {10}^2$	$5.561\times {10}^1$	$5.915\times {10}^2$	9.97	+
GSK	$5.452\times {10}^2$	$1.930\times {10}^{-4}$	$5.452\times {10}^2$	1.00	−
SMA	$5.465\times {10}^2$	$8.644\times {10}^{-1}$	$5.453\times {10}^2$	4.17	+
SASMA	$5.459\times {10}^2$	$5.056\times {10}^{-1}$	$5.452\times {10}^2$	3.11	+

According to the Wilcoxon signed rank test at the 5% significance level, the symbol “+”, or “−” indicates that SASMA performs better, or worse than the corresponding metaheuristic, respectively. The best results (Mean, STD, Min) and the best Friedman mean rank are highlighted in grey.

. The convergence curves for all the algorithms, regarding the test run where SASMA reached the minimum value, are shown in Figure 15.

The non-parametric test results reveal that GSK is the best performing algorithm, with a lower mean rank, as well as the lowest mean, standard deviation, and minimum error values of 5.4516 × 10², 1.9313 × 10⁻⁴, and 5.4516 × 10², respectively. The proposed SASMA then follows as a close second-best ranked algorithm, as proven by the mean rank, and with fairly nearby mean and minimum values of 5.4585 × 10² and 5.4523 × 10², respectively. With the exception of GSK, SASMA is able to outscore all the other algorithms as attested by the “+” signal from the Wilcoxon signed rank test in all the columns in Table 5. Completing the top three is the SMA, presenting a standard deviation with a negative exponent, which is only achieved by GSK, SASMA, SMA, and GWO (in this ranking order). Unlike in Case Study I, WOA and GSA are now among the bottom ranked algorithms (together with BA), both in the error metrics and the mean rank, highlighting perfectly the “No Free Lunch theorem”, i.e., algorithms that work well in a class of problems will fail on another class of problems.

Figure 15 highlights a similar trend to the one observed in Case Study I, namely that SMA tends to present a faster convergence in the initial phase of the search space, certainly with fewer problem dimensions, proving that the intended balance mechanisms are effectively slowing down its surrogate-assisted counterpart convergence by favoring a more global nature search in this phase, with the hopes of bearing the fruits later on. Both the PSO variants and GSK are very good in the initial phase, whereas GSK is the only one capable of outperforming SASMA and SMA in the latter stages. Unlike what was seen in Case Study I, WOA now shows a compromised stagnation almost right from the get-go, which may suggest an inadequacy of its control parameters, which once again underscores the importance of using a more (control) parameter-independent algorithm like SMA.

6. Conclusions

Solving complex real-world optimization problems with computationally efficient algorithms is a major trend of the evolutionary computation field. Traditional metaheuristics tend to rely on many FEs, which is troubling when the problem requires a hefty computational cost (model simulation). To address this challenge, surrogate models, which constitute an approximation model of the real objective function, are used in lieu of these expensive FEs, thus reducing the computational cost. With the advent of many SAEAs, the focus has been not only in the diversification of the base metaheuristic but more importantly on the mechanisms that control the flow of information between the algorithm’s swarm and surrogate building, i.e., how and which are the positions and respective fitness selected from the evolving swarm to build the approximated version of the objective function. And to this end, it is crucial that the database, as an intermediary layer, has the adequate information to ensure a general level of accurateness in the surrogate-building stage.

As such, the proposed SASMA relies on a dual-based criterion that prioritizes simultaneously the surrogate value of a given (discovered) position and its distance to the already stored positions as the chosen update mechanism of the DB. With a balance that changes with the course of the iterations from the distance to the surrogate value (minimum), SASMA ensures that the priority is to have a more spread set of stored positions in the exploration phase, i.e., mapping the search space, while it targets more accuracy in the latter phase, when the SAEA is already converging (exploitation). By using this approach together with SMA, which does not need to use local information of the individual swarm agents, we can avoid the constraints posed by a double-layered surrogate, where often times the algorithm’s local best position, as in PSO, is used to assemble a second local surrogate, which runs in parallel to the global surrogate, often requiring an independent DB(s), thus playing a key role in the refining stages of the search space process with an added computational cost. Therefore, in this work, only a global DB and surrogate is considered, and so we use the several control parameters to shift the balance of both the DB update and the assembling training data selection for the surrogate building as a way to move from a more global surrogate in the first phase to a more local surrogate in the last phase of the optimization.

To validate the performance of the proposed SASMA, we compared it against six well-regarded SAEAs on seventeen widely used benchmark mathematical functions (unconstrained optimization) with dimensionalities of 30 and 100, as well as with a set of MHs. Moreover, an additional case study, where a classical truss design (constrained) problem is considered, was included. The experimental results indicate that the proposed SASMA takes advantage of the SMA versatility as an effective population-based metaheuristic, coupled with a novel DB management strategy and surrogate building approach to accurately perform stochastic optimization. These unique traits explain why SASMA was able to outmatch or closely trail almost all the best results in terms of the mean, standard deviation, and minimum error, inheriting the good convergence properties of SMA, as can be seen in the convergence curves, with an accuracy that increases substantially around the 1000-FE mark. And, for the same token, this explains why it was best ranked in the vast majority of all test functions (Case Study I) in terms of both the Wilcoxon signed rank and Friedman test (mean rank). It is also worth noting that the additional overhead associated with database management and surrogate building mechanisms proved to be dominated by the surrogate’s least-squares fit and the DB distance computations, both scaling with the DB size and with the subset size. In comparison with the original SMA, the computational overhead of SASMA remained modest throughout our experiments and, importantly, was consistently in line with—or even more favorable than—the computation time profiles observed for the other SAEAs (in all test functions).

With fewer FEs, the increased initial phase variance explains why the good overall mean error is not matched with a similar performance in terms of STD, which is an expected consequence of the followed balanced approach. The shift from a global to a local surrogate nature, i.e., a more spread set of positions in this initial phase (when only a couple hundred FEs have passed) both in the SASMA swarm and in the DB, with the focus gradually changing (linearly) from favoring distant solutions towards quality solutions impacts the surrogate building. Meanwhile, from the half point onwards (with further evaluations), we can see the benefits of this balanced approach, with SASMA effectively moving towards the solution, particularly with 100D, which attests its adequacy for expensive optimization problems. Case Study II, the constrained optimization, with a smaller number of problem dimensions, further proved SASMA’s capabilities with competitive descriptive statistical and non-parametric results, outmatching all the tested metaheuristics, except for GSK. Finally, it is important to acknowledge certain limitations of the present study. The scalability analysis was conducted up to 100D, a commonly adopted upper benchmark in SAEA research, and our results confirm that SASMA preserves the performance trends previously observed with 30D, although exploring even higher dimensionalities remains an open direction for future work. Likewise, the adoption of a cubic RBF proved not to be an obstacle but rather a robust, parameter-free surrogate choice that aligns well with the dynamics of SASMA, although—as with any modelling option—future studies may explore alternative kernels such as Gaussian functions or even other surrogate models (e.g., Kriging).