On the Simplex Algorithm Initializing

Abstract

This paper discusses the importance of starting point in the simplex algorithm. Three different methods for finding a basic feasible solution are compared throughout performed numerical test examples. We show that our two methods on the Netlib test problems have better performances than the classical algorithm for finding initial solution. The comparison of the introduced optimization softwares is based on the number of iterative steps and on the required CPU time. It is pointed out that on average it takes more iterations to determine the starting point than the number of iterations required by the simplex algorithm to find the optimal solution.

1. Introduction

There are two main methods for solving linear programming problem: the Simplex method and the interior point method. In both of these two methods it is necessary to determine the initial point. It is known that the application of the simplex algorithm requires at least one basic feasible solution. For the interior point method, in most cases it is enough that the point belongs to the so-called central path. Note also that in most algorithms based on interior point methods, the starting point need not to be feasible. However, in practical implementation it is shown that the numerical stability of the algorithm still depends on the choice of the starting point. These issues are investigated in papers [1, 2].

Two classical algorithms for generating the initial point for the Simplex algorithm are the two-phase Simplex algorithm and the Big-M method. The main drawback of these algorithms is requiring the introduction of artificial variables, increasing the dimension of the problem. From that reason, algorithms which do not require the introduction of artificial variables are developed. A heuristic for finding the starting point of a linear programming problem, which is based on the method of minimal angles, is proposed in [3]. Unfortunately, these heuristics can be used only for certain classes of problems. Similar heuristics are investigated in the papers [4–6]. Different versions of the algorithm which does not introduce artificial variables are given in the papers [7–12]. One variant of these algorithms is introduced and discussed in the paper [11], which was the inspiration for our paper. We compare three different methods for finding an initial basic feasible solution (the starting point for the Simplex algorithm) throughout performed numerical test examples. Two methods, called 𝑀1 and 𝑀2, are introduced in [13], while the third method, called NFB, is established in [11].

2. The Simplex Method and Modifications

Consider the linear programming (LP) problem in the standard matrix form: Maximize𝐜^𝑇𝐱−𝑑,subjectto𝐴𝐱=𝐛,𝐱≥0, (2.1) where 𝐴∈ℝ^{𝑚×(𝑚+𝑛)} is the full row rank matrix (rank(𝐴)=𝑚), 𝐜∈ℝ^𝑛+𝑚, and the system 𝐴𝐱=𝐛 is defined by 𝐱∈ℝ^𝑚+𝑛, 𝐛∈ℝ^𝑚. It is assumed that (𝑖,𝑗)-th entry in 𝐴 is denoted by 𝑎_𝑖𝑗, 𝐛=(𝑏₁,…,𝑏_𝑚)^𝑇, 𝑑∈ℝ, 𝐱^𝑇=(𝑥₁,…,𝑥_𝑛+𝑚), and 𝐜^𝑇=(𝑐₁,…,𝑐_𝑛+𝑚).

Then we choose 𝑚 basic variables 𝑥_𝐵,1,…,𝑥_𝐵,𝑚, express them as a linear combination of nonbasic variables 𝑥_𝑁,1,…,𝑥_𝑁,𝑛, and obtain the canonical form of the problem (2.1). We write this canonical form in Table 1.

Table 1  

 

Coefficients of the transformed matrix 𝐴 and the transformed vector 𝑐 are again denoted by 𝑎_𝑖𝑗 and 𝑐_𝑗, respectively, without loss of generality.

For the sake of completeness we restate one version of the two-phase maximization simplex algorithm from [12, 14] for the problem (2.1), represented in Table 1.

Within each iteration of the simplex method, exactly one variable goes from nonbasic to basic and exactly one variable goes from basic to nonbasic. Usually there is more than one choice for the entering and the leaving variables. The next algorithm describes the move from the current base to the new base when the leaving-basic and entering-nonbasic variables have been selected.

Algorithm 2.1 (consider interchange a basic variable 𝑥_𝐵,𝑝 and nonbasic variable 𝑥_𝑁,𝑗). 𝑎¹_𝑞𝑙=1𝑎_𝑝𝑗𝑎,𝑞=𝑝,𝑙=𝑗_𝑝𝑙𝑎_𝑝𝑗−𝑎,𝑞=𝑝,𝑙≠𝑗_𝑞𝑗𝑎_𝑝𝑗𝑎,𝑞≠𝑝,𝑙=𝑗_𝑞𝑙−𝑎_𝑝𝑙𝑎_𝑞𝑗𝑎_𝑝𝑗,𝑞≠𝑝,𝑙≠𝑗,𝑏¹_𝑙=𝑏_𝑝𝑎_𝑝𝑗𝑏,𝑙=𝑝_𝑙−𝑏_𝑝𝑎_𝑝𝑗𝑎_𝑙𝑗,𝑐,𝑙≠𝑝_1𝑙=𝑐_𝑙−𝑐_𝑗𝑎_𝑝𝑙𝑎_𝑝𝑗−𝑐,𝑙≠𝑗,_𝑗𝑎_𝑝𝑗,𝑙=𝑗,𝑑¹𝑏=𝑑−^𝑝𝑐_𝑗𝑎_𝑝𝑗. (2.2)
The next algorithm finds an optimal solution of the LP problem when the condition 𝑏₁,…,𝑏_𝑚≥0 is satisfied.

Algorithm 2.2.
Step 𝑆1𝐴. If 𝑐₁,…,𝑐_𝑛≤0, then the basic solution is an optimal solution.
Step 𝑆1𝐵. Choose 𝑐_𝑗>0 according to the Bland's rule [15].
Step 𝑆1𝐶. If 𝑎_1𝑗,…,𝑎_𝑚𝑗≤0, stop the algorithm. Maximum is +∞.
Otherwise, go to the next step.
Step 𝑆1𝐷. Compute min_{1≤𝑖≤𝑚}𝑏_𝑖𝑎_𝑖𝑗∣𝑎_𝑖𝑗=𝑏>0^𝑝𝑎_𝑝𝑗. (2.3)
If the condition 𝑏₁,…,𝑏_𝑚≥0 is not satisfied, we use the algorithm from [12, 14] to search for the initial basic feasible solution. In contrast to approach used in [16], it does not use artificial variables and therefore does not increase the size of the problem. It is restated here as the following Algorithm 2.3.

Algorithm 2.3.
Step 𝑆2. Select the last 𝑏_𝑖<0.
Step 𝑆3. If 𝑎_𝑖1,…,𝑎_𝑖𝑛≥0, then STOP. LP problem is infeasible.
Step 𝑆4. Otherwise, find 𝑎_𝑖𝑗<0, compute min_𝑘>𝑖𝑏_𝑖𝑎_𝑖𝑗∪𝑏_𝑘𝑎_𝑘𝑗∣𝑎_𝑘𝑗=𝑏>0^𝑝𝑎_𝑝𝑗, (2.4) choose 𝑥_𝑁,𝑗 as the entering-nonbasic variable, 𝑥_𝐵,𝑝 as the leaving-basic variable, apply Algorithm 2.1, and go to Step 𝑆2.

Note that Algorithm 2.3 and the NFB algorithm from [11] are equivalent. As shown in the paper [13], the lack of the algorithm from [12] is that when it is applied to transform the selected coordinate from the basic solution into a positive, it can increase the number of negative coordinates.

The problem of selecting a leaving-basic variable and corresponding entering-nonbasic variable in the two-phase simplex method is contained in Step 𝑆1𝐷 of Algorithm 2.2 and Step 𝑆4 of Algorithm 2.3. We observed two drawbacks of Step 𝑆4. By 𝑖 we denote the index of the last negative 𝑏_𝑖.(1)If 𝑝=𝑖 for each index 𝑡<𝑖=𝑝 such that 𝑏_𝑡𝑎_𝑡𝑗<𝑏_𝑝𝑎_𝑝𝑗,𝑏_𝑡>0,𝑎_𝑡𝑗>0 (2.5) in the next iteration 𝑥_𝐵,𝑡 becomes negative: 𝑥¹_𝐵,𝑡=𝑏¹_𝑡=𝑏_𝑡−𝑏_𝑝𝑎_𝑝𝑗𝑎_𝑡𝑗<𝑏_𝑡−𝑏_𝑡𝑎_𝑡𝑗𝑎_𝑡𝑗=0. (2.6)(2)If 𝑝>𝑖, in the next iteration 𝑏¹_𝑖 is negative: 𝑏_𝑝𝑎_𝑝𝑗<𝑏_𝑖𝑎_𝑖𝑗⇒𝑏¹_𝑖=𝑏_𝑖−𝑏_𝑝𝑎_𝑝𝑗𝑎_𝑖𝑗<0. (2.7)Although there may exist 𝑏_𝑡<0, 𝑡<𝑖 such that min_𝑘>𝑡𝑏_𝑡𝑎_𝑡𝑗,𝑎_𝑡𝑗∪𝑏<0^𝑘𝑎_𝑘𝑗∣𝑎_𝑘𝑗>0,𝑏_𝑘=𝑏>0^𝑡𝑎_𝑡𝑗. (2.8) In such case, it is possible to choose 𝑎_𝑡𝑗 for the pivot element and obtain 𝑥_𝐵,𝑡=𝑏¹_𝑡=𝑏_𝑡𝑎_𝑡𝑗≥0. (2.9) Also, since 𝑏_𝑡/𝑎_𝑡𝑗≤𝑏_𝑘/𝑎_𝑘𝑗, each 𝑏_𝑘>0 remains convenient for the next basic feasible solution: 𝑥_𝐵,𝑘=𝑏¹_𝑘=𝑏_𝑘−𝑏_𝑡𝑎_𝑡𝑗𝑎_𝑘𝑗≥0. (2.10)

Therefore, it is possible that the choice of entering and leaving variable defined by Step 𝑆4 reduces the number of positive 𝑏's after the application of Algorithm 2.1. Our goal is to obviate the observed disadvantages in Step 𝑆4. For this purpose, we propose a modification of Step 𝑆4, which gives a better heuristic for the choice of basic and nonbasic variables.

Proposition 2.4 (see [13]). Let the problem (2.1) be feasible and let 𝑥 be the basic infeasible solution with 𝑏_𝑖1,…,𝑏_𝑖𝑞<0, 𝑞≤𝑚. Consider the index set 𝐼={𝑖₁,…,𝑖_𝑞}.
The following statements are valid.(1)It is possible to produce a new basic solution 𝑥¹={𝑥¹_𝐵,1,…,𝑥¹_𝐵,𝑚} with at most 𝑞−1 negative coordinates in only one step of the simplex method in the following two cases:(a)𝑞=𝑚,(b)𝑞<𝑚 and there exist 𝑟∈𝐼 and 𝑠∈{1,…,𝑛} such that min_ℎ∉𝐼𝑏_ℎ𝑎_ℎ𝑠∣𝑎_ℎ𝑠≥𝑏>0^𝑟𝑎_𝑟𝑠,𝑎_𝑟𝑠<0. (2.11)(2)It is possible to produce a new basic solution 𝑥¹={𝑥¹_𝐵,1,…,𝑥¹_𝐵,𝑚} with exactly 𝑞 negative coordinates in one step of the simplex method if neither condition (a) nor condition (b) is valid.

Proof. We restate the proof from [13] for the sake of completeness.
(1)  (a)  If 𝑞=𝑚, for an arbitrary pivot element 𝑎_𝑗𝑠<0, we get a new basic solution with at least one positive coordinate: 𝑥¹_𝐵,𝑗=𝑏¹_𝑗=𝑏_𝑗𝑎_𝑗𝑠>0. (2.12) The existence of negative 𝑎_𝑗𝑠 is ensured by the assumption that the problem (2.1) is feasible.
(b)  Now assume that the conditions 𝑞<𝑚, 𝑟∈𝐼, and (2.11) are satisfied. Choose 𝑎_𝑟𝑠 for the pivot element and apply Algorithm 2.1. Choose arbitrary 𝑏_𝑘≥0, 𝑘≠𝑟.
In the case 𝑎_𝑘𝑠<0 it is obvious that 𝑥¹_𝐵,𝑘=𝑏_𝑘−𝑏_𝑟𝑎_𝑟𝑠𝑎_𝑘𝑠≥𝑏_𝑘≥0. (2.13) In the case 𝑎_𝑘𝑠>0, using 𝑏_𝑘/𝑎_𝑘𝑠≥𝑏_𝑟/𝑎_𝑟𝑠, we conclude immediately 𝑥¹_𝐵,𝑘=𝑏¹_𝑘=𝑏_𝑘−𝑏_𝑟𝑎_𝑟𝑠𝑎_𝑘𝑠≥𝑏_𝑘−𝑏_𝑘𝑎_𝑘𝑠𝑎_𝑘𝑠=0. (2.14) On the other hand, for 𝑏_𝑟<0 we obtain from Algorithm 2.1𝑏¹_𝑟=𝑏_𝑟𝑎_𝑟𝑠≥0. (2.15) Therefore, all nonnegative 𝑏_𝑘 remain nonnegative and 𝑏_𝑟<0 becomes nonnegative.
(2)  If neither condition (a) nor condition (b) is valid, let 𝑟∉𝐼 and 𝑠∈{1,…,𝑛} be such that min_ℎ∉𝐼𝑏_ℎ𝑎_ℎ𝑠∣𝑎_ℎ𝑠=𝑏>0^𝑟𝑎_𝑟𝑠. (2.16) By choosing 𝑎_𝑟𝑠 as the pivot element and by applying the transformations defined in Algorithm 2.1 we obtain the same number of negative elements in the vector 𝑏. This fact can be proved similarly as the part 1 (b).

Remark 2.5. From Proposition 2.4 we get three proper selections of the pivot element in Step 𝑆4: (i)arbitrary 𝑎_𝑗𝑠<0 in the case 𝑞=𝑚; (ii)arbitrary 𝑎_𝑟𝑠<0 satisfying (2.11) when the conditions 0<𝑞<𝑚, 𝑟∈𝐼 are satisfied; (iii)arbitrary 𝑎_𝑟𝑠>0 satisfying (2.16) when 0<𝑞<𝑚, and there is no 𝑎_𝑟𝑠<0 satisfying conditions in the previous case.
In accordance with Proposition 2.4 and considerations in Remark 2.5, we propose the following improvement of Algorithm 2.3.

Algorithm 𝑀1 (modification of Algorithm 2.3)
Step 1. If 𝑏₁,…,𝑏_𝑚≥0, perform Algorithm 2.2. Otherwise continue.
Step 2. Select the first 𝑏_𝑖𝑠<0.
Step 3. If 𝑎_𝑖𝑠,1,…,𝑎_{𝑖𝑠,𝑛}≥0, then STOP. LP problem is infeasible.
Otherwise, construct the set 𝑄=𝑎_{𝑖𝑠,𝑗𝑝}<0,𝑝=1,…,𝑡, (2.17) initialize variable 𝑝 by 𝑝=1 and continue.
Step 4. Compute min_{1≤ℎ≤𝑚}𝑏_ℎ𝑎_ℎ,𝑗𝑝∣𝑎_ℎ,𝑗𝑝>0,𝑏_ℎ>0=min_ℎ∉𝐼𝑏_ℎ𝑎_ℎ,𝑗𝑝∣𝑎_ℎ,𝑗𝑝=𝑏>0^𝑟𝑎_{𝑟,𝑗𝑝}. (2.18)
Step 5. If 𝑏_𝑖𝑠/𝑎_{𝑖𝑠,𝑗𝑝}≤𝑏_ℎ/𝑎_ℎ,𝑗𝑝, then interchange entering-nonbasic variable 𝑥_{𝑁,𝑗𝑝} and leaving-basic variable 𝑥_{𝐵,𝑖𝑠} (apply Algorithm 2.1) and go to Step 1. Otherwise go to Step 6.
 Step 6. If 𝑝>𝑡, interchange 𝑥_{𝑁,𝑗𝑝} and 𝑥_𝐵,𝑟 (apply Algorithm 2.1) and go to Step 1. Otherwise, put 𝑝=𝑝+1 and go to Step 3.
Algorithm 𝑀1 chooses one fixed (the first) value 𝑏_𝑖𝑠<0 satisfying conditions of Proposition 2.4. But there may exist some other 𝑏_𝑖<0 such that conditions of Proposition 2.4 are satisfied, and in the next iteration we can obtain a basic solution with smaller number of negative 𝑏's. From that reason, in [13] we gave improved version of Algorithm 𝑀1, named 𝑀2.

Algorithm 𝑀2
Step 1. If 𝑏₁,…,𝑏_𝑚≥0, perform Algorithm 2.2. Otherwise, construct the set 𝐵=𝑖_𝑘∣𝑏_𝑖𝑘<0,𝑘=1,…,𝑞. (2.19)
Step 2. Set 𝑠=1 and perform the following. Step  2.1. If 𝑎_𝑖𝑠,1,…,𝑎_{𝑖𝑠,𝑛}≥0 then STOP. LP problem is infeasible. Otherwise, construct the set 𝑄=𝑎_{𝑖𝑠,𝑗𝑝}<0,𝑝=1,…,𝑡, (2.20) put 𝑝=1, and continue.  Step  2.2. Find the minima: 𝑝^′𝑏=argmin^𝑘𝑎_{𝑘,𝑗𝑝}∣𝑏_𝑘<0,𝑎_{𝑘,𝑗𝑝},𝑀𝑗𝑏<0=min^𝑘𝑎_{𝑘,𝑗𝑝}∣𝑏_𝑘>0,𝑎_{𝑘,𝑗𝑝}>0. (2.21) If 𝑏_𝑘/𝑎_{𝑘,𝑗𝑝}≤𝑀(𝑗_𝑝), then choose 𝑎_{𝑝′,𝑗𝑝} for the pivot element,  apply Algorithm 2.1, and go to Step  1.   (In the next iteration 𝑏_𝑘 becomes positive.)  Step  2.3. If 𝑝<𝑡, then put 𝑝=𝑝+1 and go to Step  2.2,   otherwise continue.   Step  2.4. If 𝑠<𝑞, then put 𝑠=𝑠+1 and go to Step  2.1,   otherwise continue.
Step 3. If 𝑞<𝑚 and there do not exist 𝑟∈𝐼 and 𝑠∈{1,…,𝑛} such that min_ℎ∉𝐼𝑏_ℎ𝑎_ℎ𝑠∣𝑎_ℎ𝑠≥𝑏>0^𝑟𝑎_𝑟𝑠,𝑎_𝑟𝑠<0,thenmovetothefollowing. (2.22)  Step  3.1. Select 𝑗₀=argmin{𝑥_𝑁,𝑙∣𝑎_{𝑖𝑞,𝑙}<0}.  Step  3.2. Compute 𝑝^′′=argmin𝑥_𝐵,𝑝∣𝑏_𝑝𝑎_𝑝,𝑗0=𝑀𝑗₀. (2.23)  Step  3.3. Choose 𝑎_{𝑝′′,𝑗0} for pivot element,  apply Algorithm 2.1, and go to Step  1.
Algorithm 𝑀1 and Algorithm 𝑀2 are well defined. If there is no 𝑏_𝑟<0 such that the condition (2.11) is valid, we choose pivot element according to Remark 2.5 to obtain a solution with the same number of negative 𝑏's. To avoid the cycling in this case, we will present an anticycling rule which is based on the following result from [13].

Proposition 2.6 (see [13]). Assume that there is no 𝑏_𝑟<0 such that the conditions (2.11) of Proposition 2.4 are satisfied. After choosing the pivot element according to (2.16), we obtain a new base where 0>𝑏¹_𝑖≥𝑏_𝑖, holds for all 𝑖∈𝐼.

Since 𝑖_𝑠 in Step 2 of Algorithm 𝑀1 is fixed, Algorithm 𝑀1 may cycle only if 𝑏¹_𝑖𝑠=𝑏_𝑖𝑠. For that reason, if the minimum in (2.18) is not unique, we choose 𝑗_𝑝 according to the Bland's rule which guarantees that the simplex method always terminates [15] and [17, Theorem 3.3]. Therefore, according to Proposition 2.6, finite number of iterations value of 𝑏_𝑖𝑠 will start to increase or we will conclude that the problem is infeasible (𝑎_{𝑖𝑠,𝑗} are positive for all 𝑗=1,…,𝑛).

In the sequel we show that our methods have better performances than the Nabli's NFB method from [11]. Algorithms 𝑀1 and 𝑀2 are implemented in the software package MarPlex, reused from [13] and tested on some standard linear programming test problems.

3. Results of Comparison

We already mentioned that we were motivated with the paper [11] to consider the number of iterations needed to find the starting point. This yields an exact indicator of the quality of the applied linear programming solvers. In the paper [11] that the quotient of the total number of iterations required to determine the initial solution and the number of variables is equal to 0.334581=268/801 for the NFB, 0.483249=439/985 for the two-phase algorithm and 0.445685=476/985 for the Big-M method. It is obvious that the NFB algorithm is better than the Two-phases and the Big-M methods with respect to this criterion.

Note that the results of the paper [11] are obtained on a small sample of test problems in which the number of variables is relatively small. To resolve this drawback, we applied the NFB algorithm to the Netlib collection test problems. In addition, we tested our two algorithms, marked with 𝑀1 and 𝑀2. In this paper we consider the results of practical application of these algorithms in accordance with the methodologies used in the papers [11, 18].

The comparison of different optimization softwares from [11] is based on the number of iterative steps. In the tables below, columns labeled by 𝑛 contain the number of variables in the problem, while the columns marked with NFB, 𝑀1, and 𝑀2 contain the number of iterations that is required for the corresponding algorithm. The names of the Netlib problems are given in the column LP. The number of iterations that are necessary to find initial basic feasible solutions in particular test examples is presented in Table 2.

Table 2 

Number of iterations for generating the initial solutions computation.

The quotient of the total number of iterations required to determine the initial solution Simplex algorithm and the total number of variables is equal to 32856/52509=0.625721 for the NFB algorithm, for the Algorithm 𝑀1 is equal to 27005/52509=0.514293, and for the 𝑀2 method is 16118/52509=0.306957. For the NFB algorithm we get a higher value compared to the result from [11], as consequence of the larger size and the computational effort to solve the tested problems. Algorithm 𝑀1 shows a slightly better efficiency, while 𝑀2 produces significantly smaller quotient.

In Table 3 we give comparative results of the total number of iterations required to solve the same test problems.

Table 3 

The total number of iterations.

From Table 3 it is apparent that 𝑀2 is the best algorithm. It is interesting to note that the 𝑀1 algorithm requires less total number of iterations compared to the NFB, although the Simplex algorithm after applying Algorithm 𝑀1 requires more iterations. Hence the choice of algorithm for determining the starting point is very important for the overall efficiency of the software for solving the LP problems.

From Tables 2 and 3 it follows that the total number of iterations spent in the Simplex algorithm to generate the optimal solution is equal to 15409,16400,14170 for the NFB, 𝑀1, and 𝑀2 methods, respectively. Therefore, it is clear that the total number of iterations required for the initial basic feasible solution is greater than the number of iterations required by the Simplex algorithm to find the optimal solution. This fact is very important, especially if we observe from Table 2 that about 25% of the considered problems are suitable for determining the starting point in one step. Taking into account the results of the paper [11] from which it follows that the number of iterations of the classical two-phase method for determining the starting point is significantly higher than the number of iterations of algorithms that do not introduce artificial variables, the fact becomes more important. This means that finding the starting point represents a very important part in solving LP problems.

The better performances of the 𝑀2 method primarily (and particularly the 𝑀1 method), compared to the NFB method, can also be confirmed by using the so-called performance profile, introduced in [18]. The underlying metric is defined by the number of iterative steps. Following the notations given in the paper [18] we have that the number of solvers is 𝑛_𝑠=3 (the NFB, 𝑀1, and 𝑀2) and the number of numerical experiments is 𝑛_𝑝=49. For the performance metrics we use the number of iterative steps. By 𝑖_𝑝,𝑠 we denote the number of iterations required to solve problem 𝑝 by the solver 𝑠. The quantity 𝑟_𝑝,𝑠=𝑖_𝑝,𝑠min𝑖_𝑝,𝑠∶𝑠∈{NFB,𝑀1,𝑀2} (3.1) is called the performance ratio. Finally, the performance of the solver 𝑠 is defined by the following cumulative distribution function 𝜌_𝑠(𝜏)=1𝑛_𝑝size𝑝∈𝒫∶𝑟_𝑝,𝑠≤𝜏,𝑠∈{NFB,𝑀1,𝑀2}, (3.2) where 𝜏∈ℝ and 𝒫 represents the set of problems. Figure 1 shows the performance profiles for NFB, 𝑀1, and 𝑀2 regarding the number of iterations. Figure 1(a) (resp., Figure 1(b)) illustrates data arranged in Table 2 (resp., Table 3).

(a)

(b)

Figure 1 

(a) Performance profile regarding the number of iterations in Table 2. (b) Performance profile regarding the number of iterations in Table 3.

It is clear from Figure 1(a), that 𝑀1 and 𝑀2 methods show better performances compared to NFB. Comparison of 𝑀1 and 𝑀2 algorithms gives somewhat contradictory results. Namely, the probability of being the optimal solver regarding the number of iterative steps required for generating the starting point is in favor of the 𝑀1 algorithm, which is confirmed by 𝜌_𝑀1(1)=0.64>𝜌_𝑀2(1)=0.60>𝜌_NFB(1)=0.38. On the other hand, the probability 𝜌_𝑀2(𝜏) of Algorithm 𝑀2 is greater than the probability 𝜌_𝑀1(𝜏) for all values 𝜏>1. On the other hand, 𝜌_𝑀2(𝜏)>𝜌_NFB(𝜏) is always satisfied.

From Figure 1(b), it is evident that the inequality 𝜌_𝑀2(𝜏)≥max{𝜌_NFB(𝜏),𝜌_𝑀1(𝜏)} is always satisfied, which means that Algorithm 𝑀2 has the highest probability of being the optimal solver with respect to the total number of iterations required to solve the problem.

In sequel, the total CPU time is the comparison criteria. The required CPU time for NFB, 𝑀1 and 𝑀2 methods is given in Table 4. The time ratio and the number of iteration ratio, of Algorithms 𝑀1 and 𝑀2 with respect to the NFB algorithm are also given in Table 4.

Table 4 

The CPU time, the CPU time ratio, and the number of iteration ratios.

The situation in this case is not quite clear. Namely, comparing the time ratio with respect to the number of iterations ratio given in columns labeled 𝑀1/NFB and 𝑀2/NFB, we conclude the number of required iterations of 𝑀1 and 𝑀2 algorithms for problems czprob, share1b, ship04l, and ship08l is smaller then the number of iterations of NFB algorithm but this is not in accordance with required CPU time ratio. This is the consequence of the greatest number of conditions that must be checked in the 𝑀1 and 𝑀2 algorithms with respect to the NFB algorithm. The difficulties of that type may occur especially when the LP problem has dense matrix. Note that for all others test problems accordance of the number of iterations ratio with respect to the required CPU time ratio does exist.

Figure 2 shows the performance profiles for NFB, 𝑀1, 𝑀2 regarding the required CPU time.

Figure 2 

Performance profiles regarding the CPU time.

It is clear from Figure 2 that the probability of being the optimal solver regarding the CPU time required is in favor of the 𝑀2 algorithm, which is confirmed by the inequalities 𝜌_𝑀2(1)>𝜌_𝑀2(1)>𝜌_NFB(1). On the other hand, further comparison when 𝜏 increases gives contradictory results. Unfortunately, 𝑀2 algorithm is not the best solver for all value 𝜏. In the case 1.5≤𝜏≤4.5 it follows that 𝑀1 algorithm is the best option except for 𝜏=2 when NFB algorithm takes advantage. Further, for 5≤𝜏≤9 we have 𝜌_𝑀2(𝜏)=𝜌_NFB(𝜏)=𝜌_𝑀1(𝜏), which means that the considered solvers are equivalent. Finally, for values 𝜏>9 Algorithm 𝑀2 is the best again.

4. Conclusion

The importance of selecting the starting point is known problem from the linear programming theory. In this paper, we investigated that problem in terms of the number of iterations required to find the initial point and the optimal point as well as in the terms of the required CPU time.

We observed that our Algorithm 𝑀2 achieved the lowest total number of iterations for finding the starting point for the Simplex method as well as the minimal total number of iterations for determining the optimal point. On the other hand, Algorithm 𝑀1 has the highest probability to achieve the minimal number of iterations to find the initial basic feasible solution. Algorithm 𝑀2 has the highest probability of being the optimal solver with respect to the total number of iterations required to solve the problem.

Comparison with respect to the required CPU time gives that the probability of being the optimal solver is in favor of the 𝑀2 algorithm for 𝜏=1 and for 𝜏≥9.5. It is clear that CPU time generally depends on the number of iterations, but it is obvious that there are some others important factors. Further research will be in that direction.

Acknowledgments

The authors would like to thank the anonymous referees for useful suggestions. P. S. Stanimirović, N. V. Stojković, and M. D. Petković gratefully acknowledge support from the Research Project 174013 Serbion Ministry of Education and Science.