A novel non-dominated sorting genetic algorithm for multi-objective optimization: DSGA

Non-dominated sorting is a critical component of all multi-objective evolutionary algorithms (MOEAs). A large percentage of computational cost of MOEAs is spent on non-dominated sorting. So the complexity of nondominated sorting method in a large extent decides the eﬃciency of the MOEA. In this paper, we present a novel non-dominated sorting method called the dynamic non-dominated sorting (DNS). It is based on the sorting of each objective instead of dominance comparisons. The computational compelxity of DNS is O ( mN log N ) ( m is the number of objectives, N is the population size), which equals to the best record so far. Based on DNS, we introduce a novel multi-objective genetic algorithm (MOGA) called the dynamic nondominated sorting genetic algorithm (DSGA). Then, some numerical comparisons between diﬀerent non-dominated sorting method are presented. The results shows that DNS is eﬃcient and promising. Finally, numerical experiments on DSGA are also given. The results show that DSGA outperforms some other MOEAs both on general-scale and large-scale multi-objective problems.


Introduction
Multi-objective optimization has extensive application in engineering and management. Many optimization problems in the real-world can be modeled as multi-objective optimization problems (MOPs) [10], [23], [35]. However, due to the theoretical and computational challenges, it is not easy to solve MOPs. Therefore, numerical multi-objective optimization attracts a wide range of research over the last decades.
One popular way to solve MOP is to reformulate it into a single-objective optimization problem. We call this technique the indirect method. Typical indirect methods are weighted sum method [31], ε−constraint method [7] and their variations [11]. One difficulty for the weighted sum method is the selection of proper weights so as to satisfy the decision-maker's preference. Since the weighted sum is a linear combination of the objective functions, the concave part of the Pareto frontier cannot be obtained using the weighted sum method. The ε−constraint method converts multiple objectives, except one, to constraints. However, it is difficult to determine the upper bounds of these objectives. On the one hand, small upper bounds could exclude some Pareto solutions; on the other hand, large upper bounds could enlarge the searching area, which yields some sub-Pareto solutions. Additionally, indirect method can only obtain a single Pareto solution in each run, but in the real-world application, decision-makers often prefer a number of optional strategies so that they can choose one according to their preference.
Another strategy to solve MOP is to explore the entire objective function value space directly in order to obtain its Pareto frontier. We call this strategy the direct method. Population-based heuristic methods are ideal direct methods, because their iterative units are populations instead of a single point, so they can obtain a set of solutions in a single run. In the past few years, many heuristic methods were applied to solve MOP, such as the evolutionary algorithm [19], [25], [39], genetic algorithm [34] and differential evolution [22], [24]. Among them, genetic algorithm attracted a great deal of attention and lots of good methods has been presented [3], [13], [16], [17].
A combination of direct and indirect methods is another strategy to solve MOP. We call this type the hybrid method. A representative of this type is MOEA/D [36]. It combines the evolutionary algorithm and three scalarization methods.
When solving MOP using direct methods, two important issues [42] need to be addressed: -Elitism: In the process of multi-objective evolutionary algorithm (MOGA), we always prefer solutions whose function values are closer to the real Pareto frontier. In the selection procedure, these solutions should be selected as parents for the next generation, which leads the task of non-dominated sorting in each iteration. According to the definition of efficient point, numerous amount of comparisons are needed to identify the non-dominated state of each point. Therefore, reasonably reducing the computational cost is one of the key research issues in designing MOEA.
-Diversity: Diversity reflects the distribution of the obtained Pareto frontier. Obviously, a uniformly distributed Pareto frontier is preferred than a unevenly distributed one. In other words, a good algorithm should avoid obtaining solutions which are excessively concentrate on one or two isolated areas.
Among them, elitism is realized by non-dominated sorting whose core operation is comparison. Since non-dominated sorting is needed in each iteration, the efficiency of non-dominated sorting method is very important for the performance of MOEA. In this paper, we first propose a novel non-dominated sorting method called the dynamic non-dominated sorting (DNS), and then a new multiobjective genetic algorithm (MOGA) based on DNS. The rest of the paper is organized as follows: In Section 2, we review some existing non-dominated sorting methods and the framework of genetic algorithm. In Section 3, we proposed DNS and a new MOGA based on DNS. In Section 4, we compare DNS with other existing non-dominated sorting methods. In Section 5, we test the proposed MOGA using some numerical benchmarks and compare its numerical performance with other MOEAs. Section 6 concludes the paper.

Related works
In this section, we first review some basic definitions of multiobjective optimization, then some existing non-dominated sorting methods, and finally propose the framework of genetic algorithm.

Some basic definitions of MOP
The general mathematical model of MOP is Here F : R n → R m is a vector function and X ⊆ R n is a box constraint.
Obviously, if y ≺ z, then y z. In this paper, if y z, we say y dominates z or z is dominated by y; if y z and z y, we say y and z are non-dominated.
Let Y ⊆ R m and y * ∈ Y , if there is no y ∈ Y such that y y * (or y ≺ y * ), then y * is called an efficient point (or weakly efficient point) of Y . Suppose that F (x * ) is an efficient point (or weakly efficient point) of the objective function value space F (X), then x * is called an efficient solution (or weakly efficient solution) of Problem (1).
Efficient and weakly efficient solutions can also be defined using cone or partial order. Another name of the efficient solution is Pareto solution. The meaning of Pareto solution is that, if x * is a Pareto solution, there is no feasible solution x ∈ X, such that f i (x) ≤ f i (x * ) for all i ∈ {1, 2, · · · , m} and there is at least one i 0 ∈ {1, 2, · · · , m} such that f i0 (x) < f i0 (x * ). In other words, x * is the best solution in the sense of " ". Another intuitive interpretation of Pareto solution is that it cannot be improved with respect to any objective without worsening at least one of the others. Weakly efficient solution means that if x * is a weakly efficient solution, then there is no feasible solution x ∈ X, such that any f i (x) of F (x) is strictly better than that of F (x * ). In other words, x * is the best solution in the sense of "≺". Obviously, an efficient solution is also a weakly efficient solution. The set of efficiet solutions is denoted by P * , its image set F (P * ) is called the Pareto frontier, denoted by PF * .

Existing non-dominated sorting methods
Non-dominated sorting is one of the critical step in MOEAs. A large percentage of computation cost is spent on non-dominated sorting for it involves numerous comparisons. Until now, there are more than ten different non-dominated sorting methods [18]. The earliest one is the naive non-dominated sorting [26]. In this method, in order to find if a solution is dominated, the solution has to do dominance comparisons with all the other solutions, which leads a numerical complexity of O(mN 3 ) in the worst case. Here, m stands for the number of objectives, N stands for the population size, the same below. The naive approach does not record any dominance comparison result, which in return cause a lot of repeated computation. The fast non-dominated sorting [3] overcomes this drawback by calculating two entities for each solution p: (i) domination count n p , the number of solutions which dominate the solution p; and (ii) dominate set S p , a set of solutions that the solution p dominates. This modification reduces the computational complexity of the fast non-dominated sorting to O(mN 2 ).
In [20] McClymont and Keedwell proposed climbing sorting and deductive sorting. The climbing sorting is similar to the bubble sorting for real number sequence. In order to locate a non-dominated solution, the candidate is shifted from dominated solution to the dominating one until all the solutions in the current population are visited. The final candidate must be a non-dominated solution. The deductive sorting is similar to the selection sorting for real number sequence. In the deductive sorting, one successively check each solution, once the current solution is found to be dominated, abandon it. If the current solution dominates all the other solutions, or is non-dominated with the others, then it is identified as a non-dominated solution. The climbing sorting works well on populations with large number of Pareto frontiers. On the contrary, the deductive sorting is good at sorting population with small number of Pareto frontiers. The average computational complexity of the climbing sorting and deductive are both O(mN 2 ).
Another idea to save dominance comparisons is to discard the identified non-dominated solutions, Corner sorting [30] applies this idea. Some of the non-dominated sorting method consider the partial order of the solutions in the populations. For example, the efficient non-dominated sorting [38] first sorts solutions using the common partial order of m−dimensional vector. This sorted population has a very important feature: solution p m will never be dominated by a solution p n if m < n. As shown in Table (III) in [38], computational complexity of the efficient non-dominated sorting is O(mN 2 ) in the worst case, while O(mN √ N ) or O(mN log N ) in the best case (depends on the different methods used in partial order.) In order to avoid repeated dominance comparisons, one can record the results of dominance comparisons in a matrix. This idea is applied in the dynamic non-dominated sorting [18] where a N × N matrix with entries 1, −1, 0 is used to record the dominance relationships between solutions. The computational complexity of the dynamic non-dominated sorting is O(mN 2 ). Another method applying this idea is the dominance degree sorting [41]. This method first calculate a comparison matrix for each objective, then builds a dominance degree matrix by adding these comparison matrixes together. The dominance relationship can be found in the dominance degree matrix. In the dominance degree sorting, only the real number sequence sorting is needed. This makes it much faster than the method based on dominance comparison. In this paper, we improve the dynamic non-dominated sorting by hybridizing it with the dominance degree sorting. The computational complexity of the improved dynamic non-dominated sorting will decrease to O(mN log N ).

Genetic algorithm
In computer science and operations research, genetic algorithm (GA) which is inspired by the process of natural selection, is one of the most popular evolutionary algorithms. It is introduced by John Holland in 1960s, and then developed by his students and colleagues at the University of Michigan between 1960s and 1970s [9]. Over the last two decades, GA was increasingly enriched by plenty of literatures [12], [33], [21]. Nowadays, GA are applied in a wide range of areas, such as mathematical programming, combinational optimization, automatic control, image processing, etc.. Suppose P (t), O(t) and S(t) represent parents, offsprings and selection pool of the t th generation, respectively. The general structure of GA is described in Algorithm 1.

Algorithm 1: Genetic algorithm
Input: Population size N p , crossover rate α c , mutation rate α m , maximal generation number t max and problem parameters. Output: Obtained population and their corresponding evaluation.
Step 2: While t has not reached t max , do Step 2.1: Crossover operator: generate crossover offspring O c (t), Step 2.2: Mutation operator: generate mutation offspring O m (t), Step 2.3: Evaluation: evaluate O c (t) and O m (t) and build the selection pool by Step 2.4: Selection operator: select P (t + 1) from S(t), Step 2.5 Let t ← t + 1, go back to Step 2.
The implementation of GA may be various in different situations. For example, some implementation generate O c (t) and O m (t) independently based on P (t), while some implementation first generate O c (t) based on P (t), then yields O m (t) based on O c (t). Furthermore, crossover, mutation and selection operators are alterable in GA. Different designs of these operators lead to different numerical performance of GA.
It is worth to notice that, for notation P (t), O(t) and S(t), we do not specify whether they are decision variables (i.e., P (t)/O(t)/S(t) ⊂ X) or objective function values (i.e., P (t)/O(t)/S(t) ⊂ F (X)) since they are bijection through objective function F (x). One can distinguish them according to the contexts. For example, when calculating the Pareto frontier, they are seen as objective function values; when running crossover and mutation, they are seen as decision variables.

Dynamic sorting genetic algorithm
In this section, we first propose an improved dynamic non-dominated sorting, then based on the improved dynamic non-dominated sorting, design a novel multiobjective optimization genetic algorithm titled the dynamic sorting genetic algorithm.

Dynamic non-dominated sorting
According to the definition of efficient point, in order to detect the nondominated points in a selection pool, each solution must compare with the others in the selection pool to find if it is dominated. In the naive sorting [2], the non-dominated points in different Pareto frontiers are detected one by one, so there exists numerous repetitive dominance comparisons between some candidate pairs, which in a large extent increases the computational complexity of native sorting. In this subsection, we tackle this shortage by recording the result of dominance comparison between each candidate pairs, which in return, avoids any repeated comparison. This idea is inspired by the dynamic programming, so we call it the dynamic non-dominated sorting.
Suppose S(t) is the current selection pool who has N solutions. The aim of non-dominated sorting is to identify all the Pareto frontiers in S(t). We denote the i th Pareto frontier l i (1 ≤ i ≤ i max ). Obviously, we have 1 ≤ i max ≤ N , i max = 1 means that all the solutions in S(t) are non-dominated, i max = N means that each Pareto frontier has only one solution. We use a N × N matrix D to record the dominance relationship in S(t), where The non-dominated solutions can be detected using D. Each row of D stands for a solution. If there is no −1 in the i th row, that means y i is not dominated by any other solution, i.e., y i is non-dominated. Finding all rows with this feature, we can detect all the non-dominated solutions. These solutions consist the first Pareto frontier of the selection pool S(t). Assign l i = 1 to these points. When detecting the second Pareto frontier, solutions on the first Pareto frontier (already identified) should not be involved any more. So before detecting the second Pareto frontier, we first shrink D by discarding the rows and columns whose solutions are already identified as in the first Pareto frontier. Then repeat the same process to detect the second Pareto frontier and so forth, until all the solutions are identified, i.e., the matrix D becomes empty.
The procedure of the dynamic non-dominated sorting is presented in Algorithm 2. The input is the current selection pool S(t), its size is N ; the output is the Pareto frontier index l i , i = 1, 2, · · · , N . Step 1 computes the N × N dynamic matrix D.
Step 2 detects the current non-dominated solution using the current D.
Step 3 shrinks the matrix D by removing rows and columns corresponding to the detected non-dominated solutions in Step 2. Then if D is not empty, go back to Step 2 to detect non-dominated solution in the next Pareto frontier; otherwise, the process of non-dominated detection finishes. It is worth to note that after some rows and columns have been removed, the index of the matrix D and the index of solution in the selection pool are not corresponding any more. So in Algorithm 2, we use an index set I ij to virtually shrink the matrix D. Here the index i always means the index of a solution in the selection pool.
Step 1: Compute a N × N dynamic matrix D whose element is Step 2: Let k := k + 1, search by rows, find set Step 3: Shrink the matrix D by removing indexes I from the index set I ij , i.e., I ij = I ij \ I.
Step 4: If I ij is not empty, go back to Step 2; otherwise stop the loop.
The index l i is called the Pareto frontier index. The smaller l i is, the better elitism y i is, i.e., the solution with smaller Pareto frontier index is closer to the real Pareto frontier.

Dynamic matrix
The computation of the dynamic matrix D is the core step of the dynamic non-dominated sorting, most of the computational cost is spent on this step. If use the dominance comparison to calculate the dynamic matrix D, N (N −1)/2 times of dominance comparisons are needed, which makes the computational complexity of the dynamic non-dominated sorting O(mN 2 ). Through the transitivity of dominating can be used in practice, it still cannot reduce the computational complexity dramatically. In this subsection, we apply the idea presented in the dominance degree sorting [41], introducing a faster method to calculate the dynamic matrix.
The process of calculating the dominance matrix is as follows. Firstly, for each objective, we calculate a N × N comparison matrix C f k (1 ≤ k ≤ m) which records the comparison relationship of solutions on this objective. Take the first objective for example, suppose vector w f1 = (p f1 C f1 can be obtained very fast by sorting the members of w f1 .
Secondly, adding all the comparison matrix together to get a dominance degree matrix C, i.e., To eliminate the effect of these solutions with identical values for all objectives, we set the corresponding element of C to be zero. For example, if p i and p j are identical respect to all objectives, we set C ij = 0. Obviously, according to this rule, C ii = 0 for all i = 1, 2, · · · , N .
Thirdly, the elements of C reflect the dominance relationship between solutions. For example, The pseudocode of calculating the dynamic matrix is presented in Algorithm 3

Algorithm 3: Dynamic matrix
Input: Selection pool S(t) and its size N = |S(t)|, number of objectives m, an iteration counter k = 1. Output: Dynamic matrix D. Step then let Step 2: If k + 1 ≤ m, then let k = k + 1, go back to step 1; otherwise, let Step 3: Build dynamic matrix D. If Cij = m, then let Dij = 1 and Dji = −1; otherwise, let Dij = 0.
Step 4: Output the dynamic matrix D.
The main computational effort of the dynamic matrix is on the computation of the comparison matrixes C f k (k = 1, 2, · · · , m). Intuitively, for each objective, function values are compared with each other, so N (N − 1)/2 real number comparisons are needed, which makes the numerical complexity of dynamic matrix O(mN 2 ). However, this process can be improved by applying a real number sequence sorting method, such as quick sort [41]. The computational complexity of the quick sort is O(N log N ), so the computational complexity of dynamic matrix is O(mN log N ).

Dynamic sorting genetic algorithm (DSGA)
In this subsection, we present a novel multi-objective genetic algorithm. Nondominated sorting in this algorithm applies the dynamic non-dominated sort-ing presented above, so we call this algorithm the dynamic sorting genetic algorithm, abbreviated as DSGA. The process of DSGA is presented in Fig.  1. In the step of crossover and mutation, self-adaptive simulated binary crossover operator (SSBX) [4] and power mutation operator (PM) [6] are applied. The SSBX operator is a real-parameter recombination operator which is commonly used in the evolutionary algorithm (EA) literature. The operator involves a parameter which dedicates the spread of offspring solutions vis-a-vis that of the parent solutions. The PM operator is based on the power distribution. It is proved to have the same performance as the widely used non-uniform mutation operator [6].
For the selection step, the binary tournament selection operator used in NSGA-II is still applied in DSGA. The binary tournament selection operator is mainly constituted by the fast non-dominated sorting and the crowdedcomparison operator. In DSGA, we replace the fast non-dominated sorting by the dynamic non-dominated sorting proposed above.

Comparison of non-dominated sorting methods
In order to clarify the improvement of the dynamic non-dominated sorting (DNS), this subsection compares it with other non-dominated sorting methods. Except DNS proposed in this paper, four other referential non-dominated sorting methods are considered: the fast non-dominated sorting (FNS) [3], climbing sorting (CS) [20], deductive sorting (DS) [20] and the dominance degree non-dominated sorting (DDNS) [41]. FNS is one of the earliest Pareto sorting approaches. It is updated from the naive non-dominated sorting [2]. The computational complexity of FNS is O(mN 2 ). CS follows dominating relationships between solutions and climbs up the graph toward the Pareto frontier. The key process of CS is to change the considering solution from any dominated one to dominating one until a non-dominated solution (at the current Pareto frontier) has been identified. The computational complexity of CS is O(mN 2 ). DS accesses each solution based upon the natural order of the population. The candidate solution compares with all its following solutions but not with its previous ones. The average numerical complexity of DS is O(mN 2 ), but in the best case that each Pareto frontier has only one solution, it decreases to O(mN ). DDNS is one of the state-of-the-art non-dominated sorting algorithms. Differently from the other non-dominated sorting algorithms, DDNS does not compare two solutions to identify dominating relationship. Instead, it constructs a comparison matrix which stores the relationship of all solutions with respect to each objective. Then a dominance degree matrix can be obtained by adding these comparison matrices together. Finally, Pareto ranking of the population can be obtained by analyzing the dominance degree matrix. If use quick sort in ranking each objective, the computational complexity of DDNS is O(mN log N ).
We compare DNS with the other referential non-dominated sorting methods introduced above. For metrics of numerical performance, time consumption and number of comparisons are considered. Experiments are divided into three groups: (i) performance with respect to the variation of the the population size, (ii) performance with respects to the variation of the number of Pareto frontiers, and (iii) performance with respect to the variation of the number of objectives. We use the fixed features population generator [18] to generate test populations. This generator can generate test populations with certain features, such as having prefixed number of points, prefixed number of Pareto frontier and prefixed number of points in each Pareto frontier. The generated test populations are listed in Table 1 where m stands for the number of objectives, k stands for the number of Pareto frontiers and N is a vector standing for the number of points in each Pareto frontiers. In the series (i) test populations, the number of objectives and Pareto frontiers are fixed, while the number of points in each Pareto frontier are even and increases from 12 to 30 with a step of 2. In the series (ii) test populations, the number of objectives is fixed, while the number of Pareto frontiers increases from 1 to 10 with step of 1, each test population has 150 points in total evenly distributed in each Pareto frontier. In the series (iii) test populations, the number of Pareto frontiers and number of points in each Pareto frontier are fixed, while the number of objectives arises from 2 to 10 with step of 1.
Results of the numerical experiments are illustrated in Fig. 2, 3 and 4. In Fig. 2(b), FNS needs much more comparisons than the other four methods, CS and DS need exact the same amount of comparisons, DDNS and DNS too but less than CS and DS. As the increase of population size, number of comparisons for FNS increases much faster than the other four method, then DS and CS, the increasing trend of DDNS and DNS are relative gentle. The same features demonstrated in Fig. 2(a) for time consumption. It is worth to note that DDNS spent slightly less time than DNS. Fig. 3 shows that, as the number of Pareto frontiers increase, the time consumption and number of comparisons decrease for CS and DS. DDNS and DNS stay in a lower level stably, while FNS is stably appears in a very high level.
It is showed in Fig. 4 that the time consumption and the number of comparisons increase as the arise of the number of objectives. This is reasonable, because the increase of the number of objectives must increases the number of comparisons, which in return increases the time consumption. But the increase rates are different. FNS has the steepest trend, CS and DS are less, DDNS and DNS only have slight increase.
In summary, the computation complexity of DNS keeps stable if the population size is fixed, and has a slight increase if the population size and number if objectives increase. This statement agrees with the theoretical complexity analysis of DNS. DNS outperforms FNS, CD and DS, and performs the same as DDNS which is considered as the most efficient non-dominated sorting method [41].

Numerical experiments
In this section, we investigate the numerical performance of DSGA. Firstly, we further compare the sorting methods FNS and DNS by embedding them into the same MOEA (NSGAII [3]). Secondly, we compare DSGA with some of the other popular MOEAs, including MOEA/D [36], SparseEA [28], PPS [8] and LSMOP [29]. Finally, we investigate the numerical performance of DSGA when scaling the number of variables.

Test problems
We use five series of test problems in the numerical experiments. They are ZDT series [42], DTLZ series [5], UF series [37], BT series [15] and LSMOP series [1]. Features of these test problems including number of objective functions m, number of dimensions n, variable bounds X and references are demonstrated in Table 2. All test problems are scalable respect to the number of dimensions, the DTLZ series is also scalable respect to the number of objective functions. Numbers in the brackets are the number of dimensions or the number of objectives we set in our experiments. Details of the objective functions, referential Pareto frontiers and Pareto solutions refer to the references.

Referenial algorithms and parameter setting
We use five referential MOEAs in the numerical experiments. They are NS-GAII [3], MOEAD [36], SparseEA [28], PPS [8] and LSMOF [29]. Among them, NSGAII is one of the most popular MOEA based on genetic algorithm. In the past decades, NSGAII got thousands of citations. MOEAD is a successful multiobjective optimization method based on decomposition, it is often used as a  [14] standard in numerical experiments. SparseEA, PPS and LSMOF are three of the latest MOEAs, note that SparseEA and LSMOF are originally designed for solving large-scale multiobjective optimization problems. Among the five referential algorithms, NSGAII is used to verify the improvement of the sorting method DNS comparing with the traditional one FNS, while the other four referential algorithm are used to investigate the numerical performance of the proposed method DSGA. The implementation of these algorithms are based on the PlatEMO [27]. For the sake of fair comparison, parameters for all algorithms are uniformly set as far as possible. To be specific, the population size is set to be 100, the maximum number of objective function evaluations is set to be 100000, the maximum number of iterations is set to be 500. The maximum number of objective function evaluations and iterations are taken as stop criteria for all algorithms. In order to achieve statistic performance, all the test are run 30 times independently, and the mean and standard deviation of the performance metrics are recorded. The other parameters for certain algorithms are set as the default in PlatEMO.

Performance metrics
Many performance metrics have been proposed to evaluate the numerical performance of MOGAs [40]. There are two goals for evaluation metrics: (i) measure the convergence of the obtained Pareto frontier, and (ii) measure the diversity of the obtained Pareto frontier.
We use the performance metric IGD [17] to evaluate the numerical performance. Suppose that P * is a set of uniformly distributed points belonging to the real Pareto frontier. It can be taken as a standard representation of the real Pareto frontier. Let A be a set of solutions obtained by a certain solver, then IGD is defined as the average distance from P * to A: where d(v, A) is the minimum Euclidean distances between v and the points in A, i.e., In fact, P * is a sample set of the real Pareto frontier. If |P * | is large enough to approximate the Pareto frontier very well, IGD(A, P * ) could measure both the diversity and convergence of A. This is also the reason that we choose IGD as the evaluation metric for this paper. A smaller IGD(A, P * ) means the set A is closer to the real Pareto frontier and has better diversity. Another well-known performance metric is the hypervolume value (HV) [32] of the obtained non-dominated solutions. The calculation of HV value do not need a referential Pareto frontier P * , but is more complicated than the calculation of IGD value, especially when the number of objectives is large. In this paper, we use IGD instead of HV since the referential Pareto frontiers of the test problems are all known and evenly distributed ones can be generated using PlatEMO.

NSGAII with FNS and DNS
In this subsection, we compare FNS and DNS by embedded them into the same MOEA. Since FNS is originally used in NSGAII, we replace FNS in NSGAII by DNS to build a new MOEA. In the following, we call the NSGAII with FNS NSGAII-FNS, and call the NSGAII with DNS NSGAII-DNS. Note that NSGAII-FNS and NSGAII-DNS are only different in the non-dominated sorting method.
In order to achieve fair competition and statistical performance, all the tests are run for 30 times independently, and the mean and standard deviation of two performance metrics, CPU time and IGD value, are recorded. In the following tables, the best record for a certain performance metric is marked as in grey cell. Besides, the Wilcoxon rank sum test with a significant level of 0.05 is adopted to perform statistical analysis the experimental results, where the symbols "+","-" and "=" indicate that the result by NSGAII-FNS are significantly better, significantly worse and statistically similar to that obtained by NSGAII-DNS, respectively.
As shown in Table 3, NSGAII-DNS spends significantly less CPU time than NSGAII-FNS on all test problems, which further verifies that DNS is faster than FNS. As for the IGD value, Table 3 shows that 38 out of the total 39 test problems are statistically similar. This is reasonable for that NSGAII-FNS and NSGAII-DNS are only different in the non-dominated sorting method, which affects the CPU time but not the final solutions.
In Figure 5, we demonstrate the decrease curve of IGD of the first test problem in each series. Because inside a series, the test problems have more or less the same structure, the IGD curve of one problem can represent the others. For each test problem, 10 samples of IGD value are taken evenly from 1000 to 10000 times of objective function evaluations. From Figure 5, the IGD value of NDGAII-DNS and NSGAII-FNS converge to almost the same value for problems ZDT1 and DTLZ1. Figures 5(d) and 5(e) show that NSGAII-DNS outperforms NSGAII-FNS for problems BT1 and LSMOP1. For problem UF1, Figure 5(c) shows that NSGAII-FNS outperforms NSGAII-DNS.