A new metaheuristic algorithm: car tracking optimization algorithm

Abstract

Over the last decade, several metaheuristic algorithms have emerged to solve numerical function optimization problems. Since the performance of these algorithms presents a suboptimal behavior, a large number of studies have been carried out to find new and better algorithms. Therefore, this paper proposes a new metaheuristic algorithm, namely the car tracking optimization algorithm; it is inspired by observing the programming methods of other metaheuristic algorithms. And the proposed algorithm has been tested over 55 benchmark functions, and the results have been compared with firefly algorithm (FA), cuckoo searching algorithm (CS), and vortex search algorithm (VS). The results indicate that the performance of the proposed algorithm surpasses FA, CS, and VS algorithm.

1 Introduction

Finding a set of parameter values to satisfy the required performance metric under certain constraints is called optimization. When it comes to practical problems, it refers to choosing the best scheme. With engineering, manufacturing, medicine, finance, biology, chemistry, physics, and other areas being deeply researched, many complicated optimization problems occur. It is time consuming to solve these optimization problems using single traditional optimization methods which are based on gradient. Therefore, since the 1970s, inspired by the nature of some physical, biological, and social phenomena, researchers have proposed a series of intelligent optimization algorithms, which provide a good solution to solve complex optimization problems. These algorithms are called meta-heuristics algorithms. In the 1980s, the simulated annealing algorithm (Gelatt et al. 1983; Goffe et al. 1994), random climbing algorithm (Goldfeld et al. 1966; Choi and Yeung 2006), and evolutionary algorithm (Holland 1975; Rechenberg 1965; Golberg 1989) came into being. Since the 1990s, some scholars have gained inspiration from the foraging behavior of natural swarm biological, and a stochastic optimization algorithm is put forward by simulating the foraging behavior of these creatures, and then the swarm intelligence algorithms are established. The current swarm intelligence algorithms include ant colony algorithm (Colorni et al. 1991; Dorigo et al. 1996; Dorigo and Stützle 1999), particle swarm optimization (Eberhart and Kennedy 1995; Shi and Eberhart 1998), fish swarm algorithms (Li et al. 2002; Wang et al. 2005), artificial bee colony algorithm (Karaboga and Basturk 2007; Gao and Liu 2012), firefly algorithm (Yang 2010b; Yang et al. 2012), cuckoo search algorithm (Yang and Deb 2009, 2010), bat algorithm (Yang 2010a; Yang and Hossein Gandomi 2012), fruit fly algorithm (Pan 2012; Li et al. 2013). These proposed swarm intelligence algorithms provide more choices to solve complex optimization problems.

Although meta-heuristic algorithms show a strong ability of optimization in solving modern nonlinear global optimization problems, some algorithms will fall into local optimum when facing different optimization problems. Yang (2010c) pointed out that all meta-heuristic algorithms strive for making balance between randomization and local search to some extent. Each optimization algorithm has its own strengths and weaknesses. Therefore, it is necessary to come up with a better algorithm that can solve most optimization problems, and that is why so many swarm intelligence algorithms have emerged in recent years.

We can summarize the rules of these algorithms by studying these optimization algorithms: the set of all possible solutions of the problem being regarded as the solution space, generate a new solution set by applying certain operator operation to a subset of the possible solutions of the problem, and gradually evolve the population to optimal or near-optimal solution. In these swarm intelligence optimization algorithms, particle swarm algorithm (Eberhart and Kennedy 1995) updates the velocity and position of all population according to Eqs. (1) and (2):

$$\begin{aligned} v_i \left( {t+1} \right)= & {} \omega v_i (t)+c_1 r_1 \left( {p_i -x_i (t)} \right) \nonumber \\&+\,c_2 r_2 \left( {p_\mathrm{g} -x_i (t)} \right) \end{aligned}$$

(1)

$$\begin{aligned} x_i \left( {t+1} \right)= & {} x_i (t)+v_i (t+1). \end{aligned}$$

(2)

As can be seen from Eq. (1), the flight path of the particles consists of three parts: The first part is the inertial motion of particles which contains the information of original speed $v_i (t)$ of the particle itself; the second part is “cognitive component,” which is reflected by the distance of optimum position acquired from their experiences because this part consider their own experience of the particles; the third part is the “social part”, which indicates the sharing of social information reflected by the distance between the particles and the best position $p_\mathrm{g}$ of swarm. $c_1 , c_2 , \omega$ are weighs that control these three parts. The value of the speed of the next generation is updated, and then the particle positions are updated by Eq. (2). We can see from the composition of the velocity update formula of the particle swarm algorithm that the algorithm does not take the relationship between the particles into account, but take only the relationship between each particle and the global optimal position $p_i$ and the relationship between each particle and the optimal position $p_\mathrm{g}$ of the population.

Firefly algorithm (Yang 2010b) updates the speed and location according to Eqs. (3) and (4):

$$\begin{aligned} v_i \left( {t+1} \right)= & {} \beta _{ij} \left( {r_{ij} } \right) \left( {x_j (t)-x_i (t)} \right) +\alpha \varepsilon _i \end{aligned}$$

(3)

$$\begin{aligned} x_i \left( {t+1} \right)= & {} x_i (t)+v_i (t+1). \end{aligned}$$

(4)

It can be seen from Eq. (3) that firefly flight path consists of two parts: The first part is reflected by the attraction $\beta _{ij} \left( {r_{ij} } \right)$ of firefly j whose absolute brightness is greater than firefly i to firefly i and the relative distance in between; the second part is a random term with a specific coefficient $\alpha \varepsilon _i$. We can see from the composition of the speed update formula of the firefly algorithm that the algorithm only considers the relationship between the fireflies and does not use the relationship between each firefly and the global optimal position to improve the global optimization ability.

Cuckoo search algorithm (Yang and Deb 2009) performs global random search according to Eq. (5) to update the speed, where $\alpha$ is step size and $L\left( \lambda \right)$ is Levy distribution function. Equation (6) represents the global random search trail of cuckoo according to Lévy flight process. $L\left( \lambda \right)$ can improve the global search ability, but the algorithm does not use the relationship between the various populations and the relationship between each population and the global optimal population to improve the search ability.

$$\begin{aligned} v_i \left( {t+1} \right)= & {} \alpha \oplus L\left( \lambda \right) \end{aligned}$$

(5)

$$\begin{aligned} x_i \left( {t+1} \right)= & {} x_i (t)+v_i \left( {t+1} \right) . \end{aligned}$$

(6)

Fruit fly algorithm (Pan 2012) updates the X axis ($X_i\left( {t{+}1} \right)$) and Y axis ($Y_i \left( {t+1} \right)$) positions of fruit flies in the next generation according to Eqs. (7) and (8); $X\_\mathrm{axisbest}(t)$ and $Y\_\mathrm{axisbest}(t)$ are the best place found by all fruit flies searching food in the last generation, the reciprocal of the distance ($\mathrm{Dist}_i$) between that position and the origin is taken as a solution, as in Eqs. (9) and (10). The fruit fly algorithm considers the position of the fruit flies population on the x, y axis and updates the position using the random number, but it is seen in Eqs. (7)–(10) that the algorithm does not use the relationship between each population and the relationship between each population and the global optimal population.

$$\begin{aligned} X_i \left( {t+1} \right)= & {} X\_\mathrm{axisbest}(t)+\mathrm{RandomValue} \end{aligned}$$

(7)

$$\begin{aligned} Y_i \left( {t+1} \right)= & {} Y\_\mathrm{axisbest}(t)+\mathrm{RandomValue }\end{aligned}$$

(8)

$$\begin{aligned} \mathrm{Dist}_i= & {} \sqrt{\left( {X_i^2 +Y_i^2 } \right) } \end{aligned}$$

(9)

$$\begin{aligned} S_\mathrm{i}= & {} \frac{1}{\mathrm{Dist}_i }. \end{aligned}$$

(10)

If we do not consider the background of these algorithms and their advantages and disadvantages, and simply take position and velocity updating formula of the four kinds of algorithms above into account, we can find that the velocity updating formula is constructed by the biological information of themselves, as well as some stochastic number for the particle swarm optimization algorithm (PSO) and the firefly algorithm. While the velocity updating formula of the cuckoo algorithm is derived by Levy distribution function, the fruit fly algorithm is different from optimization architecture of the former three algorithms; it can be seen from Eqs. (7) and (8) that the first part of the two equation is not current location $x_i (t)$ of each population, but the best position $X\_\mathrm{axisbest}(t)$ and $Y\_\mathrm{axisbest}(t)$ is gained in last generation.

Velocity update formula of different algorithms is different, but these algorithms basically change the current position using different operating operator to change the speed. So, in a way, we can also learn the speed update method of the above algorithms to design reasonable and effective speed update formula artificially to get the new algorithm even without the observation of the natural environment.

Although the algorithms above have good search ability, they only use either the relationship among the various populations, or the relationship between each population and the global optimal population. Therefore, this paper designs a new optimization algorithm to find optimal solutions for more optimization problems by studying the advantages and disadvantages of the above algorithms. This paper designs a new adaptive global velocity updating method by using the relationship between each population and the global optimal population, and a new local speed update method by using the relationship among various groups. The algorithm divides the search population into two groups. One group uses the adaptive global velocity update method to find the global optimal solution, and the other group uses the adaptive local velocity update method to help the algorithm jump out of the local optimal when it falls into the local optimum. The initial background of the algorithm is a scenario where a lot of cars are looking for an object on a road, so the proposed algorithm is named car tracking optimization algorithm. To test the effectiveness of the algorithm, the algorithm will optimize a total of 55 test functions mentioned in Doğugan and Ölmez (2015) and Osuna-Enciso et al. (2016), and optimization results obtained by this algorithm will be compared with results of the firefly algorithm, cuckoo search algorithm, and VS algorithm, and it can be found that the proposed algorithm is able to find more optimal solution to test functions comparing to the results of above three algorithms.

The rest part of this article is arranged as follow: The following section will describe car tracking algorithm in detail. The third part will analyze and discuss the experimental results. Finally, the fourth section summarizes this paper.

2 The proposed car tracking algorithm

As shown in Fig. 1, assume that there are N cars on a road (only A and B are shown in Fig. 1), which locates on both sides of the origin, and that they are assigned to search an object p on this road. Car A is on the left side of the origin, so the value that represents car A is negative, car B is on the right of the origin, so the value that car B is positive.

Fig. 1

Illustration iterative object p searching of car

The characteristics of the car are the desired speed ($V_N$) to find object p and current position ($X_N$) of the car . The cars can decide the magnitude and direction of the speed ($V_N$) according to their own ideas to find the location ($X_p$) where the object p probably is. When a car finds the possible location of object p, all cars will move to that location, and then restart searching the real location where the object p is.

In this article, based on the principle of cars searching object p, the procedure can be divided into several steps, and the readers can refer to programming example by following steps:

Fig. 2

Description of the proposed CTA

Table 1 Benchmark functions used in experiments

Table 2 Statistical results of 30 runs obtained by FA, CS, VS and CTA (values ${<}10^{-16}$ are considered as 0)

• (1) Randomly initialize the car population location ($X\_\mathrm{axis}_{i,j}$), where i is the size of randomly generated population, j represents that there are j cars in a population. If the objective function is one-dimensional, then $j=1$. If the objective function is n-dimensional, then $j ={ n}$.

  $$\begin{aligned} \mathrm{Init}\,X\_\mathrm{axis}_{i,j}. \end{aligned}$$

  (11)

• (2) Randomly initialize the speed ($V\_\mathrm{RandomValue}_{{i,j}}$, positive and negative represents direction) and the initialized position ($X_{i,j} (t))$ of the car population (i, j) individuals, and the position is limited within a certain range, as shown in Eq. (13), where t represents the iteration times.

  $$\begin{aligned}&X_{i,j} (t)=X\_\mathrm{axis}_{i,j} +V\_\mathrm{RandomValue}_{{i,j}} \end{aligned}$$

  (12)
  $$\begin{aligned}&X_{i,j} (t)\nonumber \\&\quad = \left\{ {{\begin{array}{l} {\mathrm{rand}\left( {0,1} \right) \cdot \mathrm{upperlimit}_j ,X_{i,j} (t)>\mathrm{upperlimit}_j } \\ {X_{i,j} (t),\mathrm{lowerlimit}_j \le X_{i,j} (t)\le \mathrm{upperlimit}_j } \\ {\mathrm{rand}\left( {0,1} \right) \cdot \mathrm{lowerlimit}_j ,X_{i,j} (t)<\mathrm{lowerlimit}_j } \\ . \end{array} }} \right. \nonumber \\ \end{aligned}$$

  (13)

• (3) After the initial move, substitute car population position ($X_\mathrm{i} (t)$) into objective judgment function (or called fitness function) in order to obtain possible objects p ($P.\mathrm{Might}_i (t)$) that is found by every car population.

  $$\begin{aligned} P.\mathrm{Might}_i (t)=\mathrm{Function}\left( {X_i (t)} \right) . \end{aligned}$$

  (14)

• (4) Seek the $i_{\mathrm{best}}$ ($i_{\mathrm{best}} =\hbox {first,\,second,\,third,}\,\hbox {forth}{\ldots }$) car population which is most likely to find the object p in all car population, $P.\mathrm{Might}_{\mathrm{best}} (t)$ is the optimal value of the objective function found after the iteration for t times, which can be seen as the object p most likely to be found in the iteration of t, and compared with historical optimum $P_{\mathrm{best}} (P_{\mathrm{best}}$ in the first iteration can be set as any solution). If it is better than $P_{\mathrm{best}}$, then replace $P_{\mathrm{best}}$ and the best position $X\_\mathrm{axisBest}_j (t)$ with $P.\mathrm{Might}_{\mathrm{best}} (t)$ and $X_{\mathrm{bestindex},j} (t)$, and replace the position of the least possible object p ($X\_\mathrm{axisWorst}_{j} (t)$) with $X_{\mathrm{worstindex},j} (t)$ in addition. After then all other car populations will be starting from that location ($X\_\mathrm{axisBest}$).

  $$\begin{aligned}&\left[ {P.\mathrm{Might}_{\mathrm{best}} (t)\quad i_{\mathrm{best}} } \right] =\mathrm{min}\left( {P.\mathrm{Might}} \right) \end{aligned}$$

  (15)
  $$\begin{aligned}&\left[ {P.\mathrm{Might}_{\mathrm{worst}} (t)\quad i_{\mathrm{worst}} } \right] =\mathrm{max}\left( {P.\mathrm{Might}} \right) \end{aligned}$$

  (16)
  $$\begin{aligned}&P_{\mathrm{best}} =P.\mathrm{Might}_{\mathrm{best}} (t) \end{aligned}$$

  (17)
  $$\begin{aligned}&X\_\mathrm{axisBest}_{j} (t)=X_{\mathrm{bestindex},j} (t) \end{aligned}$$

  (18)
  $$\begin{aligned}&X\_\mathrm{axisWorst}_{j} (t)=X_{\mathrm{worstindex},j} (t) \end{aligned}$$

  (19)
  $$\begin{aligned}&X_{\mathrm{bestindex},j} (t)=\mathrm{lowerlimit}_j\nonumber \\&\quad +\,\mathrm{rand}\left( {0,1} \right) \cdot \left( {\mathrm{upperlimit}_j -\mathrm{lowerlimit}_j } \right) \end{aligned}$$

  (20)
  $$\begin{aligned}&X_{\mathrm{worstindex},j} (t)=\mathrm{lowerlimit}_j\nonumber \\&\quad +\,\mathrm{rand}\left( {0,1} \right) \cdot \left( {\mathrm{upperlimit}_j -\mathrm{lowerlimit}_j } \right) . \end{aligned}$$

  (21)

• (5) In order to make all cars which have arrived at that place capable of searching object p more intelligently after reaching this position, all cars are divided into two groups, group A whose speed is $V_{{i,j}}$ conducts local searching, which is obtained from the Eqs. (22) to (24), global searching for group B, speed is $U_{{i,j}}$, which is obtained from Eqs. (25) and (26). Iterative search number is the MAXGEN, t on behalf of the car has searched t times current, Eqs. (22) and (25) are updated in every generation of searching.

  $$\begin{aligned} V_{i,j} =\left\{ \begin{array}{ll} S_i /\left( X_{i,j} \left( {t-1} \right) -X_{i-1,j} \left( {t-1} \right) \right) ,&{}i=2:{k}/2 \\ S_i /X_{i,j} ,&{}i=1 \\ \end{array} \right. \end{aligned}$$

  (22)

  In Eq. (22),

  $$\begin{aligned} S_i= & {} 10^{\left( {10\cdot \mathrm{rand}\left( {0,1} \right) } \right) }\cdot \mathrm{rand}\left( {0,1} \right) \cdot ( {1/( {m( i )\cdot t} )^{2}} ),\nonumber \\ i= & {} 1:{k}/2 \end{aligned}$$

  (23)

  In Eq. (23),

  $$\begin{aligned} m=m_0 +P.\mathrm{Might}_{\mathrm{best}} (t) /10{,}000\cdot \mathrm{rand}n\left( {{k}/2,1} \right) \end{aligned}$$

  (24)

The physical meaning of Eq. (24) is that if the distance of car (i, j) and car ($i-1, j$) is smaller, then car (i, j) will conduct the next search at a relatively higher speed after it reaches the best position, and vice versa. However, such definition mode can increase local search range to some extent and prevent the search range from being too dense. S is defined as a local search speed change factor sequence, and it consists of three parts of $10^{\left( {10\cdot \mathrm{rand}\left( {0,1} \right) } \right) }, \mathrm{rand}\left( {0,1} \right)$ and $\left( {1/\left( {m\left( i \right) \cdot t} \right) ^{2}} \right)$, multiple $10^{\left( {10\cdot \mathrm{rand}\left( {0,1} \right) } \right) }$ by $\mathrm{rand}\left( {0,1} \right)$ to get a random number between 0 and $10^{10}$ which is able to improve the ability of the algorithm to jump out of the local optimal to a certain extent. $\left( {1/\left( {m\left( i \right) \cdot t} \right) ^{2}} \right)$ is a set of m-determined sequences, and m is a set of numbers whose mean value is $m_0$ and standard deviation is Mightbest / 10, 000. It can be seen that m is positively to $P.\mathrm{Might}_{\mathrm{best}} (t)$, so $\left( {1/\left( {m\left( i \right) \cdot t} \right) ^{2}} \right)$ is a set of negative correlations that are negatively related with $P.\mathrm{Might}_{\mathrm{best}} (t)$. Because the general algorithm will gradually fall into the local optimal in the optimization process, for the minimum optimization, the smaller $P.\mathrm{Might}_{\mathrm{best}} (t)$ is, the bigger the $\left( {1/\left( {m\left( i \right) \cdot t} \right) ^{2}} \right)$ value is, and with the increase in the iterations times t, the value of $\left( {1/\left( {m\left( i \right) \cdot t} \right) ^{2}} \right)$ will continue to increase in the optimization process, together with stronger ability the algorithm to jump out of local best. Noting that for the maximum optimization at the same time, it needs to replace $\left( {1/\left( {m\left( i \right) \cdot t} \right) ^{2}} \right)$ with $\left( {m\left( i \right) \cdot t} \right) ^{2}$, which leads to the same effect as the minimum optimization. Therefore, the product of $10^{\left( {10\cdot \mathrm{rand}\left( {0,1} \right) } \right) }, \mathrm{rand}\left( {0,1} \right) , \left( {1/\left( {m\left( i \right) \cdot t} \right) ^{2}} \right)$ (or $\left( {m\left( i \right) \cdot t} \right) ^{2})$ can be obtained to ensure that the local search speed change factor sequence S is random and the algorithm has the ability to jump out of local optimal. The local search speed is related to the relative distance of $X_{i,j}$ and $X_{i-1,j}$, and the distance of $X_{i,j}$ and $X_{i-1,j}$ will be closer in the optimization process, and S is getting bigger and bigger, resulting in a larger result of Eq. (22), and once again improve the algorithm’s ability to jump out of the local optimal.

$$\begin{aligned} U_{i,j}= & {} { SS}/\left( {X_{i,j} \left( {t-1} \right) -X\_\mathrm{axisBest}_j \left( {t-1} \right) } \right) \nonumber \\&+\,{ SS}/( X_{i,j} \left( {t-1} \right) \nonumber \\&-\,X\_\mathrm{axisWorst}_j \left( {t-1} \right) ),i=\left( {1+{k}} \right) /2:{k}. \end{aligned}$$

(25)

In Eq. (25),

$$\begin{aligned} { SS}=10^{\left( {-10\cdot \mathrm{rand}\left( {0,1} \right) } \right) }\cdot \mathrm{rand}\left( {0,1} \right) \cdot \left( {t/{ mm}} \right) ^{2}. \end{aligned}$$

(26)

Table 3 A summary of Table 2

Table 4 Pair-wise statistical comparison of the algorithms by Wilcoxon signed-rank test ($a = 0.05$)

The global search speed $U_{i,j}$ is related to the relative distance of $X_{i,j} \left( {t-1} \right) , X\_\mathrm{axisBest}_j \left( {t-1} \right)$ and $X\_\mathrm{axisWorst}_j \left( {t-1} \right)$, obtained by Eq. (25). The physical meaning of Eq. (25) is that if the distance of car (i,j) position $X_{i,j} \left( {t-1} \right)$ and the current best car position $X\_\mathrm{axisBest}_j \left( {t-1} \right)$ is close, therefore car (i,j) is relatively far to the current worst car position $X\_\mathrm{axisWorst}_j \left( {t-1} \right)$, then car (i, j) will use relatively greater speed in the next search after it reaches the best position, and vice versa; this defined way increases flexibility and intelligence of searching; meanwhile, it has the advantage of increasing the global search capability. The SS is a global search speed change factor, which is a random number defined by Eq. (26); it consists of $10^{\left( {-10\cdot \mathrm{rand}\left( {0,1} \right) } \right) }, \mathrm{rand}\left( {0,1} \right)$ and $\left( {t/{ mm}} \right) ^{2}$. $10^{\left( {-10\cdot \mathrm{rand}\left( {0,1} \right) } \right) }$ is multiplied by $\mathrm{rand}\left( {0,1} \right)$ to get a random number ranging from 0 to $10^{-10}$. The optimization process of the algorithm will gradually approach the optimal value. In this case, the step size of optimization cannot be set too large so as to avoid missing the optimal value in the process. $\left( {t/{ mm}} \right) ^{2}$ increases with the increment of iteration times, which ensures that the optimal size of the search is not too small to cause the optimization process to be too slow and ineffective. The multiplication of the three parts guarantees that the optimization process of the algorithm will gradually approach the optimal value. In the optimization process, both the relative distance of $X_{i,j} \left( {t-1} \right)$ and $X\_\mathrm{axisBest}_j \left( {t-1} \right)$ and the relative distance of $X_{i,j} \left( {t-1} \right)$ and $X\_\mathrm{axisWorst}_j \left( {t-1} \right)$ will be closer, while SS is getting bigger and bigger, resulting in a larger result of Eq. (26), which can guarantee the algorithm to jump out of the local optimal solution near the global optimal solution. In addition, the reason why the relative distance between $X_{i,j} \left( {t-1} \right)$ and $X\_\mathrm{axisWorst}_j \left( {t-1} \right)$ gets closer is because the algorithm will make the optimal solution $P.\mathrm{Might}_{\mathrm{best}} (t)$ and the worst solution $P.\mathrm{Might}_{\mathrm{worst}} (t)$ closer in the optimization process, and it can be seen that the relative distance of $X_{i,j} \left( {t-1} \right)$ and $X\_\mathrm{axisWorst}_j \left( {t-1} \right)$ will be getting closer in some sense.

$$\begin{aligned} V\_\mathrm{RandomValue}_{{i, j}}= & {} \left\{ {{\begin{array}{l} {V_{{i, j}} ,i=1:{k}/2} \\ {U_{i,j} ,i=(1+{k}/2):{k}} \\ \end{array} }} \right. \end{aligned}$$

(27)

$$\begin{aligned} X\_\mathrm{axis}_{{i, j}}= & {} X\_\mathrm{axisBest}_{j} (t) \end{aligned}$$

(28)

$$\begin{aligned} X_{i,j}= & {} X_{{i}_{\mathrm{best}} ,j} =X\_\mathrm{axisBest}_j \end{aligned}$$

(29)

$$\begin{aligned} X_{i,j}= & {} X_{{{i}}_{\mathrm{worst}} ,j} =X\_\mathrm{axisWorst}_j. \end{aligned}$$

(30)

Equations (20) and (21) are set to prevent the situation of Eqs. (29) or (30), which results in zero denominator of Eq. (25) when Eq. (25) tends to acquire speed ($U_{{i,j}}$). In the formulas above, $m_0$ is 10,000 and mm is 500,000. The function of $\mathrm{rand}n\left( {k/2,1} \right)$ is to generate k/2 numbers whose mean value is 0 and standard deviation is 1.

• (6) Repeat steps 2–4 to enter the iterative optimization, and then determine whether the current position is better than previous iterations position, if so, enter step 5.

Figure 2 is pseudocode of complete car tracking optimization algorithm procedure. Figure 2 shows that car tracking optimization algorithm is not more complex compared with the algorithms mentioned previously, the difference is that the population is divided into two groups, designing a new adaptive global velocity updating method by utilizing the relationship between each population and the global optimal population, as well as a new local speed update method by utilizing the relationship among the various groups, thereby changing the position of the population. But the idea of separating the population into groups is not new, which has been mentioned in the literature (Dai et al. 2011; Askarzadeh and Rezazadeh 2011; Han et al. 2013). At the same time, the proposed CTA algorithm only has two parameters, mm and $m_0$, apart from the number of iterations (MAXGEN), the number of population (k), the upper and lower limits of the problem and the dimension of the problem (D), we can use the method of trial and error to get these two parameters. Here is a method for readers to refer to, the reader can take mm as 500,000 on the basis, and multiplied or divided by 10 to select the appropriate mm, in the same way of selection $m_0$. For the vast majority of test functions in this article, we will be able to find the optimal solution when setting mm as 500,000, and $m_0$ as 10,000.

Table 5 A summary of Table 4

Fig. 3

Average time of finding the best value of all algorithms for 55 benchmark functions

3 Experimental results

The proposed car tracking algorithm is tested on 55 benchmark functions, 50 of which are from the research of Karaboga and Akay (2009). In their study, Karaboga and Akay has compared ABC algorithm with GA, PSO, and DE algorithms. After that, Berat and Tamer proposed VS algorithm (Doğugan and Ölmez 2015), the performance of which is tested using the same 50 functions, in comparison with SA, PS, PSO2011, and ABC algorithms. Therefore, in this study, by using the same 50 test functions, the performance of CTA will be compared with the FA, CS and VS algorithm. FA and CS have been introduced in the first part, and VS algorithm showed good optimization capabilities in the test results of Doğugan and Ölmez (2015). In order to test the optimization capability of algorithms on high-dimensional functions, another five functions include Salomon, rotated hyper-ellipsoid, Apline, hyper-ellipsoid, and Levy function are added from study (Osuna-Enciso et al. 2016) of Valentín and Erik, et al. the dimension of five functions all are 100.

In order to evaluate the performance of the algorithm, this paper will test the optimization capability and the convergence behavior of the algorithm. First, in order to test the optimization capability, the algorithms are evaluated according to the mean and best fitness values found from each benchmark function repeated for a fixed number of evaluations. Then in order to test the convergence behavior, the average number of evaluations of finding the optimal solution by each algorithm are compared.

Table 1 shows the tested 55 functions, which includes many different kinds of problems, such as unimodal and separable problems, unimodal and non-separable problems, multimodal and separable problems, multimodal and non-separable problems. In Table 1, the parameters used in some functions can be seen in “Appendix A.” Specific introduction of these types of functions can be referred to in Doğugan and Ölmez (2015) and Karaboga and Akay (2009). F51–F55 are the additional five high-dimensional test functions, as previously described in Osuna-Enciso et al. (2016).

3.1 Parameter settings

The basic parameters of all algorithms are the same, including population size and the maximum number of function evaluations. Population size of each algorithms is 50, and the maximum number of function evaluations of all algorithms is 500,000. The other specific parameters of algorithms are given as follows:

FA settings: the largest attractiveness $\beta _0$ is chosen to be 1, the light absorption coefficient $\gamma$ is set to 1, take $\alpha$ as 0.2, as recommended in Yang (2010b).

CS settings: the probability $p_a$ that the host bird can find the egg laid by a cuckoo is 0.25, and the step size is set to 1, as recommended in Yang and Deb (2009).

VS settings: the x of gamma function is set to 0.1 as recommended in Doğugan and Ölmez (2015).

Table 6 Average number of function evaluations to find the optimal value and mean value of 30 runs to study the convergence behavior of the algorithms

3.2 Results

3.2.1 Optimization performances comparison

For each algorithm, all benchmark functions are run for 30 times, and the mean, the best values, the standard deviation, and average time of finding the best value are recorded in Table 2. In addition, the best ones are highlighted in bold, and the values below $10^{-16}$ are assumed to be 0, being the same as in Doğugan and Ölmez (2015). All algorithms are coded in MATLAB and run in a PC using an Intel Core i5-2450M with 8GB RAM workstation.

After no more than 500,000 evaluations, the number of minimum of various types of functions found by each algorithm in Table 2 are summarized in Table 3. It can be seen from Table 3 that for the test function of all types, the optimization performance of FA is the worst the CS algorithm performs better than VS algorithms and the performance of the CTA proposed in this paper are better than that of the other three kinds of optimization algorithms. However, in order to better compare the proposed algorithm with other algorithms, the results of each function obtained from 30 runs are used in a Wilcoxon signed-rank test which is performed with a statistical significance value $a = 0.05$ as in Doğugan and Ölmez (2015). The p values, T$+$, T− (i.e., T$+$ and T−, as defined in Civicioglu (2013)) and Winner after each algorithm performs pair-wise Wilcoxon signed-rank test are recorded in Table 4. ‘$+$’ indicates that the CTA exhibits a statistically superior performance than compared algorithm; ‘_’ indicates the CTA exhibits an inferior performance than compared algorithm; and ‘$=$’ indicates cases in which there is no statistical difference between the two algorithms. Table 5 is a summary of Table 4, each cell in Table 5 shows the total count of the three statistical significance cases ($+/=/-$) in the pair-wise comparison obtained from Table 4, it can be found from Table 5 that the proposed CTA outperforms other algorithms on three types of function including US, UN and MS. For MN problem, the optimization performance of CTA and CS algorithm is almost the same, but the VS and FA underperform the CTA. In summary, the optimization performance of CTA proposed in this paper is superior to the other three algorithms.

Doğugan and Ölmez (2015) indicates that VS is very simple, and it is not population based algorithms. Furthermore, the it can be concluded that with the same iterations, the average computational time of VS algorithm is smaller than the other population based algorithms (ABC, PSO2011). While the algorithms compared with VS algorithm in this paper are all population based algorithms, therefore, it can be predicted that the results should be similar as that in Doğugan and Ölmez (2015). So this paper does not compare the average computational time for same iterations, but the average time of finding the best value of all algorithms, as shown in Fig. 3. It shows that the proposed CTA is quite competitive comparing with VS algorithm. Although the average time of finding the best value of VS algorithm is much faster than others on most of the function, it is not the fastest on a few of test functions. Moreover, it can be seen by observing the optimization time of CS algorithm and CTA that the running time of CTA is shorter than the CS algorithm.

Table 7 A summary of Table 6

Fig. 4

Error iteration curve of Quartic function obtained by each algorithm

Fig. 5

Error iteration curve of Powell function obtained by each algorithm

3.2.2 Convergence behavior comparison

It can be seen in Table 2 that for a large proportion of functions, the optimal value can be obtained after 500,000 evaluations, so in order to compare the capability of convergence behavior of the algorithms, the number of evaluations is reduced to 250,000 times. The mean value and the average number of evaluations is counted to find the optimal value of 30 runs. The results are shown in Table 6. Method of comparison is that if the algorithms are able to find the optimal value within 250,000 evaluations, the algorithm which runs the least average evaluations to find the optimal value has better convergence performance; if the algorithms are unable to find the optimal value after 250,000 evaluations, the final results are compared and the smaller optimization result of the algorithm is, the better the performance convergence of that algorithm is.

The optimal solution in Table 6 displays in bold. The results of the algorithms are compared, the method of comparison is described above and the comparison results are expressed in the form of a/b/c shown in Table 7, where ‘a’ represents the number of evaluations where convergence performance of CTA is better than compared algorithm, ‘b’ represents the number where convergence performance of CTA is similar to compared algorithm, ‘c’ represents the number where convergence performance of CTA is relatively inferior to compared algorithm. It can be drawn that the proposed CTA has shown greater convergence behavior compared with the other three algorithms on different types of functions. In addition, for some of the functions, more number of evaluation is required in order to find the optimal solution for all of the algorithms.

In order to show how the proposed algorithms dominate the others, we selected 11 out of 55 benchmark functions and plotted the error iteration graphs obtained by each algorithm solving function as shown in Figs. 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 and 14. Figures 4, 5, 6, 10, 11 show that the CTA algorithm dominates the others before the 1000th iterations, while Figs. 7, 8, 9, 12, 13 and 14 show that the CTA algorithm dominates the others at the beginning. So we can conclude that the solving speed of CTA is quite efficient compared to other algorithms.

Fig. 6

Error iteration curve of Schwefel 1.2 function obtained by each algorithm

Fig. 7

Error iteration curve of Rastrigin function obtained by each algorithm

Fig. 8

Error iteration curve of Michalewicz10 function obtained by each algorithm

Fig. 9

Error iteration curve of Ackley function obtained by each algorithm

Fig. 10

Error iteration curve of Salomon function obtained by each algorithm

Fig. 11

Error iteration curve of Rotated hyper-ellipsoid function obtained by each algorithm

Fig. 12

Error iteration curve of Alpine function obtained by each algorithm

Fig. 13

Error iteration curve of Hyper-ellipsoid function obtained by each algorithm

Fig. 14

Error iteration curve of Levy function obtained by each algorithm

Table 8 A parameter of the Fletcher–Powell function

4 Conclusion

This paper presents a new swarm intelligence optimization algorithm named CTA, which is different from the previous swarm intelligence algorithms. It is not obtained by observing the foraging behavior of biological, but created artificially through observing the programming methods of these algorithms. This algorithm divides the car population into two groups, and uses global and local iterative search strategy to find the optimal solution, respectively. Global search strategy adaptively adjusts the pace based on the best and the worst current position, while the local search strategy adaptively adjusts the pace based on the relative distance between the position of the cars around

Table 9 B parameter of the Fletcher–Powell function

The proposed CTA is tested over a large set of 55 benchmark, and these 55 functions are rich in type which comprises unimodal, multimodal, separable and non-separable problems, and range covers 100-dimensional function as well. The results are compared with those of FA, CS and VS; the results showed that CTA is highly competitive compared with the other algorithms. Because the CTA algorithm is a new algorithm and the velocity updating formula is not perfect, so it needs further discussion and improvement.

Appendix A

See Tables 8, 9, 10, 11, 12, 13, 14 and 15.

Table 10 $\alpha$ parameter of the Fletcher–Powell function

Table 11 A parameter of the Foxholes function

Table 12 a and b parameters of the Kowalik function

Table 13 a and c parameters of the Shekel functions

Table 14 a, c and p parameters of the 3-parameter Hartman function

Table 15 a, c and p parameters of the 6-parameter Hartman function