A Binary Chaotic White Shark Optimizer

Abstract

This research presents a novel hybrid approach, which combines the White Shark Optimizer (WSO) metaheuristic algorithm with chaotic maps integrated into the binarization process. Inspired by the predatory behavior of white sharks, WSO has shown great potential to navigate complex search spaces for optimization tasks. On the other hand, chaotic maps are nonlinear dynamical systems that generate pseudo-random sequences, allowing for better solution diversification and avoiding local optima. By hybridizing WSO and chaotic maps through adaptive binarization rules, the complementary strengths of both approaches are leveraged to obtain high-quality solutions. We have solved the Set Covering Problem (SCP), a well-known NP-hard combinatorial optimization challenge with real-world applications in several domains, and experimental results indicate that LOG and TENT chaotic maps are better after statistical testing. This hybrid approach could have practical applications in telecommunication network optimization, transportation route planning, and resource-constrained allocation.

1. Introduction

In the constant search for solutions to complex problems that arise in a variety of fields, optimization plays a crucial role. One such challenging problem is the Set Covering Problem (SCP), a fundamental issue in combinatorial optimization with practical applications in logistics, route planning, resource allocation, and network optimization [1]. The SCP involves finding the minimum set of subsets that covers all given elements, aiming to minimize the cost or the number of selected subsets. Despite its apparent simplicity, the SCP is an NP-hard problem, implying that its complexity increases exponentially with the size of the problem, making it challenging to obtain optimal solutions through exact methods for large-scale instances.

Researchers have explored various strategies to address the SCP efficiently and effectively in response to this complexity. Among these strategies, metaheuristic algorithms have emerged as a promising option due to their ability to find high-quality solutions in a reasonable time [2]. However, adapting these algorithms to combinatorial problems like the SCP presents unique challenges that require innovative approaches.

The field of metaheuristics has grown considerably in recent years, as demonstrated by Rajwar et al. in their systematic literature review [3], where they evidence more than 500 metaheuristics. One of the metaheuristics that has gained attention in this context is the White Shark Optimizer (WSO). Modeled after the natural behavior of great white sharks, WSO operates as a population-based algorithm capable of finding solutions close to the global optimum in complex and nonlinear problems. Its ability to explore the search space effectively makes it an attractive tool for addressing the SCP and other combinatorial optimization problems [4]. However, given its continuous nature, adapting WSO to combinatorial problems like the SCP requires additional techniques to ensure the quality of the solutions obtained.

Another interesting trend in the study of metaheuristics is hybridization. Hybridizations aim to improve the exploration and exploitation capabilities of metaheuristics. Currently, there are different types of hybridizations:

• Metaheuristics improving metaheuristics: This type of hybridization consists of combining two metaheuristic algorithms. Usually, one metaheuristic has exploration virtues and the other has exploitation virtues [5,6].
• Hyperheuristics: Here, we have again two metaheuristics but with hierarchies where a high-level metaheuristic guides a low-level one [7].
• Machine learning improving metaheuristics: In this approach, machine learning techniques are incorporated to improve the performance of metaheuristics [8].
• Chaos improving metaheuristics: This approach uses chaos theory to modify the stochastic behavior of metaheuristics [9,10,11].

This is where chaotic maps come into play, nonlinear dynamic systems that exhibit seemingly random but deterministic behavior [12]. Integrating chaotic maps into the binarization process of WSO would allow for the effective exploration of the SCP search space, enhancing solution diversity and avoiding local optima.

The binarization process is essential for a continuous metaheuristic to solve binary combinatorial optimization problems. The motivation for binarizing metaheuristics lies in the Free Lunch Theorem [13,14], which tells us that no algorithm can solve all optimization problems. The literature shows that the two-step technique is the most widely used method for binarizing metaheuristics [15].

In this context, this work proposes a hybrid approach that combines WSO with chaotic maps to address the SCP and obtain high-quality solutions. Through this innovative combination, the aim is to overcome the inherent challenges of the SCP and provide results with practical applications in various fields, from telecommunications network optimization to transportation route planning and limited resource allocation.

A summary of the content structure of the following sections: Section 2 presents the conceptual and mathematical definition of the SCP. Section 3 presents the work related to the SCP, binary problem solving, and chaotic maps in metaheuristics. Section 4 presents the conceptual and mathematical definition of WSO. Section 5 presents how to binarize continuous metaheuristics. Section 6 presents our research proposal. Section 7 presents the experimental results and their discussion to close with the conclusions and future works in Section 8.

2. Set Covering Problem

In combinatorial optimization, numerous practical problems of great importance involve finding the best combination of binary or discrete variables. An example of this is the Set Covering Problem, which focuses on finding the minimum number of subsets required to cover all the given elements, thus reducing the overall cost or the number of chosen subsets.

The objective function in the context of Set Covering is a mathematical expression that represents the quality or efficiency of a proposed solution to the problem. In Set Covering, the objective is to minimize this function, which involves finding the most efficient combination of sets to cover all elements of the given universe.

Let us define a binary matrix a with dimensions $m\times n$, where $a_{ij}=1$ indicates that the j-th column includes the i-th row, and $a_{ij}=0$ if it does not. Each column j comes with a non-negative cost $c_j$. The sets $I=\{1,\dots ,m\}$ and $J=\{1,\dots ,n\}$ represent the rows and columns, respectively. The Set Covering Problem aims to find a subset of columns $S\subseteq J$ such that every row in I is covered by at least one column in S, while minimizing the total cost of the selected columns.

$$\mathrm{Minimize}f\left(\mathbf{x}\right)=\sum _{j=1}^n{c}_j{x}_j$$

(1)

$$\sum _{j=1}^n{a}_{ij}{x}_j\ge 1,\forall i\in I,$$

(2)

where $x_j\in \{0,1\},\forall j\in J$.

Here, $x_j$ represents the selection status of column j, where $x_j=1$ means the column is included, and $x_j=0$ means it is not. The element $a_{ij}$ corresponds to the respective entry in the binary matrix.

3. Related Work

3.1. Set Covering Optimization

The Set Covering Problem (SCP) is a key challenge in combinatorial optimization. Because of its importance in numerous real-world scenarios, it is widely studied in academic research and industrial applications. The SCP is defined as the task of selecting a minimum set of subsets from a given set to cover all elements of another set. This problem has diverse logistics, route planning, resource allocation, and network optimization applications.

A wide range of approaches and techniques have been proposed in the literature to solve the SCP. Among the most prominent methods are exact methods and metaheuristics. Exact methods, such as integer linear programming, guarantee finding the optimal solution but can be computationally expensive for large-scale problems. On the other hand, metaheuristics, such as genetic algorithms [16], tabu search [17], and simulated annealing [18], offer approximate solutions in a reasonable time and are effective for solving moderate to large-scale SCP instances.

In addition to these approaches, hybrid and advanced approaches have been proposed that combine different optimization techniques to improve performance in solving the SCP [19]. These approaches may integrate metaheuristics with exact algorithms, data preprocessing techniques, or domain-specific heuristics to achieve even better solutions.

3.2. Binary Problems Resolution

Transfer functions are key mechanisms for adapting continuous metaheuristic algorithms to binary optimization problems. These functions map continuous values from the search space to real values in the range [0, 1] [20].

The sigmoid function has been widely used, but there are limitations regarding its ability to maintain a proper balance between exploration and exploitation of the search space. Therefore, several alternative transfer functions have been proposed and studied to overcome the shortcomings of the sigmoid function. These new functions aim to enable better transitions between exploration and exploitation phases during algorithm execution, potentially improving performance in solving binary optimization problems [21].

In addition to transfer functions, binarization rules also play a crucial role in the performance of binary metaheuristic algorithms. These rules determine how continuous values mapped to real numbers are further mapped to binary values. Some commonly used rules include the threshold rule, roulette rule, elite-based rule, and elite-roulette. Several studies have analyzed the relative importance of transfer functions and binarization rules. The results suggest that binarization rules can have a greater impact on performance than the transfer functions themselves. In particular, elite-based or elite-roulette rules have generally produced the best results [8].

However, according to the principle of no free lunch [22], there is no single general technique capable of efficient binarization for all optimization problems. The performance of a binary metaheuristic algorithm will depend on the specific problem, the transfer function, and the binarization rule used.

3.3. Chaotic Maps into Metaheuristic

Dynamic systems, being nonlinear and non-periodic, exhibit chaotic behaviors that are deterministic but appear random. In recent decades, they have been widely studied and utilized in the field of metaheuristics to enhance the exploration of search spaces and avoid getting trapped in local optima [23]. The implementation of chaotic mappings is valued for its computational efficiency and the need for a few initial parameters. These systems are susceptible to minor variations in initial conditions. The literature highlights some relevant chaotic maps [10].

Table 1. Table of chaotic maps.

Type	Chaotic Maps
Logistic Map	$x_{k+1}=c·x_k(1-x_k)$, $c=4$
Piecewise Map	$x_{k+1}=\left\{\begin{array}{cc}{\displaystyle \frac{x_k}{l}}\hfill & 0\le x_k<l\hfill \\ {\displaystyle \frac{x_k-l}{0.5-l}}\hfill & l\le x_k<0.5\hfill \\ {\displaystyle \frac{1-l-x_k}{0.5-l}}\hfill & 0.5\le x_k<1-l\hfill \\ {\displaystyle \frac{1-x_k}{l}}\hfill & 1-l\le x_k<1\hfill \end{array}\right.,\mathrm{where}l=0.4$
Sine Map	$x_{k+1}={\displaystyle \frac{c}{4}}\sin \left(\pi x_k\right)$, where $c=4$
Singer Map	$x_{k+1}=\mu (7.86x_k-23.31x_k^2+23.75x_k^3)-13.302875x_k^4,\mu =1.07$
Sinusoidal Map	$x_{k+1}=c{x}_k^2\sin \left(\pi x_k\right)$, where $c=2.3$
Tent Map	$x_{k+1}=\left\{\begin{array}{cc}{\displaystyle \frac{x_k}{0.7}}\hfill & \mathrm{if}{x}_k<0.7\hfill \\ {\displaystyle \frac{10}{3}}(1-x_k)\hfill & \mathrm{if}{x}_k\ge 0.7\hfill \end{array}\right.$
Circle Map	$x_{k+1}=\mathrm{mod}\left(x_k+d-{\displaystyle \frac{c}{2\pi }}·\sin \left(2\pi x_k\right),1\right)$, where $c=0.5\mathrm{and}d=0.2$

and Figure 1 show the mathematical definition and behavior of the chaotic map, respectively.

One of the earliest works introducing the use of chaotic maps in metaheuristics was by Ouyang et al. [24], where they proposed Chaotic Particle Swarm Optimization (CPSO) using the logistic map. Since then, numerous algorithms based on different chaotic maps have been proposed.

Several well-known chaotic maps used in metaheuristics include the logistic map, piecewise map, sine map, Singer map, and sinusoidal map [10]. These chaotic maps have been applied in various evolutionary algorithms, including chaotic genetic algorithms [25,26,27], chaotic particle swarm optimization [24], and chaotic artificial bee colony optimization [28].

4. White Shark Optimizer

In the oceanic environment, white sharks are capable of detecting the presence of prey in deep waters, thanks to their senses of electrical perception, vision, pressure, smell, and hearing, as shown in Figure 2. It is important to note, as shown in Figure 3, that the shark’s hearing perception is extensive, as sharks possess an auditory system that runs through their entire body. Despite their senses, they lack prior knowledge of the exact locations of these food sources within a specific region. As a result, white sharks need to extensively search to locate food sources in the vast sea. This research identified three primary behaviors of white sharks that aid in efficient prey localization [4].

• Movement speed towards prey: White sharks employ an undulating movement that harnesses the waves generated by the prey’s displacement. This movement, guided by their senses of hearing and smell, enables the shark to navigate towards the food source.
• Random prey search: White sharks head towards regions where prey has been identified and stay near the most promising targets. This approach relies on randomly exploring possible food sources in the deep ocean.
• Behavior of nearby prey localization: White sharks mimic the behavior of fish schools to locate nearby prey. In this approach, a shark moves towards the most successful individual in the search, facilitating the location of the optimal prey.

The main objective of WSO is to find optimal solutions in optimization problems, including feature selection problems [29], intrusion detection [30], proton exchange membrane fuel cell (PEMFC) design [31], optimal energy flow [32], and estimation of parameters for lithium-ion battery models [33].

In feature selection, WSO has been adapted to address high-dimensional problems, where identifying an optimal subset of features is crucial for model performance. Enhanced binary variants of WSO, such as Binary-Distribution-based WSO (BDWSO), Binary Sine Cosine WSO (BSCWSO), and Binary Hybrid Sine Cosine WSO (BHSCWSO), have been developed to improve the balance between exploration and exploitation in complex multi-peak search problems [29].

In intrusion detection, WSO has been applied to enhance intrusion prediction models by selecting informative features, leading to improved performance of machine-learning-based intrusion detection systems. Improved variants of WSO, such as BIWSO1, BIWSO2, and BIWSO3, have demonstrated their effectiveness in terms of classification accuracy, precision, recall, and F1 scores [30].

In the field of PEMFCs, WSO has been used to optimize the parameter design of fuel cells, resulting in improved efficiency and performance of these cells. WSO has proven to be more effective than other optimization approaches, such as Salp Swarm Algorithm (SSA) and Harris Hawks Optimization (HHO) [31].

Furthermore, WSO has been successfully applied to optimal energy flow problems [32] and estimation of parameters for lithium-ion battery models [33]. Hybrid variants of WSO, such as Hybrid White Shark Equilibrium Optimizer (WSEO), have effectively optimized energy scheduling problems in IoT-based systems.

In summary, the White Shark Optimizer has proven to be a promising and versatile metaheuristic that has been adapted and enhanced to address various optimization problems in various fields. Its improved variants have shown superior accuracy, convergence, and efficiency performance compared to other established optimization algorithms.

4.1. Mathematical Model

4.1.1. Parameter Initialization

The WSO framework begins by setting up a matrix that represents the initial population of solutions. This matrix has dimensions $N\times d$, where N is the population size, and d corresponds to the problem’s dimensionality, as detailed below:

• ub: Upper bound.
• lb: Lower bound.
• n: Number of search agents.
• d: dimension.
• t: Current iteration.
• T: Maximum iterations.

Then, we initialize the population of initial solutions for the sharks based on the parameters above, and subsequently initialize the initial velocity and position, where rand is a continuous random number within the range [0, 1].

The initial population is generated within the search space using a uniform random distribution, as outlined below.

$$w=\left[\begin{array}{cccc}{w}_{1,1}& w_{1,2}& \cdots & w_{1,d}\\ w_{2,1}& w_{2,2}& \cdots & w_{2,d}\\ ⋮& ⋮& \ddots & ⋮\\ w_{n,1}& w_{n,2}& \cdots & w_{n,d}\end{array}\right]$$

(3)

In this context, $w_{i,j}$ denotes the starting vector for the i-th white shark in the j-th dimension. The values $u_j$ and $l_j$ correspond to the maximum and minimum bounds of the search area in the j-th dimension, respectively, and r is a random value generated between $[0,1]$.

$$\begin{array}{c}{w}_{ij}=l_j+rand\times (u_j-l_j)\end{array}$$

(4)

4.1.2. Movement Speed towards Prey

White sharks are the ultimate hunters. They dedicate a significant part of their existence to searching for and pursuing their prey, using an extraordinary combination of highly developed senses: acute vision, fine hearing, and exceptional smell.

These marine predators have the ability to detect the location of their prey by interpreting disturbances in the water. The waves generated by the movements of the animals they hunt provide crucial information to the shark. Once the white shark has identified these aquatic signals, it begins its approach towards the prey.

This stalking and approaching behavior can be mathematically represented by a specific equation that models the shark’s movement in relation to its target.

$$v_{t+1}^i=\mu \left[v_t^i+p_1\left(w_{gbes{t}_t}-w_t^i\right)\times c_1\right]+p_2\left(w_{bes{t}_t}^{v_i}-w_t^i\right)\times c_2$$

(5)

Within this framework, the terms $v_{t+1}^i$ and $v_t^i$ are crucial. They correspond to the updated speed and the current position of the i-th shark, respectively. The collective best position found by all sharks so far is indicated by $w_{gbes{t}_t}$. Conversely, $w_t^i$ describes the present location of the i-th shark, while $w_{bes{t}_t}^{v_i}$ captures the optimal position that this shark has discovered throughout its journey.

Random parameters $c_1$ and $c_2$, drawn from the range $[0,1]$, are utilized to influence the search process. The factor $\mu$ is essential for managing the convergence rate of the WSO algorithm. In addition, $p_1$ and $p_2$ serve as weights to control how $w_{gbes{t}_t}$ and $w_{bes{t}_t}^{v_i}$ affect the shark’s current position $w_t^i$. The values of these parameters $p_1$, $p_2$, and $mu$ are derived using specific formulas presented below:

$$p_1=p_{\max }+(p_{\max }-p_{\min })\times e^{-{\left({\displaystyle \frac{4k}{K}}\right)}^2},$$

(6)

$$p_2=p_{\min }+(p_{\max }-p_{\min })\times e^{-{\left({\displaystyle \frac{4k}{K}}\right)}^2},$$

(7)

$$\mu ={\displaystyle \frac{2}{\left|2-\tau -\sqrt{{\tau }^2-4\tau }\right|}}.$$

(8)

The forces $p_{\max }$ and $p_{\min }$ establish the upper and lower thresholds needed to guide the movement of the white sharks effectively. The symbols k and K represent the current iteration number and the total number of iterations, respectively. Additionally, $\tau$ acts as an acceleration coefficient to influence the process.

4.1.3. Updating the Sharks’ Velocity in the Water

In this section, we encounter a decision equation where two scenarios are generated:

• Great white sharks randomly update their position around the prey guided by smell.
• Great white sharks can update their position in the search space based on hearing the prey.

These two decisions depend on a value rand and $mv$, where $mv$ represents the movement strength that increases over time to ensure convergence by accelerating speed.

The first equation updates the i-th row of $w_i^{+1}$ by element-wise multiplication with $\neg \oplus w_o$. Here, $\neg \oplus w_o$ denotes the negation of a bitwise XOR operation between values a and b, where a and b denote the boundaries.

And the second equation sums the position with the velocity divided by the frequency of the shark’s undulatory movement.

$$w_i^{t+1}=\left\{\begin{array}{cc}{w}_i^t·\neg \oplus w_o+u·a+l·b;\hfill & \mathrm{rand}<mv\hfill \\ w_i^t+{\displaystyle \frac{v_i^t}{f}};\hfill & \mathrm{rand}\ge mv\hfill \end{array}\right.$$

(9)

$$a=\mathrm{sgn}(w_i^t-u)>0$$

(10)

$$b=\mathrm{sgn}(w_i^t-l)<0$$

(11)

The $sgn$ function is applied to check if the difference between each element of the vector and the boundaries is positive or negative. The function outputs 1 if the input is positive, $-1$ if it is negative, and 0 when the input is zero. As a result, the variable a is set to true if the difference is positive, while b is marked true if the difference is negative. This approach allows for the categorization or filtering of data based on whether they lie above or below the defined boundaries.

The frequency f of the oscillatory motion is given by

$$f=f_{\min }+{\displaystyle \frac{f_{\max }-f_{\min }}{f_{\max }+f_{\min }}}.$$

(12)

$f_{\min }$ and $f_{\max }$ correspond to the lowest and highest frequencies of the oscillatory motion, respectively.

The parameter $mv$ measures the intensity of sensory abilities, such as hearing and smell, which grow stronger as the number of iterations increases.

$$mv={\displaystyle \frac{1}{\left(a_0+e^{\left(\frac{K/2-k}{a_1}\right)}\right)}},$$

(13)

where $a_0$ and $a_1$ are constants that control exploration and exploitation behaviors.

4.1.4. Updating the Sharks’ Position Based on the Schooling of Fish

This code segment implements a behavior known as “nearby prey localization”. In this stage, the great white sharks adjust their positions using information from nearby best solutions. For each shark in the population, a new position is calculated based on the distance between its current location and the best global solution. If it is the first shark, its position is updated directly with a random displacement. For subsequent sharks, a new position is calculated by weighing the best global solution and the position of the previous shark. This allows sharks to explore and exploit nearby areas based on shared information, contributing to the efficiency of solution search in the search space. Here, $S_s$ represents a suggested parameter to express the strength of the olfactory and visual senses of the great white sharks when following other sharks that are close to the optimal prey, and $D_w$ represents the distance between the prey and the shark.

The approach of the white shark as it converges on the prey can be modeled in the following manner:

$${w^{\prime }}_i^{t+1}=w_{\mathrm{gbest}}^t+r_1·\overrightarrow{D_w}·\mathrm{sgn}(r_2-0.5)\mathrm{if}{r}_3<s_s.$$

(14)

${w^{\prime }}_i^{t+1}$ indicates the next position of the i-th white shark with respect to its prey. The function $\mathrm{sgn}(r_2-0.5)$ determines the sign of the argument: it returns 1 if positive, −1 if negative, and 0 if zero, guiding the direction of the search. The terms $r_1$, $r_2$, and $r_3$ are random values that are continuously distributed within the range $[0,1]$.

$$\overrightarrow{D_w}=\left|\mathrm{rand}\times (w_{\mathrm{gbest}}^t-w_i^t)\right|$$

(15)

The parameter $S_s$ is used to describe the strength of the visual and olfactory senses of the great white shark when closely following its prey, calculated as follows:

$$S_s=\left|1-e^{-a_2·{\displaystyle \frac{t}{T}}}\right|.$$

(16)

In this scenario, $a_2$ functions as a positive constant that regulates the trade-off between exploration and exploitation. In this study, $a_2$ is assigned a value of 0.0005 for all the experiments. The author made this choice [4] following an in-depth assessment of various problem instances.

To create a mathematical model of the behavior of the white shark group, the top two optimal solutions were retained. In contrast, the positions of the remaining sharks were adjusted in relation to these best solutions. The formula below was introduced to characterize the behavior of the white shark collective:

$$w_{k+1}^i={\displaystyle \frac{w_k^i+w_{k+1}^{\prime i}}{2\times rand}},$$

(17)

where rand represents a uniformly generated random value within the range $[0,1]$.   

4.1.5. Pseudocode for WSO

The Algorithm 1 describes the pseudocode of WSO, detailing the initialization of parameters, the calculation of positions and velocities, and the binarization of values. This process is repeated until the defined termination criteria are met.

Algorithm 1 White Shark Optimizer

1: Define the problem parameters.   2: Define the parameters for the WSO.   3: Generate the initial positions of the WSO randomly.   4: Set the initial population’s velocity.   5: Evaluate the initial population’s positions   6: while $t>T$ do   7:     Sequentially revise the parameters v, $p_1$, $p_2$, $\mu$, a, b, $w_o$, f, $mv$, and $S_s$,   8:     respectively.   9:     for $i=1,\dots ,n$ do 10:         $v_{i_{t+1}}=\mu \left[v_{i_t}+p_1\left(w_{g_{{\mathrm{best}}_t}}-w_{i_t}\right)\times c1+p_2\left(w_{{\nu }_{i_t}^{\mathrm{best}}}-w_{i_t}\right)\times c2\right]$ 11:     end for 12:     for $i=1,\dots ,n$ do 13:         if $rand<mv$ then 14:            $w_{i_{t+1}}=w_{i_t}·\neg \oplus w_o+u·a+l·b$ 15:         else 16:            $w_{i_{t+1}}=w_{i_t}+{\displaystyle \frac{v_{i_t}}{f}}$ 17:         end if 18:     end for 19:     for $i=1\dots ,n$ do 20:         if $rand\le S_s$ then 21:            $\overrightarrow{D_w}=|rand\times (w_{g_{bes{t}_t}}-w_{i_t})|$ 22:            if $i==1$ then 23:                $w_{t+1}^i=w_{g_{{\mathrm{best}}_t}}+r_1{\overrightarrow{D}}_w·\mathrm{sgn}(r_2-0.5)$ 24:            else 25:                ${\acute{w}}_{t+1}^i=w_{g_{{\mathrm{best}}_t}}+r_1{\overrightarrow{D}}_w·\mathrm{sgn}(r_2-0.5)$ 26:                $w_{t+1}^i={\displaystyle \frac{w_{i_t}+{\acute{w}}_{t+1}^i}{2\times \mathrm{rand}}}$ 27:            end if 28:         end if 29:     end for 30:     Adjust the white sharks’ positions that cross the boundary limits 31:     Evaluate and adjust the updated positions 32: end while 33: Return the best solution obtained up to now

5. Binarization Techniques

Within the context of continuous metaheuristics, binarization techniques stand out [15], which aim to transform values from a continuous domain into a binary format. This process is carried out with the goal of preserving the ability to generate high-quality solutions characteristic of continuous metaheuristics, thereby facilitating the attainment of binary solutions of equivalent quality.

5.1. Two-Step Technique

This technique is a strategy for transforming continuous combinatorial optimization problems into equivalent binary problems [34]. This approach is often used when applying metaheuristics to combinatorial optimization problems involving continuous variables. The process consists of two main steps, as shown in Figure 4.

5.1.1. Transfer Function

The transfer function is fundamental in the binarization process, particularly in the realm of continuous metaheuristics. It is one of the most commonly used normalization techniques and was first introduced in [35]. Its main role is to transform continuous values into a predefined range, typically $[0,1]$. This transformation is key for converting continuous solutions into a binary format, enhancing their effectiveness in optimization algorithms that rely on binary search methods.

By applying the transfer function, continuous values are appropriately scaled and adjusted, facilitating their subsequent binarization and efficient utilization in optimization algorithms. Therefore, the transfer function constitutes a fundamental step in the binarization process, significantly contributing to the effectiveness and efficiency of continuous metaheuristics in various optimization applications.

In Figure 5, the graph generated by the S-shape and V-shape equations can be observed, which are named as such due to the shape they produce. In

Table 2. Transfer function table.

S-Shaped	Equation	V-Shaped	Equation
S1	$T\left(d_j^i\right)={\displaystyle \frac{1}{1+e^{-2d_i^j}}}$	V1	$T\left(d_i^j\right)=\left|\mathrm{erf}\left({\displaystyle \frac{\sqrt{\pi }}{2}}{d}_i^j\right)\right|$
S2	$T\left(d_j^i\right)={\displaystyle \frac{1}{1+e^{-d_i^j}}}$	V2	$T\left(d_i^j\right)=\left|\tanh \left(d_i^j\right)\right|$
S3	$T\left(d_j^i\right)={\displaystyle \frac{1}{1+e^{\frac{(-d_i^j)}{2}}}}$	V3	$T\left(d_i^j\right)={\displaystyle \frac{d_i^j}{\sqrt{1+{\left(d_i^j\right)}^2}}}$
S4	$T\left(d_j^i\right)={\displaystyle \frac{1}{1+e^{\frac{(-d_i^j)}{3}}}}$	V4	$T\left(d_i^j\right)=\left|{\displaystyle \frac{2}{\pi }}\arctan \left({\displaystyle \frac{\pi }{2}}{d}_j^i\right)\right|$

, these equations and their variations are presented.

5.1.2. Binarization Rules

Binarization refers to converting continuous values into binary states, typically 0 and 1. In this approach, binarization rules are applied to probabilities derived from a transfer function to produce a binary outcome. Various methods for executing this binarization process are detailed in the literature [36]. Selecting an appropriate binarization rule is crucial, as it depends on the specific context and the problem’s requirements. Proper use of these binarization rules is key to achieving precise and dependable results [34].

In

Table 3. Table of binarization rules.

Type	Binarization Rules
Standard (STD)	$X_{\mathrm{new}}^j=\left\{\begin{array}{cc}1\hfill & \mathrm{if}\mathrm{rand}\le T\left(d_w^j\right)\hfill \\ 0\hfill & \mathrm{else}.\hfill \end{array}\right.$
Complement (COM)	$X_{\mathrm{new}}^j=\left\{\begin{array}{cc}\mathrm{Complement}\left(X_w^j\right)\hfill & \mathrm{if}\mathrm{rand}\le T\left(d_w^j\right)\hfill \\ 0\hfill & \mathrm{else}.\hfill \end{array}\right.$
Static Probability (SP)	$X_{\mathrm{new}}^j=\left\{\begin{array}{cc}0\hfill & \mathrm{if}T\left(d_w^j\right)\le \alpha \hfill \\ X_w^j\hfill & \alpha <T\left(d_w^j\right)\le {\displaystyle \frac{1}{2}}(1+\alpha )\hfill \\ 1\hfill & T\left(d_w^j\right)\ge {\displaystyle \frac{1}{2}}(1+\alpha )\hfill \end{array}\right.$
Elitist (ELIT)	$X_{\mathrm{new}}^j=\left\{\begin{array}{cc}{X}_{\mathrm{Best}}^j\hfill & \mathrm{if}\mathrm{rand}<T\left(d_w^j\right)\hfill \\ 0\hfill & \mathrm{else}.\hfill \end{array}\right.$

, four binarization rules can be observed along with their respective equations and conditions.

6. A New Binary Approach for the White Shark Optimizer

The White Shark Optimizer (WSO) has proven to be effective in combinatorial optimization, but its adaptation to problems requiring binary solutions poses challenges, particularly in integrating continuous velocity values with binary populations. To address this issue, we propose binarizing both the population and the velocity, allowing the WSO to function effectively in discrete environments.

This hybrid approach combines the WSO with binarization techniques and chaotic maps. By using transfer functions such as the sigmoid and hyperbolic tangent, continuous solutions are converted into binary ones, improving solution diversity and preventing premature convergence. This method has practical applications in network optimization, route planning, and resource allocation.

6.1. Binarization of Velocity and Population

Since velocity is calculated in the WSO similarly to that in Particle Swarm Optimization (PSO), we adapted binarization techniques developed for PSO. This involves using transfer functions to convert continuous values into probabilities, determining binary states (0 or 1). Binarization is integrated into the WSO to ensure consistency between velocity and population, avoiding errors in position updates.

The decision to adapt the White Shark Optimizer by binarizing both the velocity and the population is based on the demonstrated effectiveness of similar techniques in variants of Particle Swarm Optimization (PSO), such as Binary PSO (BPSO). Various studies have explored and improved BPSO to address challenges in combinatorial problems, showing that binarization is crucial for optimizing in discrete spaces. For example, a modified BPSO that adopts concepts from genotype–phenotype representation and mutation operators from genetic algorithms has outperformed the original BPSO on benchmark functions [37]. Another study implemented an improved BPSO for feature selection in gene expression data, simplifying the selection process and improving classification accuracy [38]. Additionally, an improved BPSO has been used to solve unit commitment problems, demonstrating its superiority in terms of production cost and computation time [39]. In the field of association rule mining, a BPSO has been successfully employed to extract quality rules from transactional databases [40]. A novel approach for defining the velocity vector in BPSO has also been proposed, providing a more effective interpretation of continuous PSO in its binary version [41]. High-utility itemset mining has been optimized using BPSO, particularly in reducing the search space and improving efficiency [42]. Furthermore, studies have addressed the challenges of BPSO and proposed new solutions to improve its convergence rate and avoid trapping in local optima [43]. BPSO has been adapted for classical problems such as the knapsack problem, introducing probability functions that maintain diversity and effectiveness in the search process [44]. Finally, a BPSO has been developed for the lot-sizing problem, demonstrating its capability to find optimal solutions in most cases [45]. All these studies reinforce the validity of applying binarization techniques in the WSO, thus justifying the adaptation of the algorithm to discrete problems and improving its performance in combinatorial optimization tasks.

Below, in Equation (5), we can observe the velocity equation of WSO, where it can be seen that it has the same composition as the velocity of PSO [37].

To better appreciate the proposal, a flow chart has been created for a clearer understanding of the solution.

6.1.1. Initialization of Parameters

The initialization of parameters is a critical step in any optimization algorithm, including the proposed White Shark Optimizer (WSO). This process involves setting up the necessary parameters that will govern the behavior and performance of the algorithm throughout its execution.

Prior to setting up the parameters for the WSO, it is crucial to identify the parameters specific to the problem. This involves determining the population size, the dimensions of the search space, and the range of values that the variables can take.

The WSO requires several parameters to be initialized, such as the initial velocity of the population, the weight factors for velocity updates, and the parameters for the chaotic maps. These parameters include:

• Population size (n): Determines the number of candidate solutions in the population.
• Velocity parameters (v, $\mu$, $p_1$, $p_2$, $c1$, $c2$): These parameters control the speed and direction of the search process.

We set the initial velocities for each individual in the population. Typically, these velocities are initialized to small random values to ensure that the search process begins with minimal bias.

Proper initialization of these parameters is crucial for the algorithm’s convergence and efficiency. Careful consideration and tuning of these values can significantly impact the overall performance of the WSO.

6.1.2. Update Velocity and Positions

Updating the velocity and positions of the population is a fundamental step in the optimization process. This phase involves adjusting the velocity of each individual in the population and subsequently updating their positions based on the new velocities.

For better understanding, a flowchart has been created in Figure 6, representing the entire WSO algorithm process, including its binarization.

6.1.3. Binarize Velocity and Positions

Binarization is a crucial step for converting continuous values into discrete binary values. This step helps in adapting the continuous optimization process to a binary representation, which is often necessary for specific types of optimization problems.

• Transfer Function for Population: Convert the continuous positions of the individuals into binary values using a transfer function. This function maps continuous values into binary space based on a predefined threshold or chaotic map values.
• Transfer Function for Velocity: Similarly, apply a transfer function to the velocity values to obtain binary representations. This ensures that the velocities are also represented in a discrete binary format.
• Chaotic Map Values: Incorporate chaotic maps to introduce randomness into the binarization process. Chaotic maps provide a way to create diverse binary patterns, enhancing the exploration capability of the algorithm.
• Binarization Rule: Apply a binarization rule that uses the chaotic numbers to decide the binary representation of both positions and velocities. This rule determines the conversion threshold and ensures consistency in binary representation.

Proper binarization of velocity and positions allows the algorithm to operate effectively in a binary search space, which is essential for solving problems that require discrete solutions.

6.1.4. Sort Solutions

Sorting solutions is an essential step for evaluating and selecting the best candidates from the population. This process involves ranking the solutions based on their fitness or quality, which helps in determining the optimal solution.

• Evaluate Fitness: Compute the fitness of each solution based on the objective function or problem-specific criteria. Fitness values reflect how well each solution meets the optimization goals.

Sorting solutions ensures that the best candidates are given priority, facilitating the convergence of the algorithm towards optimal solutions.

6.1.5. Return Solutions

Returning the final solutions is the concluding step of the optimization process. This step involves selecting and presenting the best solution(s) obtained during the execution of the algorithm.

• Best Solution Selection: Based on the sorted solutions, identify the optimal solution(s) with the highest fitness values. This solution represents the best outcome achieved by the algorithm.
• Output: Present the optimal solution(s) and their corresponding fitness values as the result of the optimization process. This provides the final outcome of the algorithm and offers insights into the best solution found.
• Reporting: Include additional information such as the number of iterations, parameter settings, and performance metrics to provide a comprehensive view of the algorithm’s performance.

Returning the solutions allows users to assess the effectiveness of the optimization process and make informed decisions based on the results.

6.2. Repairing Complex Solutions

The simultaneous binarization of population and velocity reduces errors in repairing complex solutions, ensuring consistency in the binary space. This process is reinforced by chaotic maps, which provide pseudo-random sequences useful for creating dynamic thresholds in the binarization process. Algorithm 2 summarizes the proposal.

Algorithm 2 Binary White Shark Optimizer

1: Define the problem parameters.   2: Define the parameters for the WSO.   3: Generate the initial positions of the WSO randomly.   4: Set the initial population’s velocity.   5: Evaluate the initial population’s positions   6: while $t>T$ do   7:     Sequentially revise the parameters v, $p_1$, $p_2$, $\mu$, a, b, $w_o$, f, $mv$, and $S_s$,   8:     respectively.   9:     for $i=1,\dots ,n$ do 10:         $v_{i_{t+1}}=\mu \left[v_{i_t}+p_1\left(w_{g_{{\mathrm{best}}_t}}-w_{i_t}\right)\times c1+p_2\left(w_{{\nu }_{i_t}^{\mathrm{best}}}-w_{i_t}\right)\times c2\right]$ 11:     end for 12:     for $i=1,\dots ,n$ do 13:         if $rand<mv$ then 14:            $w_{i_{t+1}}=w_{i_t}·\neg \oplus w_o+u·a+l·b$ 15:         else 16:            $w_{i_{t+1}}=w_{i_t}+{\displaystyle \frac{v_{i_t}}{f}}$ 17:         end if 18:     end for 19:     for $i=1\dots ,n$ do 20:         if $rand\le S_s$ then 21:            $\overrightarrow{D_w}=|rand\times (w_{g_{bes{t}_t}}-w_{i_t})|$ 22:            if $i==1$ then 23:                $w_{i_{t+1}}=w_{g_{{\mathrm{best}}_t}}+r_1\overrightarrow{D_w}·\mathrm{sgn}(r_2-0.5)$ 24:            else 25:                ${\dot{w}}_{i_{t+1}}=w_{g_{{\mathrm{best}}_t}}+r1·\mathrm{sgn}(r2-0.5)$ 26:                $w_{i_{t+1}}={\displaystyle \frac{w_{i_t}+{\dot{w}}_{i_{t+1}}}{2\times \mathrm{rand}}}$ 27:                ${\displaystyle \frac{a}{b}}$ 28:            end if 29:         end if 30:         for $i=1\dots ,pop$ do 31:            for $j=1\dots ,dim$ do 32:                Obtain $T\left(d_{\mathrm{i}}^{\mathrm{j}}\right)$ by applying the transfer function to the population 33:                Get chaotic map value 34:                Obtain $X_{\mathrm{new}}^{\mathrm{j}}$ by applying the binarization rule using a chaotic number for the population. 35:                Obtain $T\left(d_{\mathrm{i}}^{\mathrm{j}}\right)$ by applying the transfer function to the velocity. 36:                Get chaotic map value 37:                Obtain $X_{\mathrm{new}}^{\mathrm{j}}$ by applying the binarization rule using a chaotic number for the velocity. 38:            end for 39:         end for 40:     end for 41:     Adjust the white sharks’ positions that cross the boundary limits 42:     Evaluate and adjust the updated positions 43: end while 44: Return the best solution obtained up to now

7. Results and Discussion

To assess the proposed method, various continuous metaheuristics will be employed to tackle the Set Covering problem and then compared against the White Shark Optimizer (WSO). The metaheuristics include the Grey Wolf Optimizer (GWO), Pendulum Search Algorithm (PSA), Sine Cosine Algorithm (SCA), Whale Optimization Algorithm (WOA), and Moth–Flame Optimization (MFO), with each tested across 16 unique configurations, as shown in

Table 4. Table of binarization rules and chaotic maps.

Chaotic Maps	STD	ELIT
Nothing	STD	ELIT
Logistic Map	STD_LOG	ELIT_LOG
Piecewise Map	STD_PIECE	ELIT_PIECE
Sine Map	STD_SINE	ELIT_SINE
Singer Map	STD_SINGER	ELIT_SINGER
Sinusoidal Map	STD_SINU	ELIT_SINU
Tent Map	STD_TENT	ELIT_TENT
Circle Map	STD_CIRCLE	ELIT_CIRCLE

.

7.1. Metaheuristics

The performance of WSO will be assessed using these algorithms to provide a comprehensive evaluation. The GWO, based on social hunting behaviors, will serve as a benchmark. The PSA and SCA offer innovative approaches with oscillatory movements and trigonometric functions, respectively, while the WOA and MFO are inspired by natural predator and moth behaviors. This range of metaheuristics ensures a thorough assessment of WSO’s strengths and weaknesses compared to both traditional and novel optimization techniques.

7.1.1. Grey Wolf Optimizer

Modeled after the social hierarchy found in grey wolf packs [46], the Grey Wolf Optimizer (GWO) introduces four key hierarchical roles: $\alpha$ (indicating the current best solution), $\beta$ (the second-best solution), $\delta$ (third in rank, fostering diversity), and $\omega$ (representing other potential solutions). This technique maintains a balance between exploration and exploitation within the search space, offering an effective method for tackling complex optimization challenges.

The pseudocode can be seen in Algorithm 3.

7.1.2. Pendulum Search Algorithm

Developed in 2022, the Pendulum Search Algorithm (PSA) is a population-based metaheuristic that draws inspiration from the harmonic motion of a simple pendulum [47]. The initial solutions are generated randomly, and their positions are adjusted through the following method:

$$X_{i,j}^t=X_{i,j}^t+{\mathrm{pend}}_{i,j}^t·({\mathrm{Best}}_j-X_{i,j}^t).$$

(18)

Let $X_{i,j}^t$ represent the position of the i-th solution in the j-th dimension during iteration t. The variable ${\mathrm{Best}}_j$ denotes the position of the optimal solution in the j-th dimension. The value of ${\mathrm{pend}}_{i,j}^t$ is then computed as follows:

$${\mathrm{pend}}_{i,j}^t=2·e^{(-t/t_{\max })}·cos(2\pi ·\mathrm{rand}).$$

(19)

Here, t denotes the current iteration, $t_{\max }$ represents the total number of iterations, and rand is a random value uniformly distributed within the interval $[0,1]$.

The pseudocode can be seen in Algorithm 4.

Algorithm 3 Grey Wolf Optimizer

1: Input: The population $X=\{X_1,X_2,\dots ,X_i\}$   2: Output: The updated population $X^{\prime }=\{X_1^{\prime },X_2^{\prime },\dots ,X_i^{\prime }\}$ and the best individual $X_{best}$   3: Initialize the population X randomly   4: Evaluate the objective function for each individual in the population X   5: Determine the best individual in the population ($X_{best}$)   6: for iteration (t) do   7:     $a=2-t·\left({\displaystyle \frac{2}{\mathrm{maxIter}}}\right)$   8:     Determine alpha wolf ($X_{\alpha }$)               ▹$X_{\alpha }$ is the best solution   9:     Determine beta wolf ($X_{\beta }$)             ▹$X_{\beta }$ is the second-best solution 10:    Determine delta wolf ($X_{\delta }$)              ▹$X_{\delta }$ is the third-best solution 11:    for solution (i) do 12:         for dimension (j) do 13:            $r1=\mathrm{rand}(0,1)$ 14:            $r2=\mathrm{rand}(0,1)$ 15:            $A1=2·a·r1-a$ 16:            $C1=2·r2$ 17:            $d_{\alpha }=\left|C1·X_{\alpha ,j}^t-X_{i,j}^t\right|$ 18:            $X1=X_{\alpha ,j}^t-A1·d_{\alpha }$ 19:            $r1=\mathrm{rand}(0,1)$ 20:            $r2=\mathrm{rand}(0,1)$ 21:            $A2=2·a·r1-a$ 22:            $C2=2·r2$ 23:            $d_{\beta }=\left|C2·X_{\beta ,j}^t-X_{i,j}^t\right|$ 24:            $X2=X_{\beta ,j}^t-A2·d_{\beta }$ 25:            $r1=\mathrm{rand}(0,1)$ 26:            $r2=\mathrm{rand}(0,1)$ 27:            $A3=2·a·r1-a$ 28:            $C3=2·r2$ 29:            $d_{\delta }=\left|C3·X_{\delta ,j}^t-X_{i,j}^t\right|$ 30:            $X3=X_{\delta ,j}^t-A3·d_{\delta }$ 31:            $X_{i,j}^t={\displaystyle \frac{X1+X2+X3}{3}}$ 32:         end for 33:     end for 34:     Determine the objective function value for each member of the population X. 35:     Update $X_{best}$ 36: end for 37: return the updated population X, with $X_{best}$ as the best result.

7.1.3. Sine Cosine Algorithm

Introduced by Mirjalili in 2016, the Sine Cosine Algorithm (SCA) is a metaheuristic designed to address continuous optimization problems. It takes inspiration from the alternating behavior of sine and cosine functions [48]. The positions of the solutions are then updated using the equations provided below.

$$X_i^{t+1}=X_i^t+r_1·sin\left(r_2\right)·\left|r_3{P}_i^t-X_i^t\right|$$

(20)

$$X_i^{t+1}=X_i^t+r_1·cos\left(r_2\right)·\left|r_3{G}^t-X_i^t\right|$$

(21)

$X_i^t$ represents the position of the i-th solution at iteration t, while $P_i^t$ denotes the position of the solution with the highest fitness for the i-th individual. $G^t$ indicates the best overall solution’s position. The variables $r_1$, $r_2$, and $r_3$ are random numbers, where $r_1$ is a random value, $r_2$ lies within the interval $[0,2\pi ]$, and $r_3$ ranges from $[0,2]$.

These equations enable both exploration and exploitation of the search space by utilizing sine and cosine functions.

The pseudocode can be seen in Algorithm 5.

Algorithm 4 Pendulum Search Algorithm

1: Input: The set of individuals $X=X_1,X_2,\dots ,X_i$   2: Output: The modified population $X^{\prime }=X_1^{\prime },X_2^{\prime },\dots ,X_i^{\prime }$ and the Best   3: Generate a random population X   4: Compute the objective function for each individual in the population X   5: Select the best individual in the population (Best)   6: for iteration (t) do   7:     for solution (i) do   8:         for dimension (j) do   9:            Update $pen{d}_{i,j}^t$ 10:            Update the position of $X_{i,j}^t$ 11:         end for 12:     end for 13:     Assess the objective function for every individual in the population X 14:     Update Best 15: end for 16: return the modified population $X^{\prime }$, with Best as the optimal result.

Algorithm 5 Sine Cosine Algorithm

1: Input: The set of individuals $X=\{X_1,X_2,\dots ,X_i\}$   2: Output: The modified population $X^{\prime }=\{X_1^{\prime },X_2^{\prime },\dots ,X_i^{\prime }\}$ and $X_{best}$   3: Generate a random population X   4: Compute the objective function for each member of the population X   5: Select the best individual in the population ($X_{best}$)   6: $a=2$   7: for iteration (t) do   8:     $r1=a-\left(t·{\displaystyle \frac{a}{\max \mathrm{Iter}}}\right)$   9:     for solution (i) do 10:         for dimension (j) do 11:            $rand=\mathrm{rand}(0,1)$ 12:            $r2=(2·\pi )·\mathrm{rand}(0,1)$ 13:            $rand=\mathrm{rand}(0,1)$ 14:            $r3=2·\mathrm{rand}(0,1)$ 15:            $r4=\mathrm{rand}(0,1)$ 16:            if $r4<0.5$ then 17:                $X_{i,j}^t=X_{i,j}^t+(r1·sin\left(r2\right)·|r3·X_{best,j}-X_{i,j}^t\left|\right)$ 18:            else 19:                $X_{i,j}^t=X_{i,j}^t+(r1·cos\left(r2\right)·|r3·X_{best,j}-X_{i,j}^t\left|\right)$ 20:            end if 21:         end for 22:     end for 23:     Calculate the objective function for each individual in the population X. 24:     Update $X_{best}$ 25: end for 26: return the modified population X, with $X_{best}$ as the optimal result.

7.1.4. Whale Optimization Algorithm

Developed by Mirjalili and Lewis in 2016, the Whale Optimization Algorithm (WOA) is a metaheuristic inspired by the social structure and hunting strategies of whales [49]. It emulates the ’bubble-net feeding’ technique, which is a complex and coordinated approach used by whales to capture their prey.

The WOA employs three primary phases during its search and optimization process:

• Search for Prey: The whale agents explore the search space to find the target (optimal solution). Each agent’s position is updated based on a randomly chosen agent, which may not always be the best identified so far, promoting a wider and more diverse exploration.
• Surrounding the Prey: After identifying the prey (optimal solution), the whales arrange themselves to surround it. This phase marks an intensification step, concentrating the algorithm’s focus on the vicinity of the identified promising solution.
• Bubble-Net Strategy: In the final phase, whales employ the bubble-net strategy to capture the prey, refining the search within the chosen region to optimize the solution further.

The position of the whales is updated using the following equations:

$$\overrightarrow{D}=\left|\overrightarrow{C}·{\overrightarrow{X}}^{*}\left(t\right)-\overrightarrow{X}\left(t\right)\right|,$$

(22)

$$\overrightarrow{X}(t+1)={\overrightarrow{X}}^{*}\left(t\right)-\overrightarrow{A}·\overrightarrow{D}.$$

(23)

Here, ${\overrightarrow{X}}^{*}$ denotes the position of the optimal solution, with $\overrightarrow{A}$ and $\overrightarrow{C}$ serving as coefficient vectors. The term $\overrightarrow{D}$ defines the distance between the whale and the prey.

This approach allows WOA to achieve a balance between exploration and exploitation, making it a flexible method for solving a variety of complex optimization problems.

The pseudocode can be seen in Algorithm 6.

7.1.5. Moth–Flame Optimization

The Moth–Flame Optimization (MFO) algorithm simulates the way moths navigate around artificial lights [50]. In MFO, moth positions serve as candidate solutions and are organized in a matrix, while their fitness values are stored in an array. The optimal positions, known as flames, are updated and saved in a matrix as well.

Each moth’s position is adjusted based on its corresponding flame using the equation below:

$$M_i=S(M_i,F_j),$$

(24)

where S is a spiral function defined by

$$S(M_i,F_j)=D_i·e^{bt}·cos\left(2\pi t\right)+F_j.$$

(25)

$D_i$ represents the separation between the moth $M_i$ and the flame $F_j$, and it is computed using the following expression:

$$D_i=\parallel M_i-F_j\parallel .$$

(26)

Parameter b determines the form of the logarithmic spiral, while t is a randomly chosen number within the interval $[-r,1]$, where r gradually decreases from −1 to −2 as the iterations progress.

To prevent getting stuck in local optima, each moth adjusts its position based on a flame. During each iteration, the list of flames is updated and arranged according to their fitness values. The top-performing moth is aligned with the best flame, and the least-performing moth is matched with the worst flame. The total number of flames is dynamically reduced throughout the iterations using the following approach:

$$\mathrm{flameNo}=\mathrm{round}\left(N-\mathrm{iter}·{\displaystyle \frac{N-1}{\mathrm{MaxIter}}}\right).$$

(27)

N denotes the total number of moths, while iter and MaxIter refer to the current iteration count and the maximum number of iterations, respectively.

The pseudocode can be seen in Algorithm 7.

Algorithm 6 Whale Optimization Algorithm

1: Input: The set of individuals $X=\{X_1,X_2,\dots ,X_i\}$   2: Output: The modified population $X^{\prime }=\{X_1^{\prime },X_2^{\prime },\dots ,X_i^{\prime }\}$ and $X_{best}$   3: Generate a random population X   4: Calculate the objective function for each individual in X   5: Select the best individual in X ($X_{best}$)   6: $b=1$   7: for iteration (t) do   8:     $a=2-\left({\displaystyle \frac{2t}{\max \mathrm{Iter}}}\right)$   9:     for solution (i) do 10:         $p=\mathrm{rand}(0,1)$ 11:         $A=2a\left(\mathrm{rand}\right(0,1)-a)$ 12:         $C=2·\mathrm{rand}(0,1)$ 13:         $l=\mathrm{rand}(-1,1)$ 14:         if $p<0.5$ then 15:            if $\left|A\right|<1$ then 16:                for dimension (j) do 17:                    $D=\left|C·X_{best,j}-X_{i,j}^t\right|$ 18:                    $X_{i,j}^t=X_{best,j}-(A·D)$ 19:                end for 20:            else 21:                $X_{random}=$ a randomly selected individual from the population 22:                for dimension (j) do 23:                    $D=\left|C·X_{random,j}-X_{i,j}^t\right|$ 24:                    $X_{i,j}^t=X_{random,j}-(A·D)$ 25:                end for 26:            end if 27:         else 28:            for dimension (j) do 29:                $D^{\prime }=X_{best,j}-X_{i,j}^t$ 30:                $X_{i,j}^t=(D^{\prime }·e^{b·l}·cos(2·\pi ·l))+X_{best,j}$ 31:            end for 32:         end if 33:     end for 34:     Calculate the objective function for every individual in X. 35:     Update $X_{best}$ 36: end for 37: return the modified population X, with $X_{best}$ as the best result.

Algorithm 7 Moth-Flame Optimization

Input: N (Size of the population), T (Maximum iterations), dim (Number of dimensions). Output: The global optimum (best flame).   1: procedure MFO   2:     Initializing the moth population.   3:     while $t<$ T do   4:         Update the number of flames (${\mathrm{flame}}_{NO}$).   5:         Compute the fitness function M as OM.   6:         if $t==1$ then   7:            OF = sort(${\mathrm{OM}}_1$).   8:            F = sort(${\mathrm{M}}_1$).   9:         else 10:            OF = sort(${\mathrm{OM}}_{t-1}$, ${\mathrm{OM}}_t$). 11:            F = sort(${\mathrm{M}}_{t-1}$, ${\mathrm{M}}_t$). 12:         end if 13:         Identify the best flame. 14:         for $i=1$ to N do 15:            for $j=1$ to dim do 16:                Update r and t. 17:                Compute D. 18:                Modify $M(i,j)$. 19:            end for 20:         end for 21:         Compute the probability value of $M(i,j)$. 22:         Update the new position. 23:         $t=t+1$. 24:     end while 25:     return the global optimum (the best flame). 26: end procedure

7.2. Experimental Setup

For parameter configuration, a population of 30 individuals was used, and 500 iterations were performed, as shown in

Table 5. Parameter table.

Parameter	Value
Number of metaheuristics	6
Independent runs	3
Transfer function	V3
Number of binarization schemes	16
Number of SCP instances	3
Population size	30
Number of iterations	500
WSO Parameters	a = 2
	$f_{\min }$ = 0.07
	$f_{\max }$ = 0.75
	$\tau$ = 4.125
	$a_0$ = 6.25
	$a_1$ = 100
	$a_2$ = 0.0005

.

Considering the number of metaheuristics (6), number of instances (3), and number of versions of the metaheuristics (16) and independent runs (3), we can calculate that the total number of experiments to be conducted is 864.

Concerning the software employed in the experiments, Python 3.10.5 (64-bit) was used on a system running Windows 10. In terms of hardware, the experiments were executed on a computer equipped with an Intel Core i7-8650U processor operating at 2.11 GHz and 16 GB of RAM.

7.3. Summary of Results

For

Table 6. Metaheuristic WSO table for SCP41, SCP51, and SCP61.

Experiment	scp41			scp51			scp61
	Best	Avg.	RPD	Best	Avg.	RPD	Best	Avg.	RPD
V3-STD	438	440	2.098	272	274.667	7.51	141	143.667	2.174
V3-STD_LOG	433	433.333	0.932	267	267	5.534	141	141	2.174
V3-STD_PIECE	433	433	0.932	267	267.333	5.534	141	141	2.174
V3-STD_SINE	433	433	0.932	267	267.333	5.534	141	141	2.174
V3-STD_SINGER	434	434.333	1.166	267	267.333	5.534	141	141.333	2.174
V3-STD_SINU	433	433	0.932	268	268	5.929	141	141	2.174
V3-STD_TENT	433	433	0.932	267	267	5.534	141	141	2.174
V3-STD_CIRCLE	434	435.667	1.166	267	267.667	5.534	147	148	6.522
V3-ELIT	435	435.333	1.399	268	268.667	5.929	142	142	2.899
V3-ELIT_LOG	433	433	0.932	267	267.333	5.534	141	141	2.174
V3-ELIT_PIECE	433	433	0.932	267	267	5.534	141	141	2.174
V3-ELIT_SINE	433	433	0.932	267	267.333	5.534	141	141	2.174
V3-ELIT_SINGER	434	434	1.166	267	267	5.534	141	141	2.174
V3-ELIT_SINU	433	433	0.932	268	268	5.929	141	141	2.174
V3-ELIT_TENT	433	433	0.932	267	267.333	5.534	141	141	2.174
V3-ELIT_CIRCLE	433	433.333	0.932	269	269	6.324	141	142.333	2.174

,

Table 7. Metaheuristic GWO table for SCP41, SCP51, and SCP61.

Experiment	scp41			scp51			scp61
	Best	Avg.	RPD	Best	Avg.	RPD	Best	Avg.	RPD
V3-STD	433	433	0.932	267	267	5.534	141	141	2.174
V3-STD_LOG	434	434	1.166	262	265.667	3.557	141	141	2.174
V3-STD_PIECE	433	433	0.932	267	267	5.534	141	141	2.174
V3-STD_SINE	434	434.333	1.166	267	267.333	5.534	141	141	2.174
V3-STD_SINGER	434	434.667	1.166	268	268	5.929	141	141.333	2.174
V3-STD_SINU	434	434	1.166	267	267.667	5.534	141	141	2.174
V3-STD_TENT	433	433	0.932	267	267	5.534	141	141	2.174
V3-STD_CIRCLE	433	433.333	0.932	267	267.667	5.534	141	141	2.174
V3-ELIT	433	433	0.932	267	267.333	5.534	141	141	2.174
V3-ELIT_LOG	433	433	0.932	267	267.667	5.534	141	141.667	2.174
V3-ELIT_PIECE	433	433	0.932	267	267.333	5.534	141	142.333	2.174
V3-ELIT_SINE	433	434.333	0.932	267	267.333	5.534	141	142	2.174
V3-ELIT_SINGER	434	434	1.166	267	267	5.534	141	142.333	2.174
V3-ELIT_SINU	433	433.667	0.932	267	267.333	5.534	141	141	2.174
V3-ELIT_TENT	433	433	0.932	267	267	5.534	141	142.333	2.174
V3-ELIT_CIRCLE	433	434.333	0.932	267	267.333	5.534	145	145	5.072

,

Table 8. Metaheuristic PSA table for SCP41, SCP51, and SCP61.

Experiment	scp41			scp51			scp61
	Best	Avg.	RPD	Best	Avg.	RPD	Best	Avg.	RPD
V3-STD	433	433	0.932	267	267.667	5.534	144	144.667	4.348
V3-STD_LOG	434	434	1.166	267	267.667	5.534	142	143.667	2.899
V3-STD_PIECE	433	433	0.932	267	267.333	5.534	141	142.333	2.174
V3-STD_SINE	434	434	1.166	267	267.667	5.534	141	143.667	2.174
V3-STD_SINGER	434	434.667	1.166	268	268.667	5.929	142	142	2.899
V3-STD_SINU	434	434.667	1.166	267	268	5.534	142	142	2.899
V3-STD_TENT	433	433	0.932	267	267	5.534	141	142.333	2.174
V3-STD_CIRCLE	438	440.667	2.098	277	279.333	9.486	141	143.667	2.174
V3-ELIT	433	434.333	0.932	267	267	5.534	144	144.667	4.348
V3-ELIT_LOG	433	433	0.932	267	267	5.534	141	142.667	2.174
V3-ELIT_PIECE	433	434.333	0.932	267	267.333	5.534	141	142.333	2.174
V3-ELIT_SINE	433	433	0.932	267	267.333	5.534	145	145	5.072
V3-ELIT_SINGER	434	434	1.166	267	267	5.534	141	142.333	2.174
V3-ELIT_SINU	433	433	0.932	267	267.333	5.534	141	143.667	2.174
V3-ELIT_TENT	433	434.333	0.932	267	267	5.534	138	141.333	0
V3-ELIT_CIRCLE	437	440	1.865	272	274.333	7.51	148	150.333	7.246

,

Table 9. Metaheuristic SCA table for SCP41, SCP51, and SCP61.

Experiment	scp41			scp51			scp61
	Best	Avg.	RPD	Best	Avg.	RPD	Best	Avg.	RPD
V3-STD	433	433.667	0.932	267	267.667	5.534	142	143	2.899
V3-STD_LOG	434	434	1.166	268	268.333	5.929	142	143	2.899
V3-STD_PIECE	433	434.667	0.932	268	268	5.929	141	142.333	2.174
V3-STD_SINE	434	434.333	1.166	268	268.333	5.929	141	143.667	2.174
V3-STD_SINGER	434	435	1.166	268	268.667	5.929	142	142	2.899
V3-STD_SINU	435	435.667	1.399	268	268.667	5.929	142	142	2.899
V3-STD_TENT	434	434.333	1.166	267	267.333	5.534	141	142.667	2.174
V3-STD_CIRCLE	434	434	1.166	267	267.667	5.534	141	144	2.174
V3-ELIT	433	433	0.932	267	267.333	5.534	141	143.667	2.174
V3-ELIT_LOG	433	434.333	0.932	267	267.667	5.534	141	141	2.174
V3-ELIT_PIECE	433	434.333	0.932	267	267.333	5.534	141	143.667	2.174
V3-ELIT_SINE	433	434.333	0.932	267	267	5.534	141	142.333	2.174
V3-ELIT_SINGER	433	433.333	0.932	258	264.667	1.976	141	141	2.174
V3-ELIT_SINU	434	434	1.166	267	267	5.534	141	143.333	2.174
V3-ELIT_TENT	433	433	0.932	267	267	5.534	145	145	5.072
V3-ELIT_CIRCLE	433	433	0.932	267	267.667	5.534	145	145	5.072

,

Table 10. Metaheuristic MFO table for SCP41, SCP51, and SCP61.

Experiment	scp41			scp51			scp61
	Best	Avg.	RPD	Best	Avg.	RPD	Best	Avg.	RPD
V3-STD	433	433	0.932	267	267	5.534	141	142.333	2.174
V3-STD_LOG	433	433	0.932	267	267	5.534	141	141	2.174
V3-STD_PIECE	433	433	0.932	267	267.333	5.534	141	141	2.174
V3-STD_SINE	433	433	0.932	267	267	5.534	141	141	2.174
V3-STD_SINGER	434	434	1.166	267	267	5.534	141	141	2.174
V3-STD_SINU	433	433.667	0.932	267	267.333	5.534	141	141	2.174
V3-STD_TENT	433	433	0.932	267	267	5.534	141	141	2.174
V3-STD_CIRCLE	434	436.333	1.166	267	267	5.534	141	141	2.174
V3-ELIT	433	433	0.932	267	267.333	5.534	141	141	2.174
V3-ELIT_LOG	433	433	0.932	267	267	5.534	141	141	2.174
V3-ELIT_PIECE	433	433	0.932	267	267.333	5.534	141	141	2.174
V3-ELIT_SINE	433	433	0.932	267	267.333	5.534	141	141	2.174
V3-ELIT_SINGER	434	434	1.166	267	267	5.534	141	141	2.174
V3-ELIT_SINU	433	433	0.932	267	267	5.534	141	141	2.174
V3-ELIT_TENT	433	433	0.932	267	267.667	5.534	141	141	2.174
V3-ELIT_CIRCLE	434	435.333	1.166	267	268.667	5.534	141	142.333	2.174

and

Table 11. Metaheuristic WOA table for SCP41, SCP51, and SCP61.

Experiment	scp41			scp51			scp61
	Best	Avg.	RPD	Best	Avg.	RPD	Best	Avg.	RPD
V3-STD	433	433	0.932	267	267.333	5.534	141	143.333	2.174
V3-STD_LOG	433	433.333	0.932	267	267.667	5.534	141	143.333	2.174
V3-STD_PIECE	433	433	0.932	257	264.667	1.581	144	144.667	4.348
V3-STD_SINE	433	434.333	0.932	267	267.333	5.534	141	143.333	2.174
V3-STD_SINGER	434	434.333	1.166	267	267.333	5.534	141	142.333	2.174
V3-STD_SINU	433	433.667	0.932	267	267.333	5.534	141	142	2.174
V3-STD_TENT	433	435.667	0.932	267	267	5.534	143	144	3.623
V3-STD_CIRCLE	437	439.333	1.865	269	270.333	6.324	141	146.667	2.174
V3-ELIT	433	434.333	0.932	267	267.333	5.534	141	141.667	2.174
V3-ELIT_LOG	433	434.333	0.932	267	269	5.534	141	142	2.174
V3-ELIT_PIECE	433	433	0.932	267	267.333	5.534	141	142.333	2.174
V3-ELIT_SINE	433	433	0.932	267	267	5.534	144	144.333	4.348
V3-ELIT_SINGER	433	433	0.932	267	268	5.534	141	141	2.174
V3-ELIT_SINU	433	433	0.932	267	267.333	5.534	141	141	2.174
V3-ELIT_TENT	433	433	0.932	267	267	5.534	141	143.333	2.174
V3-ELIT_CIRCLE	439	441.667	2.331	268	273	5.929	141	145.333	2.174

, we have a summary of the experiments, where the first column shows the variation of all experiments. In the first row, we have the SCP instance that was solved for the experiments. For each SCP instance, we have Best, Avg, and RPD, where (1) corresponds to the best result obtained, (2) corresponds to the average of the best fitness of all runs, and (3) corresponds to the “Relative Percentage Deviation”, which measures the percentage deviation of the obtained solution from the best-known solution, thus evaluating the quality of the algorithm.

$$\mathrm{RPD}=100·\left({\displaystyle \frac{\mathrm{Opt}-\mathrm{Best}}{\mathrm{Opt}}}\right)$$

(28)

Here, Opt represents the optimal value for the given instance, and Best refers to the highest-quality solution obtained from the experiment.

The results presented in Table 6 allow for a detailed comparison of WSO’s performance in relation to five other metaheuristics—GWO, PSA, SCA, MFO, and WOA—across the three instances of the “Set Covering” problem (SCP41, SCP51, SCP61). Figure 7, Figure 8, Figure 9, Figure 10, Figure 11, Figure 12, Figure 13, Figure 14, Figure 15, Figure 16, Figure 17 and Figure 18 show the convergence tables of the experiments.

For the SCP41 instance, WSO stands out by achieving a Best value of 433, matched by GWO and slightly surpassed by PSA in some configurations. However, it is important to note that WSO’s performance varies across its different configurations. For example, while V3-STD_PIECE shows an RPD of 0.932, V3-ELIT presents an RPD of 1.399. Compared to other algorithms, WSO demonstrates competitive performance in some configurations, but it is not uniformly superior. For instance, SCA presents an RPD of 0.932 in its best configuration, matching WSO’s best result, while MFO and WOA generally show higher RPDs.

In the SCP51 instance, WSO maintains its competitiveness by achieving an RPD as low as 3.557 in the V3-STD_LOG configuration. This result is particularly noteworthy when compared to PSA and MFO, which present higher RPD values, indicating greater dispersion in their results. Although GWO achieves a competitive Best value, a closer examination suggests that it may exhibit greater stability than WSO. In Table 7 (GWO, scp51), only two values differ from 5.534, while in Table 6 (WSO, scp51), five RPD values vary from 5.534. This indicates that GWO could be the more stable method, with MFO showing nearly similar stability.

Finally, in SCP61, WSO continues to demonstrate its effectiveness by achieving a minimum RPD of 2.174 in several configurations, including V3-ELIT_CIRCLE and V3-STD_PIECE. Compared to WOA and SCA, which present higher RPDs, WSO demonstrates a superior ability to maintain consistent and near-optimal results. Although GWO also shows strong performance in this instance, WSO manages to match or surpass it in terms of stability and average consistency.

In conclusion, WSO positions itself as one of the most robust and consistent metaheuristics in this set of experiments, achieving an effective balance between exploration and exploitation. Compared to GWO, PSA, SCA, MFO, and WOA, WSO stands out for its ability to maintain low RPD values and obtain consistent average results, making it especially suitable for efficiently and reliably solving instances of the “Set Covering” problem.

7.4. Statistical Tests

Prior to performing the statistical analysis, it was crucial to select the most suitable type of test, deciding between parametric and non-parametric options. In this study, a non-parametric test was chosen because the data originated from machines and did not exhibit the normal distribution typical of natural processes. Given the independence of the samples, the Wilcoxon–Mann–Whitney test was employed for the analysis. This test helps identify significant differences between algorithms, offering detailed insights into their comparative performance.

$$H_0:M_{hA}\ge M_{hB}$$

(29)

$$H_1:M_{hA}<M_{hB}$$

(30)

To apply the chosen statistical test, we used the corresponding function from the Python scipy.stats.mannwhitneyu. library [51] (accessed on 6 October 2024). We set the “alternative” parameter to “less” in that function. Our analysis focused on comparing two different metaheuristics. A resulting p-value less than 0.05 would indicate that the sample from the first metaheuristic (MhA) is statistically smaller than that of the second (MhB).

The statistical analysis of the metaheuristics on the SCP41, SCP51, and SCP61 instances was performed using the Wilcoxon–Mann–Whitney test to compare WSO with other metaheuristics: GWO, PSA, SCA, MFO, and WOA. The detailed results of the statistical test for each instance are presented below and are shown in

Table 12. Average p-value of WSO compared to others experiments for SCP41.

	STD	STD_LOG	STD_PIECE	STD_SINE	STD_SINGER	STD_SINU	STD_TENT	STD_CIRCLE	ELIT	ELIT_LOG	ELIT_PIECE	ELIT_SINE	ELIT_SINGER	ELIT_SINU	ELIT_TENT	ELIT_CIRCLE
STD	X	0.988	0.991	0.991	0.988	0.991	0.991	0.964	0.988	0.991	0.991	0.991	0.991	0.991	0.991	0.988
STD_LOG	0.036	X	0.909	0.909	0.079	0.909	0.909	0.079	0.036	0.909	0.909	0.909	0.094	0.909	0.909	0.604
STD_PIECE	0.03	0.252	X	1	0.03	1	1	0.03	0.03	1	1	1	0.023	1	1	0.252
STD_SINE	0.03	0.252	1	X	0.03	1	1	0.03	0.03	1	1	1	0.023	1	1	0.252
STD_SINGER	0.036	0.97	0.991	0.991	X	0.991	0.991	0.5	0.079	0.991	0.991	0.991	0.909	0.991	0.991	0.97
STD_SINU	0.03	0.252	1	1	0.03	X	1	0.03	0.03	1	1	1	0.023	1	1	0.252
STD_TENT	0.03	0.252	1	1	0.03	1	X	0.03	0.03	1	1	1	0.023	1	1	0.252
STD_CIRCLE	0.089	0.97	0.991	0.991	0.697	0.991	0.991	X	0.327	0.991	0.991	0.991	0.909	0.991	0.991	0.97
ELIT	0.036	0.988	0.991	0.991	0.97	0.991	0.991	0.816	X	0.991	0.991	0.991	0.991	0.991	0.991	0.988
ELIT_LOG	0.03	0.252	1	1	0.03	1	1	0.03	0.03	X	1	1	0.023	1	1	0.252
ELIT_PIECE	0.03	0.252	1	1	0.03	1	1	0.03	0.03	1	X	1	0.023	1	1	0.252
ELIT_SINE	0.03	0.252	1	1	0.03	1	1	0.03	0.03	1	1	X	0.023	1	1	0.252
ELIT_SINGER	0.03	0.967	0.994	0.994	0.252	0.994	0.994	0.252	0.03	0.994	0.994	0.994	X	0.994	0.994	0.967
ELIT_SINU	0.03	0.252	1	1	0.03	1	1	0.03	0.03	1	1	1	0.023	X	1	0.252
ELIT_TENT	0.03	0.252	1	1	0.03	1	1	0.03	0.03	1	1	1	0.023	1	X	0.252
ELIT_CIRCLE	0.036	0.604	0.909	0.909	0.079	0.909	0.909	0.079	0.036	0.909	0.909	0.909	0.094	0.909	0.909	X

,

Table 13. Average p-value of WSO compared to others experiments for SCP51.

	STD	STD_LOG	STD_PIECE	STD_SINE	STD_SINGER	STD_SINU	STD_TENT	STD_CIRCLE	ELIT	ELIT_LOG	ELIT_PIECE	ELIT_SINE	ELIT_SINGER	ELIT_SINU	ELIT_TENT	ELIT_CIRCLE
STD	X	0.991	0.988	0.988	0.988	0.991	0.991	0.988	0.988	0.988	0.991	0.988	0.991	0.991	0.988	0.991
STD_LOG	0.03	X	0.252	0.252	0.252	0.023	1	0.094	0.03	0.252	1	0.252	1	0.023	0.252	0.023
STD_PIECE	0.036	0.909	X	0.604	0.604	0.094	0.909	0.31	0.055	0.604	0.909	0.604	0.909	0.094	0.604	0.03
STD_SINE	0.036	0.909	0.604	X	0.604	0.094	0.909	0.31	0.055	0.604	0.909	0.604	0.909	0.094	0.604	0.03
STD_SINGER	0.036	0.909	0.604	0.604	X	0.094	0.909	0.31	0.055	0.604	0.909	0.604	0.909	0.094	0.604	0.03
STD_SINU	0.03	0.994	0.967	0.967	0.967	X	0.994	0.909	0.094	0.967	0.994	0.967	0.994	1	0.967	0.023
STD_TENT	0.03	1	0.252	0.252	0.252	0.023	X	0.094	0.03	0.252	1	0.252	1	0.023	0.252	0.023
STD_CIRCLE	0.036	0.967	0.84	0.84	0.84	0.252	0.967	X	0.079	0.84	0.967	0.84	0.967	0.252	0.84	0.03
ELIT	0.036	0.991	0.98	0.98	0.98	0.967	0.991	0.97	X	0.98	0.991	0.98	0.991	0.967	0.98	0.252
ELIT_LOG	0.036	0.909	0.604	0.604	0.604	0.094	0.909	0.31	0.055	X	0.909	0.604	0.909	0.094	0.604	0.03
ELIT_PIECE	0.03	1	0.252	0.252	0.252	0.023	1	0.094	0.03	0.252	X	0.252	1	0.023	0.252	0.023
ELIT_SINE	0.036	0.909	0.604	0.604	0.604	0.094	0.909	0.31	0.055	0.604	0.909	X	0.909	0.094	0.604	0.03
ELIT_SINGER	0.03	1	0.252	0.252	0.252	0.023	1	0.094	0.03	0.252	1	0.252	X	0.023	0.252	0.023
ELIT_SINU	0.03	0.994	0.967	0.967	0.967	1	0.994	0.909	0.094	0.967	0.994	0.967	0.994	X	0.967	0.023
ELIT_TENT	0.036	0.909	0.604	0.604	0.604	0.094	0.909	0.31	0.055	0.604	0.909	0.604	0.909	0.094	X	0.03
ELIT_CIRCLE	0.03	0.994	0.991	0.991	0.991	0.994	0.994	0.991	0.909	0.991	0.994	0.991	0.994	0.994	0.991	X

and

Table 14. Average p-value of WSO compared to others experiments for SCP61.

	STD	STD_LOG	STD_PIECE	STD_SINE	STD_SINGER	STD_SINU	STD_TENT	STD_CIRCLE	ELIT	ELIT_LOG	ELIT_PIECE	ELIT_SINE	ELIT_SINGER	ELIT_SINU	ELIT_TENT	ELIT_CIRCLE
STD	X	0.965	0.965	0.965	0.918	0.965	0.965	0.038	0.823	0.965	0.965	0.965	0.965	0.965	0.965	0.823
STD_LOG	0.098	X	1	1	0.252	1	1	0.03	0.023	1	1	1	1	1	1	0.252
STD_PIECE	0.098	1	X	1	0.252	1	1	0.03	0.023	1	1	1	1	1	1	0.252
STD_SINE	0.098	1	1	X	0.252	1	1	0.03	0.023	1	1	1	1	1	1	0.252
STD_SINGER	0.177	0.909	0.909	0.909	X	0.909	0.909	0.036	0.094	0.909	0.909	0.909	0.909	0.909	0.909	0.5
STD_SINU	0.098	1	1	1	0.252	X	1	0.03	0.023	1	1	1	1	1	1	0.252
STD_TENT	0.098	1	1	1	0.252	1	X	0.03	0.023	1	1	1	1	1	1	0.252
STD_CIRCLE	0.987	0.991	0.991	0.991	0.988	0.991	0.991	X	0.991	0.991	0.991	0.991	0.991	0.991	0.991	0.988
ELIT	0.321	0.994	0.994	0.994	0.967	0.994	0.994	0.03	X	0.994	0.994	0.994	0.994	0.994	0.994	0.827
ELIT_LOG	0.098	1	1	1	0.252	1	1	0.03	0.023	X	1	1	1	1	1	0.252
ELIT_PIECE	0.098	1	1	1	0.252	1	1	0.03	0.023	1	X	1	1	1	1	0.252
ELIT_SINE	0.098	1	1	1	0.252	1	1	0.03	0.023	1	1	X	1	1	1	0.252
ELIT_SINGER	0.098	1	1	1	0.252	1	1	0.03	0.023	1	1	1	X	1	1	0.252
ELIT_SINU	0.098	1	1	1	0.252	1	1	0.03	0.023	1	1	1	1	X	1	0.252
ELIT_TENT	0.098	1	1	1	0.252	1	1	0.03	0.023	1	1	1	1	1	X	0.252
ELIT_CIRCLE	0.321	0.909	0.909	0.909	0.697	0.909	0.909	0.036	0.319	0.909	0.909	0.909	0.909	0.909	0.909	X

.

• Instance SCP41
  For the SCP41 instance, the statistical test revealed that WSO configurations with chaotic maps (STD and ELITE) had p-values less than 0.05 compared to several other configurations. Specifically, WSO with STD and ELITE in chaotic configurations showed statistically significant differences compared to STD and ELITE configurations from other experiments, as well as against STD-SINGER, STD-CIRCLE, ELIT, and ELIT-SINGER. These p-values indicate that WSO performed significantly better in these specific configurations compared to the other evaluated metaheuristics.
• Instance SCP51
  In the SCP51 instance, the statistical test also showed that WSO with chaotic maps (STD and ELITE) had p-values less than 0.05 compared to STD and ELITE configurations, as well as compared to STD-SINU, ELIT, ELITE-SINU, and ELITE-CIRCLE. This finding suggests that WSO performed statistically superior in these configurations compared to the other metaheuristics in this instance, highlighting greater effectiveness compared to the evaluated alternatives.
• Instance SCP61
  Finally, in the SCP61 instance, WSO with chaotic maps (STD and ELITE) obtained p-values less than 0.05 compared to STD-CIRCLE and ELITE. These results demonstrate that WSO exhibited statistically superior performance in these specific configurations compared to other metaheuristics evaluated for SCP61.

In summary, the statistical analysis confirms that WSO, particularly with chaotic map configurations, shows superior performance compared to other metaheuristics across the three “Set Covering” problem instances. The p-values less than 0.05 in multiple comparisons suggest that WSO has statistically significant performance compared to the other evaluated techniques. These results reinforce the robustness and effectiveness of WSO in solving “Set Covering” problem instances.

7.5. Exploration vs. Exploitation

Within metaheuristics, a key challenge is achieving the right balance between exploration and exploitation throughout the search process. Exploration enables the algorithm to probe new regions of the search space, whereas exploitation hones in on enhancing solutions in areas already deemed promising. If these two elements are not properly balanced, the algorithm may either become stuck in local optima (excessive exploitation) or struggle to converge within a feasible timeframe (excessive exploration).

During the experimentation with the metaheuristic without the application of chaotic maps, it was observed that the algorithm maintained a reasonable balance between exploration and exploitation. As shown in Figure 19 and Figure 20, at the beginning of the execution, exploration is predominantly high, which is expected and desirable as the algorithm attempts to cover a large portion of the search space to avoid falling into early suboptimal solutions. As the iterations progress, exploitation starts to gain prominence, allowing for the refinement of the solutions found.

When introducing chaotic maps into the metaheuristic, a noticeable change in the dynamics between exploration and exploitation was observed. Chaotic maps, known for their ability to introduce variability and avoid repetitive cycles, significantly altered the behavior of the algorithm, favoring a faster convergence. As illustrated in Figure 21 and Figure 22, the algorithm exhibited an accelerated decrease in the exploration phase, with an almost immediate increase in exploitation.

While rapid convergence may seem advantageous, it is crucial to consider that excessive exploitation from early stages can lead the algorithm to premature convergence, limiting the diversity of solutions explored and potentially trapping the process in local optima. However, in this particular case, the application of chaotic maps proved beneficial in scenarios where the speed of convergence is prioritized over the diversity of solutions.

8. Conclusions

This work presents a comprehensive evaluation of the White Shark Optimizer (WSO) for solving the Set Covering Problem (SCP) in comparison with several metaheuristics: Grey Wolf Optimizer (GWO), Pendulum Search Algorithm (PSA), Sine Cosine Algorithm (SCA), Whale Optimization Algorithm (WOA), and Moth–Flame Optimization (MFO). The study focuses on adapting WSO to binary optimization by incorporating population and velocity binarization techniques, along with chaotic maps to enhance the algorithm’s exploration and convergence.

The results show that WSO demonstrates competitive performance in the SCP41, SCP51, and SCP61 instances, though its superiority is not uniform across all configurations. For SCP41, while WSO achieves a Best value of 433 in some configurations, it is matched by GWO and slightly surpassed by PSA. In SCP51, WSO maintains its competitiveness with low RPD values but does not consistently outperform GWO in stability. In SCP61, WSO achieves minimum RPD values in several configurations, highlighting its effectiveness in certain scenarios compared to WOA and SCA.

Despite the variability in performance, WSO’s use of chaotic maps generally improves its effectiveness, as confirmed by statistical analysis. The Wilcoxon–Mann–Whitney tests indicate that certain WSO configurations with chaotic maps significantly differ from other methods, emphasizing their potential for solving binary optimization problems.

In summary, this work validates the use of WSO with advanced binarization techniques and chaotic maps for combinatorial optimization. Although it may not be uniformly superior across all instances, its ability to achieve near-optimal solutions and maintain consistency in select configurations underscores its applicability. This study contributes empirical evidence to the growing field of metaheuristics, highlighting WSO’s strengths and identifying areas for further research in binary optimization.