A Modified Quantum-Inspired Genetic Algorithm Using Lengthening Chromosome Size and an Adaptive Look-Up Table to Avoid Local Optima

Abstract

The quantum-inspired genetic algorithm (QGA), which combines quantum mechanics concepts and GA to enhance search capability, has been popular and provides an efficient search mechanism. This paper proposes a modified QGA, called dynamic QGA (DQGA). The proposed algorithm utilizes a lengthening chromosome strategy for a balanced and smooth transition between exploration and exploitation phases to avoid local optima and premature convergence. Apart from that, a novel adaptive look-up table for rotation gates is presented to boost the algorithm’s optimization abilities. To evaluate the effectiveness of these ideas, DQGA is tested by various mathematical benchmark functions as well as real-world constrained engineering problems against several well-known and state-of-the-art algorithms. The obtained results indicate the merits of the proposed algorithm and its superiority for solving multimodal benchmark functions and real-world constrained engineering problems.

1. Introduction

Metaheuristic optimization algorithms have been proposed to tackle complex, high-dimensional problems without comprehensive knowledge of the problem’s nature and their search spaces’ derivative information, which is essential for finding critical points of the search space in classical optimization methods. Metaheuristics have the ability to treat optimization problems as black boxes. So, the input, output, and a proper fitness function of an optimization problem suffice to solve the problem. As a result, metaheuristic algorithms are problem-independent, meaning they can be applied to a wide variety of problems with subtle modifications. Metaheuristic algorithms provide acceptable results in a timely manner for many real-world optimization problems, but their computational cost is excessively high using conventional algorithms. Some examples of the applications are image and signal processing [1], engineering and structural design [2], routing problems [3], feature selection [4], stock market portfolio optimization [5], RNA prediction [6], and resource management problems [7].

Han and Kim proposed the prominent genetic quantum algorithm (GQA) [8] and the quantum-inspired evolutionary algorithm [9] for combinatorial optimization problems using qubit representation and quantum rotation gates instead of the ‘crossover’ operator, in the genetic algorithm (GA). The probabilistic representation of qubits used in quantum-inspired metaheuristic optimization algorithms instead of bits expands the diversity of individuals in the algorithm’s population, so it helps the optimization algorithm avoid premature convergence and getting stuck in local optima. Recently, a relatively large number of quantum-inspired metaheuristics have been proposed to solve a vast range of real-world optimization problems. Some recent examples are as follows. In [10,11,12], quantum-inspired metaheuristics are applied to image processing problems, and structural design applications are presented in [13,14,15,16]. In  [17,18,19,20,21,22], quantum-inspired metaheuristics are utilized for job-scheduling problems, and some examples of network applications of quantum-inspired metaheuristics are found in [23,24,25,26]. In [27], a quantum-inspired metaheuristic is used for quantum circuit synthesis. Other applications are feature selection [28,29], fuzzy c-means clustering [30], stock market portfolio optimization [31], flight control optimization [32,33], antenna positioning problems [34], airport gate allocation [35], and multi-objective optimization [36]. A comprehensive review of quantum-inspired metaheuristics and their variants is presented in [37,38]. Considering the diverse range of applications of quantum-inspired metaheuristics, it is clear that this scope has gained much attention, and this approach can solve real-world optimization problems effectively.

Metaheuristic optimization algorithms such as GA [39] have been widely used in solving some important optimization problems in, e.g., the field of quantum information and computation, such as in distributed quantum computing [40,41,42,43], in the design and the optimization of quantum circuits [44,45,46], and in finding stabilizers of a given sub-space [47], etc.

The main challenge in all metaheuristic algorithms is achieving a properly balanced transition between the exploration and exploitation phases. This paper proposed DQGA to establish a smooth transition between the exploration and exploitation phases. The principal objective of the proposed algorithms is to boost global search ability without deteriorating the local search.

DQGA enhances the search power of QGA with two contributions:

• Lengthening Chromosomes Size: DQGA increases the size of chromosomes throughout the algorithm run. This strategy leads to increasing precision levels for the duration of generations. Low precision levels for early generations cause higher global focus and less attention to detail, favoring diversification. As opposed to that, higher precision in the last generations promotes intensification. This manner guarantees a smooth shift from the exploration phase to the exploitation phase. It should be noted that the concept of utilizing variable chromosome size was introduced in [48] as an attempt to find a suitable chromosome size for reducing computational time. Also, in [49], the authors used different chromosome sizes to cover diverse coarse-grained and fine-grained parts of a design in topological order. However, in this paper, we utilized incrementing chromosome size for different purposes, namely local optima and premature convergence avoidance.
• Adaptive Rotation Steps: Unlike the look-up table of the original GQA, which consists of fixed values for all generations and ignores the current state of the qubits, the proposed DQGA uses an adaptive look-up table which helps the algorithm to search more properly and improves the exploration–exploitation transition.

The rest of this paper is structured as follows. Section 2 presents the quantum computing basics and an overview of GQA. The proposed DQGA algorithm is described in Section 3. The results and the comparisons of the performance of the proposed algorithm on benchmark functions and real-world engineering optimization problems are given in Section 4, as well as the comparison of the results with well-known metaheuristic algorithms. Finally, Section 5 concludes this work and points out future studies.

2. Fundamentals

2.1. Quantum Computing Basics

Like bits in classical processing are the basic units of information, quantum bits, or qubits, are the units of information in quantum computing. The mathematical representation of a qubit is a unit vector in a two-dimensional Hilbert space for which the basis vectors are denoted by the symbols $\left|0\right.〉$ and $\left|1\right.〉$. Unlike classical bits, qubits can be in the superposition of $\left|0\right.〉$ and $\left|1\right.〉$ like $\alpha \left|0\right.〉+\beta \left|1\right.〉$, where $\alpha$ and $\beta$ are complex numbers such that ${|\alpha }^2|+|{\beta }^2|=1$.

If the qubit is measured in the computational, i.e., {$\left|0\right.〉$, $\left|1\right.〉$} basis, the classic outcome of 0 is observed with the probability of ${\left|\alpha \right|}^2$ and the classic outcome of 1 is observed with the probability of ${\left|\beta \right|}^2$. If 0 is observed, the state of the qubit after the measurement collapses to $\left|0\right.〉$, otherwise, it collapses to $\left|1\right.〉$ [50].

A register with m qubits is defined as:

$$\left[\begin{array}{cccc}{\alpha }_1& {\alpha }_2& \cdots & {\alpha }_m\\ {\beta }_1& {\beta }_2& \cdots & {\beta }_m\end{array}\right],\forall i\in \{1,\dots ,m\},{\left|{\alpha }_i\right|}^2+{\left|{\beta }_i\right|}^2=1.$$

(1)

An m-qubit register is able to represent $2^m$ states simultaneously. The probability of collapsing into each of these $2^m$ states after measurement is the multiplication of the corresponding probability amplitudes squared [40]. For example, consider a system comprised of three qubits as follows:

$$\left[\begin{array}{ccc}\frac{\sqrt{2}}{2}& \frac{\sqrt{3}}{2}& \frac{\sqrt{2}}{2}\\ \frac{\sqrt{2}}{2}& \frac{1}{2}& -\frac{\sqrt{2}}{2}\end{array}\right].$$

(2)

The state of the system can be described as:

$$\frac{\sqrt{3}}{4}\left|000\right.〉+\frac{-\sqrt{3}}{4}\left|001\right.〉+\frac{1}{4}\left|010\right.〉+\frac{-1}{4}\left|011\right.〉+\frac{\sqrt{3}}{4}\left|100\right.〉+\frac{-\sqrt{3}}{4}\left|101\right.〉+\frac{1}{4}\left|110\right.〉+\frac{-1}{4}\left|111\right.〉,$$

(3)

which means the probabilities for the system to represent the states $\left|000\right.〉,\left|001\right.〉,\left|010\right.〉,\left|011\right.〉,\left|100\right.〉,\left|101\right.〉,\left|110\right.〉$, and $\left|111\right.〉$ are $\frac{3}{16},\frac{3}{16},\frac{1}{16},\frac{1}{16},\frac{3}{16},\frac{3}{16},\frac{1}{16}$, and $\frac{1}{16}$, respectively.

Manipulation of qubits is performed through quantum gates. A quantum gate is a linear transformation and is reversible. A unitary matrix U is used to define a quantum gate. A complex square matrix U is unitary if its conjugate transpose $U^{†}$ and its inverse $U^{-1}$ are the same. So for any unitary matrix U Equation (4) holds.

$$U{U}^{†}=U^{†}U=I.$$

(4)

2.2. GQA

The canonical QGA called GQA is presented by Han and Kim [8]. GQA is similar to its conventional counterpart GA in terms of being population-based and evolving a set of generations. Still, it differs from GA because it uses quantum rotation gates instead of the classical crossover operator. The probabilistic nature of qubit representation made the mutation operator expendable, so there is no mutation operator in GQA.

Just like its ancestor, QGA uses a population of individuals to become evolved through the generations, but unlike GA, the individuals consist of qubits instead of bits in GQA. The population at generation t is defined as:

$$Q\left(t\right)=\{q_1^t{q}_2^t\dots ,q_n^t\},$$

(5)

where n is the population size and $q_j^t$ is a qubit chromosome and is defined by Equation (6),

$$q_j^t=\left[\begin{array}{cccc}{\alpha }_1^t& {\alpha }_2^t& \cdots & {\alpha }_m^t\\ {\beta }_1^t& {\beta }_2^t& \cdots & {\beta }_m^t\end{array}\right],$$

(6)

where m is the chromosome size and $j=1,2,...,n$. Updating qubits through the quantum rotation gate is visually illustrated in Figure 1 and is mathematically presented in Equation (7). To give an equal chance for all qubits to be measured into $\left|0\right.〉$ and $\left|1\right.〉$, they are initialized by $\frac{1}{\sqrt{2}}$.

$$\left[\begin{array}{c}{\alpha }_i^{\prime }\\ {\beta }_i^{\prime }\end{array}\right]=\left[\begin{array}{cc}cos\Delta {\theta }_i& -sin\Delta {\theta }_i\\ sin\Delta {\theta }_i& cos\Delta {\theta }_i\end{array}\right]\left[\begin{array}{c}{\alpha }_i\\ {\beta }_i,\end{array}\right]$$

(7)

where $\Delta {\theta }_i$ is the rotation angle and ${\alpha }_i^{\prime }$ and ${\beta }_i^{\prime }$ are the probability amplitudes of the qubit after being updated. In each generation, the quantum rotation gates push the qubit population to be more likely to collapse into the best individual state.

It is worth mentioning that quantum gates are susceptible to noise that can affect the measurements for real quantum computer implementation of quantum-inspired metaheuristic optimization algorithms. However, because of the stochastic nature of metaheuristics, it is not necessarily a drawback. In fact, the noise in quantum gates can play the role of the mutation operator in conventional GA, as it randomly changes the state of qubits with a small probability, leading to further diversity in the population.

3. DQGA

In this section, DQGA is presented. The algorithm uses a lengthening chromosome size strategy and an adaptive look-up table to determine quantum rotation gates. As the algorithm works on different levels (i.e., different chromosome sizes), the whole number of generations should be appropriately distributed among the levels. So, we introduced a generation distribution scheme to maximize the algorithm’s performance in the given number of generations. The pseudo-code of DQGA is given in Algorithm 1, and  Figure 2 presents the flowchart of the algorithm. We will explain these concepts in detail in the following subsections.

3.1. Lengthening Chromosome Size Strategy

The lengthening chromosome size strategy enables the chromosomes of the algorithm to grow longer as the generations pass. This algorithm behavior guarantees a balanced transition between the exploration and exploitation phases. The algorithm starts with short-length chromosomes, which yield answers with low precision. At each level of the precision, the previous level best individual becomes the current level best individual and leads the population to previously found promising areas of the search space.

An example of this procedure is depicted in Figure 3. It shows an instance of a four-level run of the algorithm. The chromosome size on levels 1 to 4 are 4, 8, 12, and 16, respectively. At the end of the first level with chromosomes of size four, the best individual is ‘0110’, which is six by conversion to base 10, and 0.4 by normalization. The first level passes its best individual ‘0110’ to the second level, which is of length 8. So, the first 4 bits of the best individual of the second level are initialized by ‘0110’. Level 2 results in ‘01111001’ as the best individual after some number of iterations. Then it passes it to level 3. Finally, level 4 inherits its first iteration’s best individual from level 3, which is ‘100100011101’ in this example.

Please note that, although the most significant bits of each level’s best individual are initialized by the preceding level’s best individual, these bits will not necessarily remain the same throughout the evolution of that level. A rough analogy is that when someone tries to find a destination on a map, he first takes an overview of the map and then gradually increases his focus on the areas that seem to be the target for details. Figure 4 shows the exponential growth of solution precision by increasing the chromosome size.

Algorithm 1 The pseudo-code of DQGA

1: initialize DQGA parameters ($min\_length,max\_length,interval$)   2: $current\_level\leftarrow 1$   3: Calculate $max\_level$ using Equation (8)   4: $chromosom{e}_{\_}size\leftarrow min\_length$   5: $t\leftarrow 0$   6: Initialize quantum population $Q\left(t\right)$   7: Make binary population $P\left(t\right)$ by applying measurement on $Q\left(t\right)$   8: Evaluate fitness and find the best individual   9: Calculate $level\_iterations\_number$ using Equation (16) 10: while $(current\_level\le max\_level)$ do 11:     while $(t<level\_iterations\_number)$ do 12:         $t\leftarrow t+1$ 13:         Calculate $Q\left(t\right)$ using rotation gates on $Q(t-1)$ from Table 1 14:         Make binary population $P\left(t\right)$ by applying measurement on $Q\left(t\right)$ 15:         Evaluate fitness and find the best individual 16:     end while 17:     $t\leftarrow 0$ 18:     $current\_level\leftarrow current\_level+1$ 19:     $best\_individual(current\_level)\leftarrow best\_individual(current\_level-1)$ 20:     $chromosome\_size\leftarrow chromosome\_size+interval$ 21:     Initialize quantum population $Q\left(t\right)$ 22: end while 23: return $best\_individual(max\_level),best\_fitness\_value$

Table 1. Look-up table for DQGA.

${\mathit{x}}_{\mathit{i}}$	${\mathit{b}}_{\mathit{i}}$	$\mathit{f}\left(\mathit{x}\right)\ge \mathit{f}\left(\mathit{b}\right)$	$\mathit{\Delta }{\mathit{\theta }}_{\mathit{i}}$
0	0	false	Equation (15)
0	0	true	Equation (15)
0	1	false	Equation (10)
0	1	true	Equation (12)
1	0	false	Equation (11)
1	0	true	Equation (13)
1	1	false	Equation (14)
1	1	true	Equation (14)

Table 1. Look-up table for DQGA.

${\mathit{x}}_{\mathit{i}}$	${\mathit{b}}_{\mathit{i}}$	$\mathit{f}\left(\mathit{x}\right)\ge \mathit{f}\left(\mathit{b}\right)$	$\mathit{\Delta }{\mathit{\theta }}_{\mathit{i}}$
0	0	false	Equation (15)
0	0	true	Equation (15)
0	1	false	Equation (10)
0	1	true	Equation (12)
1	0	false	Equation (11)
1	0	true	Equation (13)
1	1	false	Equation (14)
1	1	true	Equation (14)

The main advantage of the lengthening chromosome strategy is local optima avoidance. At the early levels of the algorithm, we do not have many points on the search space, as the small number of bits cannot represent many numbers. Because of this, the chance of the local optima being found in the first levels is minuscule. This fact is also true for the global optimum, but we do not need to find the global optimum solution at the early stages. The algorithm can take its time searching all over the search space even with low precision and gradually elevate the focus at the endmost levels to exploit for the global best solution. We can be more confident that the algorithm would not become trapped in the local optima in this way.

The algorithm starts with a level of precision with chromosomes of length $min\_length$ for each dimension and increases the length of the chromosomes by $interval$ genomes until the chromosomes length reaches $max\_length$. So, the number of levels can be calculated by Equation (8).

$$max\_level=⌊\frac{max\_length-min\_length}{interval}⌋+1.$$

(8)

3.2. Look-Up Table with Adaptive Rotation Steps

In DQGA, we introduced an adaptive look-up table to boost searchability. For the sake of simplicity and to gain better control of the quantum search space, all states are limited to reside between 0 to 90 degrees. Qubits with states closer to 90 degrees are more likely to collapse to $\left|1\right.〉$ after measurement, while the probability for those closer to 0 degrees to be measured into $\left|0\right.〉$ is more. We try to push the qubits to states that seem to yield better solutions during the algorithm. At early iterations of each level of the algorithm, the rotation steps toward the more fitted state are relatively small, giving the chance for the qubit to be measured even to the opposite state. The algorithm diversifies the search in this manner (exploration phase). As the number of iterations grows, the rotation steps become larger to make the qubit to be more and more likely to be measured into the best solution’s state (exploitation phase). The rotation steps are adjusted by coefficient m, which increases gradually throughout the iterations of each level, leading the rotation steps to become more prominent. Coefficient m is calculated using Equation (9).

$$m=\frac{1}{a-b(iteration/level\_iterations\_number)},a\ge b+1,$$

(9)

where a and b are tuning parameters and in this paper we set them to 1.1 and 0.1, respectively.

To determine the rotation step $\Delta \theta$ for each qubit, we consider three cases:

• When the $ith$ bit of the best fitted binary solution of the previous generation $\mathbf{b}$ and current chromosome $\mathbf{x}$ are not equal, and $\mathbf{b}$ is more fitted than $\mathbf{x}$, we rotate the corresponding qubit state in a direction that makes it more likely to collapse into the state of $b_i$ with a huge step. The rotation size of a huge step is formulated in Equation (10) for $b_i=1$ and $x_i=0$ and in and Equation (11) for $b_i=0$ and $x_i=1$.

  $$\Delta {\theta }_i=(\pi /2-{\theta }_i)\times m$$

  (10)

  $$\Delta {\theta }_i=-{\theta }_i\times m,$$

  (11)

  where m is the adjustment coefficient calculated by Equation (8).
• When the $ith$ bit of the best fitted individual b and current chromosome $\mathbf{x}$ are different and x has a higher fitness value in comparison to b, the corresponding qubit is pushed to the state of $x_i$ but this time with a little caution or hesitation, as the previous iteration’s best individual guides us conversely. This leads to a relatively smaller rotation size, called medium step. Equations (12) and (13) show the mathematical representation of the case with $b_i=1$ and $x_i=0$ and the case with $b_i=0$ and $x_i=1$, respectively.

  $$\Delta {\theta }_i=(\pi /2-{\theta }_i)\times \frac{m}{20}$$

  (12)

  $$\Delta {\theta }_i=-{\theta }_i\times \frac{m}{20}.$$

  (13)
• The last case is when $b_i$ and $x_i$ are identical. In this case, we do not care about which individual yields better fitness, as both of them share a similar state. So, we just move the qubit state by a tiny step in order to slightly confirm the last iteration’s best individual state regardless of the fitness comparison. These minor fluctuations help to keep the diversity of the population. Equation (14) expresses the tiny step when $b_i$ and $x_i$ are in state ‘1’, while Equation 15 shows otherwise.

  $$\Delta {\theta }_i=(\pi /2-{\theta }_i)\times \frac{m}{500}$$

  (14)

  $$\Delta {\theta }_i=-{\theta }_i\times \frac{m}{500}.$$

  (15)

As $\Delta {\theta }_i$ is proportional to qubit’s state ${\theta }_i$, the rotation steps are calculated adaptively. It means that the wider the angle between the current state and the desired ket, the larger the rotation step will be. Table 1 presents the look-up table of DQGA and summarizes all the possible cases and their corresponding rotation steps.

3.3. Distribution of Generations in Different Precision Levels

As DQGA utilizes different chromosome sizes during the algorithm, we must assign a certain number of iterations to each level. Intuitively, it is clear that levels with small chromosome sizes need fewer epochs to reach a suitable solution in comparison to those consisting of a larger amount of genomes. Because when we use low levels of precision, the number of potential solutions is far less than the case with high levels of precision. As a result, we determined to distribute the whole iteration number to get consistently larger for more extended chromosome sizes. Equation (15) gives the number of iterations at each level.

$$level\_iterations\_number=\frac{L}{max\_length(max\_length+1)/2}\times n,$$

(16)

where L is the number of each level and n is the whole number of iterations. The sum of the epochs of all levels equals to the whole number of generations. So, we have:

$$\sum _{k=1}^{max\_level}level\_iterations\_numbe{r}_k=n.$$

(17)

4. Experimental Results and Comparison Discussion

In this section, the comparison results of utilizing the proposed algorithm to solve various optimization problems are presented to assess its efficiency and performance. The DQGA approach is applied to 10 benchmark functions and three classical constrained engineering problems. Furthermore, we applied the Wilcoxon rank-sum test in order to show the significance of the difference between the proposed algorithm and comparison algorithms’ results.

4.1. Testing DQGA on Benchmark Functions

To show the abilities of the metaheuristic algorithms, it is a common practice to test the metaheuristic algorithms by several benchmark functions with different properties. We chose 10 of the most famous benchmark functions from the optimization literature. The description, domain, and the optima of the benchmark functions are taken from [51,52,53]. The benchmark functions are depicted in

Table 2. Description of benchmark functions.

Function Name	Function Description	Domain	${\mathit{F}}_{\mathbf{min}}$
Sphere Function	$F_1\left(\mathbf{x}\right)={\sum }_{i=1}^n{x}_i^2$	$[-5.12,5.12]$	0
Schwefel 2.22	$F_2\left(\mathbf{x}\right)={\sum }_{i=1}^n\left|x_i\right|+{\prod }_{i=1}^n\left|x_i\right|$	$[-10,10]$	0
Schwefel 2.21	$F_3\left(\mathbf{x}\right)={max}_i\left\{\left|x_i\right|,1\le i\le n\right\}$	$[-1.28,1.28]$	0
Rosenbrock	$F_4\left(\mathbf{x}\right)={\sum }_{i=1}^{n-1}\left[100{\left(x_{i+1}-x_i^2\right)}^2+{(x_i-1)}^2\right]$	$[-30,30]$	0
Step Function	$F_5\left(\mathbf{x}\right)={\sum }_{i=1}^n{\left(⌊x_i+0.5⌋\right)}^2$	$[-100,100]$	0
Ackley	$F_6\left(\mathbf{x}\right)=-20exp(-0.2\sqrt{\frac{1}{n}{\sum }_{i=1}^n{x}_i^2})-$ $exp(\frac{1}{n}{\sum }_{i=1}^{n}cos2\pi x_i)+20+e$	$[-32,32]$	0
Rastrigin	$F_7\left(\mathbf{x}\right)=10n+{\sum }_{i=1}^n\left[x_i^2-10cos\left(2\pi x_i\right)\right]$	$[-5.12,5.12]$	0
Schwefel	$F_8\left(\mathbf{x}\right)=418.9829n-{\sum }_{i=1}^n{x}_{i}sin\sqrt{\left|x_i\right|}$	$[-500,500]$	0
Styblisky–Tang	$F_9\left(\mathbf{x}\right)=\frac{1}{2}{\sum }_{i=1}^n(x_i^4-16x_i^2+5x_i)$	$[-5,5]$	$-39.16599n$
Levy	$F_{10}\left(\mathbf{x}\right)={sin}^2\left(\pi {\omega }_1\right)+{\sum }_{i=1}^{n-1}{({\omega }_i-1)}^2\times$ $\left[1+10{sin}^2(\pi {\omega }_i+1)\right]+$ ${({\omega }_n-1)}^2\left[1+{sin}^2\left(2\pi {\omega }_n\right)\right],$ $where{\omega }_i=1+\frac{x_i-1}{4},fori=1,\dots ,n$	$[-10,10]$	0

and are visualized in Figure 5. The first five functions are unimodal, meaning they have one global optimum and no local optima. Unimodal functions are suitable for testing the exploitation ability of optimization algorithms. Conversely, the last five benchmark functions are more challenging problems and are called multimodal functions. Each of these consists of numerous local optima. The number of dimensions for all the benchmark functions is set to 30.

We compared the results with five well-known and highly regarded metaheuristic algorithms, namely GA [54], GQA [8], PSO [55] which is, QPSO [56], and MFO [57]. The Python library Mealpy [58] is utilized to implement GA, PSO, and MFO algorithms for the comparison purpose. The number of iterations and the population size for all algorithms is set to 500 and 30, respectively.

Table 3. Parameter values for optimization algorithms.

Algorithm	Parameter	Value
GA [54]	Implementation type	Real-coded
	Selection method	Roulette wheel
	Crossover probability	$80\%$
	Mutation method	Flip
	Mutation probability	$0.05\%$
GQA [8]	No Parameter setting
PSO [55]	$c_1$	2
	$c_2$	2
	weight_min	0.1
	weight_max	0.9
QPSO [56]	$a_1$	1
	$a_2$	0.5
MFO [57]	a	$[-2,-1]$
	b	1
DQGA	min_length	16
	max_length	32
	interval	4
	a	1.1
	b	0.1

shows the values of parameters for all algorithms in this experimental comparison.

As can be seen in

Table 4. Comparison results for the benchmark functions.

F		GA [54]	GQA [8]	PSO [55]	QPSO [56]	MFO [57]	DQGA
$F_1$	Mean STD	$2.90\times {10}^0$ $4.06\times {10}^{-1}$	$2.32\times {10}^1$ $9.40\times {10}^0$	$5.58\times {10}^1$ $2.76\times {10}^1$	$2.39\times {10}^{-2}$ $3.38\times {10}^{-2}$	$\mathbf{1}.\mathbf{28}\times {\mathbf{10}}^{-\mathbf{5}}$ $2.53\times {10}^{-5}$	$3.05\times {10}^{-4}$ $2.02\times {10}^{-4}$
$F_2$	Mean STD	$1.17\times {10}^1$ $1.03\times {10}^0$	$3.34\times {10}^1$ $1.01\times {10}^1$	$2.48\times {10}^5$ $7.75\times {10}^5$	$3.95\times {10}^0$ $5.46\times {10}^0$	$4.35\times {10}^0$ $9.71\times {10}^0$	$\mathbf{7}.\mathbf{41}\times {\mathbf{10}}^{-\mathbf{2}}$ $2.44\times {10}^{-2}$
$F_3$	Mean STD	$1.24\times {10}^1$ $1.30\times {10}^0$	$5.70\times {10}^1$ $6.53\times {10}^0$	$3.65\times {10}^1$ $5.26\times {10}^0$	$1.67\times {10}^1$ $5.07\times {10}^0$	$4.94\times {10}^1$ $1.41\times {10}^1$	$\mathbf{7}.\mathbf{86}\times {\mathbf{10}}^{\mathbf{0}}$ $2.43\times {10}^0$
$F_4$	Mean STD	$1.93\times {10}^5$ $6.31\times {10}^4$	$8.17\times {10}^6$ $5.17\times {10}^6$	$4.04\times {10}^7$ $4.50\times {10}^7$	$7.93\times {10}^2$ $8.27\times {10}^2$	$9.76\times {10}^3$ $2.72\times {10}^4$	$\mathbf{5}.\mathbf{56}\times {\mathbf{10}}^{\mathbf{2}}$ $7.50\times {10}^2$
$F_5$	Mean STD	$1.17\times {10}^3$ $1.72\times {10}^2$	$8.70\times {10}^3$ $4.40\times {10}^3$	$2.31\times {10}^4$ $1.07\times {10}^4$	$5.59\times {10}^1$ $7.11\times {10}^1$	$7.63\times {10}^0$ $5.01\times {10}^0$	$\mathbf{2}.\mathbf{37}\times {\mathbf{10}}^{\mathbf{0}}$ $1.71\times {10}^0$
$F_6$	Mean STD	$7.32\times {10}^0$ $4.11\times {10}^{-1}$	$1.49\times {10}^1$ $1.43\times {10}^0$	$1.99\times {10}^1$ $1.49\times {10}^{-1}$	$3.92\times {10}^0$ $1.55\times {10}^0$	$1.76\times {10}^1$ $5.06\times {10}^0$	$\mathbf{1}.\mathbf{63}\times {\mathbf{10}}^{\mathbf{0}}$ $7.56\times {10}^{-1}$
$F_7$	Mean STD	$1.12\times {10}^2$ $9.79\times {10}^0$	$1.64\times {10}^2$ $2.89\times {10}^1$	$2.82\times {10}^2$ $6.10\times {10}^1$	$7.55\times {10}^1$ $2.49\times {10}^1$	1.31E+02 $2.82\times {10}^1$	$\mathbf{4}.\mathbf{94}\times {\mathbf{10}}^{\mathbf{1}}$ $9.28\times {10}^0$
$F_8$	Mean STD	$5.67\times {10}^3$ $3.58\times {10}^2$	$4.63\times {10}^3$ $5.80\times {10}^2$	$7.29\times {10}^3$ $1.15\times {10}^3$	$3.28\times {10}^3$ $4.28\times {10}^2$	$4.29\times {10}^3$ $4.63\times {10}^2$	$\mathbf{1}.\mathbf{91}\times {\mathbf{10}}^{\mathbf{3}}$ $4.03\times {10}^2$
$F_9$	Mean STD	$-9.79\times {10}^2$ $2.30\times {10}^1$	$-9.66\times {10}^2$ $4.96\times {10}^1$	$-7.77\times {10}^2$ $5.26\times {10}^1$	$-1.04\times {10}^3$ $3.77\times {10}^1$	$-1.03\times {10}^3$ $4.01\times {10}^1$	$-\mathbf{1}.\mathbf{14}\times {\mathbf{10}}^{\mathbf{3}}$ $5.66\times {10}^0$
$F_{10}$	Mean STD	$3.54\times {10}^0$ $6.90\times {10}^{-1}$	$2.88\times {10}^1$ $1.04\times {10}^1$	$8.60\times {10}^1$ $3.30\times {10}^1$	$5.45\times {10}^0$ $3.18\times {10}^0$	$8.45\times {10}^0$ $4.75\times {10}^0$	$\mathbf{3}.\mathbf{27}\times {\mathbf{10}}^{\mathbf{0}}$ $1.85\times {10}^0$

, the results of DQGA for the benchmark functions are promising in comparison to other algorithms. For unimodal benchmark functions, the proposed algorithm yields the best average results for all the benchmark functions except for the Sphere function, which is the second best after MFO. The results for the multimodal test functions, which are more similar to real-world problems and are more challenging, are even better, and DQGA outperforms all the other algorithms in all multimodal benchmark functions.

In order to test the significance of the difference in the results, the Wilcoxon statistical test is applied pairwise between DQGA and other comparative algorithms with the level of significance $\alpha =0.05$. The p-values obtained from the test are given in

Table 5. p-values of the Wilcoxon ranksum test between DQGA and comparison algorithms.

Function	GA [54]	GQA [8]	PSO [55]	QPSO [56]	MFO [57]
$F_1$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$
$F_2$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$3.82\times {10}^{-1}$
$F_3$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$
$F_4$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$6.14\times {10}^{-1}$	$3.29\times {10}^{-1}$
$F_5$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$3.42\times {10}^{-6}$
$F_6$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$2.60\times {10}^{-6}$	$1.73\times {10}^{-6}$
$F_7$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$1.15\times {10}^{-4}$	$1.73\times {10}^{-6}$
$F_8$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$1.92\times {10}^{-6}$	$1.73\times {10}^{-6}$
$F_9$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$
$F_{10}$	$7.73\times {10}^{-3}$	$1.73\times {10}^{-6}$	$1.73\times {10}^{-6}$	$6.16\times {10}^{-4}$	$2.16\times {10}^{-5}$

. From the results, it is apparent that none of the p-values is greater than 0.05, rejecting the null hypothesis and confirming the significance of the results.

To test the time efficiency of the proposed algorithm, we provided convergence curves that show and compare the algorithms’ iterations needed to reach specific fitness values. It should be noted that comparing the number of iterations is a more fair criterion than the total execution time, especially in our case, as the algorithms are of different implementation approaches that might have a substantial impact on the total execution time. For instance, multi-processing and multi-threading approaches can reduce the computational time to nearly one-fourth on a four-core CPU. For this reason, we chose to compare the algorithms based on the number of iterations criterion rather than the total execution time.

Figure 6 presents the convergence behavior of different algorithms in this experiment. The convergence curve of the proposed algorithm shows a steady improvement in the solution as the generations pass. The convergence speed is also very competitive with other algorithms. The pace is faster than other algorithms in most cases except for the Sphere function, Schwefel 2.21, Rosenbrock function, and Levy function which was roughly equivalent to GA and QPSO algorithms.

Boxplots in Figure 7 show the range of solutions in different runs. The low range of distribution of results for DQGA compared to the other algorithms verifies the reliability and consistency of the algorithm. The ranges are relatively lower or at least comparable to the best for DQGA except for the Levy function, in which the GA yielded more consistent results.

4.2. Constrained Engineering Design Optimization Using DQGA

As the ultimate purpose of metaheuristics is to tackle complex real-world problems and not merely solve mathematical benchmark functions, we also applied DQGA to three classical constrained engineering problems. The engineering problems are the pressure vessel design problem, the speed reducer design problem, and the cantilever beam design problem. The constraint handling technique used in this paper is the death penalty, meaning that the constraint violation leads to a substantial negative fitness and inability to compete with other solutions. The results obtained by DQGA were utterly satisfying and are presented in the following subsections in detail.

4.2.1. Pressure Vessel Design

The pressure vessel design problem was first introduced by [59]. The problem objective is to minimize the material, forming, and welding costs of producing a cylindrical vessel with two hemispherical caps at both ends (see Figure 8). The problem consists of four design variables: thickness of shell $T_S$, thickness of head $T_h$, inner radius R, and the cylindrical section’s length L. The problem is formulated as follows:

$$\begin{array}{cc}\hfill Consider& \mathbf{x}=\left[x_1{x}_2{x}_3{x}_4\right]=\left[T_s{T}_{h}RL\right],\hfill \\ \hfill Minimize& f\left(\mathbf{x}\right)=0.6224x_1{x}_3{x}_4+1.7781x_2{x}_3^2+3.1661x_1^2{x}_4+19.84x_1^2{x}_3,\hfill \\ \hfill Subjectto& g_1\left(\mathbf{x}\right)=0.0193x_3-x_1\le 0,\hfill \\ \hfill & g_2\left(\mathbf{x}\right)=0.00954x_3-x_2\le 0,\hfill \\ \hfill & g_3\left(\mathbf{x}\right)=1296000-\pi x_3^2{x}_4-\frac{4}{3}\pi x_3^3\le 0,\hfill \\ \hfill Domain& 0\le x_1,x_2\le 99,\hfill \\ \hfill & 10\le x_3,x_4\le 200.\hfill \end{array}$$

The results of applying DQGA to the pressure vessel design problem are given in

Table 6. Results of different algorithms for the pressure vessel design problem.

Algorithm	${\mathit{T}}_{\mathit{s}}$	${\mathit{T}}_{\mathit{h}}$	R	L	Minimum Weight
Branch-bound [60]	1.125	0.625	48.97	106.72	7982.5
GA [66]	0.81250	0.43750	42.097398	176.65405	6059.94634
GWO [61]	0.812500	0.434500	42.089181	176.758731	6051.5639
WOA [62]	0.812500	0.437500	42.0982699	176.638998	6059.7410
HHO [63]	0.81758383	0.4072927	42.09174576	176.7196352	6000.46259
WSA [64]	0.78654289	0.39348835	40.75268075	194.78059812	5929.62188231
AOA [65]	0.8303737	0.4162057	42.75127	169.3454	6048.7844
DQGA	0.79760749	0.39427185	41.31109227	186.64366007	5921.48841641

and are compared with the reported results of Branch-bound [60], GA [54], GWO [61], WOA [62], HHO [63], WSA [64], and AOA [65] algorithms. The results confirm that DQGA outperformed the other algorithms in solving this problem.

4.2.2. Speed Reducer Design

The speed reducer design problem aims to minimize the total weight of a speed reducer by concerning the bending stress on the gear teeth, stress on the surface, transverse deflections, and stresses in shafts constraints [67]. The problem has six continuous variables and one discrete variable $x_3$, which corresponds to the number of teeth on the pinion. The structure of a speed reducer is given in Figure 9, and the problem description is defined in the following:

$$\begin{array}{cc}\hfill Consider& \mathbf{x}=\left[x_1{x}_2{x}_3{x}_4{x}_5{x}_6{x}_7\right],\hfill \\ \hfill Minimize& f\left(\mathbf{x}\right)=0.7854x_1{x}_2^2(3.3333x_3^2+14.9334x_3-43.0934)-1.508x_1(x_6^2+x_7^2)\hfill \\ \hfill & +7.4777(x_6^3+x_7^3)+0.7854(x_4{x}_6^2+x_5{x}_7^2),\hfill \\ \hfill Subjectto& g_1\left(\mathbf{x}\right)=\frac{27}{x_1{x}_2^2{x}_3}-1\le 0,\hfill \\ \hfill & g_2\left(\mathbf{x}\right)=\frac{397.5}{x_1{x}_2^2{x}_3^2}-1\le 0,\hfill \\ \hfill & g_3\left(\mathbf{x}\right)=\frac{1.93x_4^3}{x_2{x}_3{x}_6^4}-1\le 0,\hfill \\ \hfill & g_4\left(\mathbf{x}\right)=\frac{1.93x_5^3}{x_2{x}_3{x}_7^4}-1\le 0,\hfill \\ \hfill & g_5\left(\mathbf{x}\right)=\frac{\sqrt{{(745x_4/x_2{x}_3)}^2+16.9\times {10}^6}}{110x_6^3}-1\le 0,\hfill \\ \hfill & g_6\left(\mathbf{x}\right)=\frac{\sqrt{{(745x_4/x_2{x}_3)}^2+157.5\times {10}^6}}{85x_7^3}-1\le 0,\hfill \\ \hfill & g_7\left(\mathbf{x}\right)=\frac{x_2{x}_3}{40}-1\le 0,\hfill \\ \hfill & g_8\left(\mathbf{x}\right)=\frac{5x_2}{x_1}-1\le 0,\hfill \\ \hfill & g_9\left(\mathbf{x}\right)=\frac{x_1}{12x_2}-1\le 0,\hfill \\ \hfill & g_{10}\left(\mathbf{x}\right)=\frac{1.5x_6+1.9}{x_4}-1\le 0,\hfill \\ \hfill & g_{11}\left(\mathbf{x}\right)=\frac{1.1x_7+1.9}{x_5}-1\le 0,\hfill \\ \hfill Domain& 2.6\le x_1\le 3.6,0.7\le x_2\le 0.8,17\le x_3\le 28,\hfill \\ \hfill & 7.3\le x_4\le 8.3,7.8\le x_5\le 8.3,2.9\le x_6\le 3.9,5.0\le x_7\le 5.3\hfill \end{array}$$

Table 7. Results for speed reducer design problem using different algorithms.

Algorithm	${\mathit{x}}_2$	${\mathit{x}}_3$	${\mathit{x}}_4$	${\mathit{x}}_5$	${\mathit{x}}_6$	${\mathit{x}}_7$	${\mathit{x}}_8$	Minimum Weight
CS [68]	3.5015	0.7000	17	7.6050	7.8181	3.3520	5.2875	3000.9810
FA [69]	3.507495	0.7001	17	7.7196	8.0808	3.351512	5.287051	3010.137492
WSA [64]	3.500000	0.7	17	7.3	7.8	3.350215	5.286683	2996.348222
hHHO-SCA [70]	3.506119	0.7	17	7.3	7.9914	3.452569	5.286749	3029.873076
AAO [71]	3.4999	0.6999	17	7.3	7.8	3.3502	5.2872	2996.783
AO [72]	3.5021	0.7000	17	7.3099	7.7476	3.3641	5.2994	3007.7328
AOA [65]	3.50384	0.7	17	7.3	7.7293	3.35649	5.2867	2997.9157
DQGA	3.500024	0.7	17	7.3	7.8	3.350226	5.286621	2996.321084

presents the comparison results for solving the speed reducer design problem by the proposed algorithm and CS [68], FA [69], WSA [64], hHHO-SCA [70], AAO [71], AO [72], and AOA [65] algorithms. It can be seen that DQGA obtained the best result among the comparison algorithms.

4.2.3. Cantilever Beam Design

The purpose of the problem is to find the minimum weight for a cantilever beam containing five hollow square based elements with constant thickness (Figure 10). The beam is fixed at the larger end with a vertical force acting at the other end.

$$\begin{array}{cc}\hfill Consider& \mathbf{x}=\left[x_1{x}_2{x}_3{x}_4{x}_5\right],\hfill \\ \hfill Minimize& f\left(\mathbf{x}\right)=0.6224(x_1+x_2+x_3+x_4+x_5),\hfill \\ \hfill Subjectto& g\left(\mathbf{x}\right)=\frac{61}{x_1^3}+\frac{27}{x_2^3}+\frac{19}{x_3^3}+\frac{7}{x_4^3}+\frac{1}{x_5^3}-1\le 0,\hfill \\ \hfill Domain& 0.01\le x_1,x_2,x_3,x_4,x_5\le 100.\hfill \end{array}$$

DQGA is applied to this problem and the results are compared with several algorithms including CS [68], SOS [73], MFO [57], GCA_I [74], GCA_II [74], SMA [75], and AO [72]. The results are given in

Table 8. Comparison of the optimum results of different algorithms for the cantilever beam design problem.

Algorithm	${\mathit{x}}_1$	${\mathit{x}}_2$	${\mathit{x}}_3$	${\mathit{x}}_4$	${\mathit{x}}_5$	Minimum Weight
CS [68]	6.0089	5.3049	4.5023	3.5077	2.1504	1.33999
SOS [73]	6.01878	5.30344	4.49587	3.49896	2.15564	1.33996
MFO [57]	5.984872	5.316727	4.497333	3.513616	2.161620	1.339988
GCA_I [74]	6.01	5.304	4.49	3.498	2.15	1.34
GCA_II [74]	6.01	5.304	4.49	3.498	2.15	1.34
SMA [75]	6.017757	5.310892	4.493758	3.501106	2.150159	1.33996
AO [72]	5.8881	5.5451	4.3798	3.5973	2.1026	1.3390
DQGA	5.967485	4.821212	4.502603	3.488657	2.161575	1.306752

. From the results, it can be seen that DQGA presents the optimal solution for this problem in comparison to the other algorithms.

5. Conclusions and Potential Future Work

In this paper, we proposed a modified QGA called DQGA, which focuses not only on exploration and exploitation abilities but on smoothing the transition between the mentioned phases. These improvements are achieved by an adaptive look-up table and a lengthening chromosomes strategy, which clarifies the search space gradually and postpones the convergence to high precision solutions to the ending generations, avoiding the algorithm from premature convergence and being trapped in the local optima. Experimental tests were conducted to ensure that the proposed concepts are effective in practice. DQGA outperformed the comparative algorithms in most cases, especially for multimodal benchmark functions and the more challenging engineering design problems.

These promising results give hope that the presented algorithm has the potential to tackle other real-world optimization problems. Future studies may include applying DQGA to various applications, such as network applications, fuzzy controller design, image thresholding, flight control, and structural design. In addition, the binary-coded nature of the proposed algorithm makes it suitable for discrete optimization problems like the travelling salesman problem, the 01 knapsack problem, the job-scheduling problem, airport gate allocation, and feature selection. Moreover, a systematic and adaptive tuning of parameters of DQGA, such as the minimum and the maximum length of chromosomes and incremental intervals, can be considered for further studies.