Mathematical Problems in EngineeringVolume 2012 (2012), Article ID 482193, 28 pagesdoi:10.1155/2012/482193

Research Article

A Two-Phase Support Method for Solving Linear Programs: Numerical Experiments

Mohand Bentobache1,2 and Mohand Ouamer Bibi²

¹Department of Technology, University of Laghouat, 03000, Algeria²Laboratory of Modelling and Optimization of Systems (LAMOS), University of Bejaia, 06000, Algeria

Received 6 September 2011; Accepted 7 February 2012

Academic Editor: J. Jiang

Copyright © 2012 Mohand Bentobache and Mohand Ouamer Bibi. This is an open access article distributed under the Creative Commons Attribution License, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.

Abstract.

We develop a single artificial variable technique to initialize the primal support method for solving linear programs with bounded variables. We first recall the full artificial basis technique, then we will present the proposed algorithm. In order to study the performances of the suggested algorithm, an implementation under the MATLAB programming language has been developed. Finally, we carry out an experimental study about CPU time and iterations number on a large set of the NETLIB test problems. These test problems are practical linear programs modelling various real-life problems arising from several fields such as oil refinery, audit staff scheduling, airline scheduling, industrial production and allocation, image restoration, multisector economic planning, and data fitting. It has been shown that our approach is competitive with our implementation of the primal simplex method and the primal simplex algorithm implemented in the known open-source LP solver LP_SOLVE.

1. Introduction

Linear programming is a mathematical discipline which deals with solving the problem of optimizing a linear function over a domain delimited by a set of linear equations or inequations. The first formulation of an economical problem as a linear programming problem is done by Kantorovich (1939, [1]), and the general formulation is given later by Dantzig in his work [2]. LP is considered as the most important technique in operations research. Indeed, it is widely used in practice, and most of optimization techniques are based on LP ones. That is why many researchers have given a great interest on finding efficient methods to solve LP problems. Although some methods exist before 1947 [1], they are restricted to solve some particular forms of the LP problem. Being inspired from the work of Fourier on linear inequalities, Dantzig (1947, [3]) developed the simplex method which is known to be very efficient for solving practical linear programs. However, in 1972, Klee and Minty [4] have found an example where the simplex method takes an exponential time to solve it.

In 1977, Gabasov and Kirillova [5] have generalized the simplex method and developed the primal support method which can start by any basis and any feasible solution and can move to the optimal solution by interior points or boundary points. The latter is adapted by Radjef and Bibi to solve LPs which contain two types of variables: bounded and nonnegative variables [6]. Later, Gabasov et al. developed the adaptive method to solve, particularly, linear optimal control problems [7]. This method is extended to solve general linear and convex quadratic problems [8–18]. In 1979, Khachian developed the first polynomial algorithm which is an interior point one to solve LP problems [19], but it’s not efficient in practice. In 1984, Karmarkar presented for the first time an interior point algorithm competitive with the simplex method on large-scale problems [20].

The efficiency of the simplex method and its generalizations depends enormously on the first initial point used for their initialization. That is why many researchers have given a new interest for developing new initialization techniques. These techniques aim to find a good initial basis and a good initial point and use a minimum number of artificial variables to reduce memory space and CPU time. The first technique used to find an initial basic feasible solution for the simplex method is the full artificial basis technique [3]. In [21, 22], the authors developed a technique using only one artificial variable to initialize the simplex method. In his experimental study, Millham [23] shows that when the initial basis is available in advance, the single artificial variable technique can be competitive with the full artificial basis one. Wolfe [24] has suggested a technique which consists of solving a new linear programming problem with a piecewise linear objective function (minimization of the sum of infeasibilities). In [25–31], crash procedures are developed to find a good initial basis.

In [32], a two-phase support method with one artificial variable for solving linear programming problems was developed. This method consists of two phases and its general principle is the following: in the first phase, we start by searching an initial support with the Gauss-Jordan elimination method, then we proceed to the search of an initial feasible solution by solving an auxiliary problem having one artificial variable and an obvious feasible solution. This obvious feasible solution can be an interior point of the feasible region. After that, in the second phase, we solve the original problem with the primal support method [5].

In [33, 34], we have suggested two approaches to initialize the primal support method with nonnegative variables and bounded variables: the first approach consists of applying the Gauss elimination method with partial pivoting to the system of linear equations corresponding to the main constraints and the second consists of transforming the equality constraints to inequality constraints. After finding the initial support, we search a feasible solution by adding only one artificial variable to the original problem, thus we get an auxiliary problem with an evident support feasible solution. An experimental study has been carried out on some NETLIB test problems. The results of the numerical comparison revealed that finding the initial support by the Gauss elimination method consumes much time, and transforming the equality constraints to inequality ones increases the dimension of the problem. Hence, the proposed approaches are competitive with the full artificial basis simplex method for solving small problems, but they are not efficient to solve large problems.

In this work, we will first extend the full artificial basis technique presented in [7], to solve problems in general form, then we will combine a crash procedure with a single artificial variable technique in order to find an initial support feasible solution for the initialization of the support method. This technique is efficient for solving practical problems. Indeed, it takes advantage of sparsity and adds a reduced number of artificial variables to the original problem. Finally, we show the efficiency of our approach by carrying out an experimental study on some NETLIB test problems.

The paper is organized as follows: in Section 2, the primal support method for solving linear programming problems with bounded variables is reviewed. In Section 3, the different techniques to initialize the support method are presented: the full artificial basis technique and the single artificial variable one. Although the support method with full artificial basis is described in [7], it has never been tested on NETLIB test problems. In Section 4, experimental results are presented. Finally, Section 5 is devoted to the conclusion.

2. Primal Support Method with Bounded Variables

2.1. State of the Problem and Definitions

The linear programming problem with bounded variables is presented in the following standard form: where and are -vectors; an -vector; an -matrix with ; and are -vectors. In the following sections, we will assume that and . We define the following index sets: So we can write and partition the vectors and the matrix as follows: (i)A vector verifying constraints (2.2) and (2.3) is called a feasible solution for the problem (2.1)–(2.3).(ii)A feasible solution is called optimal if , where is taken from the set of all feasible solutions of the problem (2.1)–(2.3).(iii) A feasible solution is said to be -optimal or suboptimal if where is an optimal solution for the problem (2.1)–(2.3), and is a positive number chosen beforehand.(iv)We consider the set of indices such that . Then is called a support if .(v)The pair comprising a feasible solution and a support will be called a support feasible solution (SFS).(vi)An SFS is called nondegenerate if .

Remark 2.1. An SFS is a more general concept than the basic feasible solution (BFS). Indeed, the nonsupport components of an SFS are not restricted to their bounds. Therefore, an SFS may be an interior point, a boundary point or an extreme point, but a BFS is always an extreme point. That is why we can classify the primal support method in the class of interior search methods within the simplex framework [35].

(i)We define the Lagrange multipliers vector and the reduced costs vector as follows:

where .

Theorem 2.2 (the optimality criterion [5]). Let be an SFS for the problem (2.1)–(2.3). So the relations: are sufficient and, in the case of nondegeneracy of the SFS , also necessary for the optimality of the feasible solution .

The quantity defined by: is called the suboptimality estimate. Thus, we have the following theorem [5].

Theorem 2.3 (sufficient condition for suboptimality). Let be an SFS for the problem (2.1)–(2.3) and an arbitrary positive number. If , then the feasible solution is -optimal.

2.2. The Primal Support Method

Let be an initial SFS and an arbitrary positive number. The scheme of the primal support method is described in the following steps:(1)Compute ; .(2)Compute with the formula (2.9).(3)If , then the algorithm stops with , an optimal SFS.(4)If , then the algorithm stops with , an -optimal SFS.(5)Determine the nonoptimal index set: (6)Choose an index from such that .(7)Compute the search direction using the relations: (8)Compute , where is determined by the formula: (9)Compute using the formula (10)Compute .(11)Compute , .(12)Compute .(13)If , then the algorithm stops with , an optimal SFS.(14)If , then the algorithm stops with , an -optimal SFS.(15)If , then we put .(16)If , then we put .(17)We put and . Go to the step (1).

3. Finding an Initial SFS for the Primal Support Method

Consider the linear programming problem written in the following general form: where , , , are vectors in ; is a matrix of dimension , is a matrix of dimension , , . We assume that and .

Let be the number of constraints of the problem (3.1) and , are, respectively, the constraints indices set and the original variables indices set of the problem (3.1). We partition the set as follows: , where and represent, respectively, the indices set of inequality and equality constraints. We note by the -vector of ones, that is, and the vector of the identity matrix of order .

After adding slack variables to the problem (3.1), we get the following problem in standard form: where , , is the vector of the added slack variables and its upper bound vector. In order to work with finite bounds, we set , , that is, , where is a finite, positive and big real number chosen carefully.

Remark 3.1. The upper bounds, , , of the added slack variables can also be deduced as follows:, where is a -vector computed with the formula Indeed, from the system (3.3), we have , . By using the bound constraints (3.4), we get , . However, the experimental study shows that it’s more efficient to set , to a given finite big value, because for the large-scale problems, the deduction formula (3.6) given above takes much CPU time to compute bounds for the slack variables.

The initialization of the primal support method consists of finding an initial support feasible solution for the problem (3.2)–(3.5). In this section, being inspired from the technique used to initialize interior point methods [36] and taking into account, the fact that the support method can start with a feasible point and a support which are independent, we suggest a single artificial variable technique to find an initial SFS. Before presenting the suggested technique, we first extend the full artificial basis technique, originally presented in [7] for standard form, to solve linear programs presented in the general form (3.1).

3.1. The Full Artificial Basis Technique

Let be a -vector chosen between and and an -vector such that . We consider the following subsets of : , , and we assume without loss of generality that , with and . Remark that and form a partition of ; and .

We make the following partition for , and : , where

, where and , where Hence, the problem (3.2)–(3.5) becomes

After adding artificial variables to the equations of the system (3.11), where is the number of elements of the artificial index set , we get the following auxiliary problem: where represents the artificial variables vector, where is a real nonnegative number chosen in advance.

If we put , , , , , , , , , then we get the following auxiliary problem: The variables indices set of the auxiliary problem (3.17)–(3.19) is Let us partition this set as follows: , where Remark that the pair , where with and , is a support feasible solution (SFS) for the auxiliary problem (3.17)–(3.19). Indeed, lies between its lower and upper bounds: for we have Furthermore, the -matrix is invertible because and verifies the main constraints: by replacing , , , and with their values in the system (3.18), we get Therefore, the primal support method can be initialized with the SFS to solve the auxiliary problem. Let be the obtained optimal SFS after the application of the primal support method to the auxiliary problem (3.17)–(3.19), where If , then the original problem (3.2)–(3.5) is infeasible.

Else, when does not contain any artificial index, then will be an SFS for the original problem (3.2)–(3.5). Otherwise, we delete artificial indices from the support , and we replace them with original or slack appropriate indices, following the algebraic rule used in the simplex method.

In order to initialize the primal support method for solving linear programming problems with bounded variables written in the standard form, in [7], Gabasov et al. add artificial variables, where represents the number of constraints. In this work, we are interested in solving the problem written in the general form (3.1), so we have added artificial variables only for equality constraints and inequality constraints with negative components of the vector .

Remark 3.2. We have . Since in the relationship (3.22), we have and, we get .

Remark 3.3. If we choose such that or , then the vector , given by the relationship (3.22), will be a BFS. Hence, the simplex algorithm can be initialized with this point.

Remark 3.4. If , and , two cases can occur.

Case 1. If , then we put .

Case 2. If , then we put , and .In the two cases, we get , , therefore . Hence , so we add only artificial variables for the equality constraints.

3.2. The Single Artificial Variable Technique

In order to initialize the primal support method using this technique, we first start by searching an initial support, then we proceed to the search of an initial feasible solution for the original problem.

The application of the Gauss elimination method with partial pivoting to the system of equations (3.3) can give us a support , where . However, the experimental study realized in [33, 34] reveals that this approach takes much time in searching the initial support, that is, why it’s important to take into account the sparsity property of practical problems and apply some procedure to find a triangular basis among the columns corresponding to the original variables, that is, the columns of the matrix . In this work, on the base of the crash procedures presented in [26, 28–30], we present a procedure to find an initial support for the problem (3.2)–(3.5).

Procedure 1 (searching an initial support). (1) We sort the columns of the matrix according to the increasing order of their number of nonzero elements. Let be the list of the sorted columns of .(2) Let (the column of L) be the first column of the list verifying: such that where is a given tolerance. Hence, we put , , .(3) Let be the index corresponding to the column of the list , that is, . If has zero elements in all the rows having indices in and if such that then we put , .(4) We put . If , then go to step (3), else go to step (5).(5) We put , , .(6) For all , if the constraint is originally an inequality constraint, then we add to an index corresponding to the slack variable , that is, . If the constraint is originally an equality constraint, then we put and add to this latter an artificial variable for which we set the lower bound to zero and the upper bound to a big and well-chosen value . Thus, we put , , .

Remark 3.5. The inputs of Procedure 1 are:(i)the -matrix of constraints, ;(ii)a pivoting tolerance fixed beforehand, ;(iii)a big and well chosen value . The outputs of Procedure 1 are:(i): the initial support for the problem (3.2)–(3.5);(ii): the indices of the constraints for which we have added artificial variables;(iii): the indices of artificial variables added to the problem (3.2)–(3.5);(iv): the number of artificial variables added to the problem (3.2)–(3.5).

After the application of the procedure explained above (Procedure 1) for the problem (3.2)–(3.5), we get the following linear programming problem: where is the -vector of the artificial variables added during the application of Procedure 1, with , is an -matrix.

Since we have got an initial support, we can start the procedure of finding a feasible solution for the original problem.

Procedure 2 (searching an initial feasible solution). Consider the following auxiliary problem: where is an artificial variable, , and is a -vector chosen between and . We remark that is an obvious feasible solution for the auxiliary problem. Indeed, Hence, we can apply the primal support method to solve the auxiliary problem (3.31) by starting with the initial SFS , where is the support obtained with Procedure 1. Let be, respectively, the optimal solution, the optimal support, and the optimal objective value of the auxiliary problem (3.31).If , then the original problem (3.2)–(3.5) is infeasible.Else, when does not contain any artificial index, then will be an SFS for the original problem (3.2)–(3.5). Otherwise, we delete the artificial indices from the support and we replace them with original or slack appropriate indices, following the algebraic rule used in the simplex method.

Remark 3.6. The number of artificial variables of the auxiliary problem (3.31) verifies the inequality: .The auxiliary problem will have only one artificial variable, that is, , when the initial support found by Procedure 1 is constituted only by the original and slack variable indices (), and this will hold in two cases.

Case 1. When all the constraints are inequalities, that is, .

Case 2. When and step (4) of Procedure 1 ends with .The case holds when the step (4) of Procedure 1 stops with .

Remark 3.7. Let’s choose a -vector between and and two nonnegative vectors and . If we put in the auxiliary problem (3.31), , with , then the vector is a feasible solution for the auxiliary problem. Indeed, We remark that if we put , we get , then and we obtain the evident feasible point that we have used in our numerical experiments, that is, It’s important here, to cite two other special cases.Case 1. If we choose the nonbasic components of equal to their bounds, then we obtain a BFS for the auxiliary problem, therefore we can initialize the simplex algorithm with it.Case 2. If we put and , then . Hence, the vector is a feasible solution for the auxiliary problem (3.31), with .

Numerical ExampleConsider the following LP problem: where We put , and we apply the two-phase primal support method using the single artificial variable technique to solve the problem (3.39).

Phase 1. After adding the slack variables and to the problem (3.39), we get the following problem in standard form: where The application of Procedure 1 to the problem (3.41) gives us the following initial support: . In order to find an initial feasible solution to the original problem, we add an artificial variable to problem (3.41), and we compute the vector : . Thus, we obtain the following auxiliary problem: Remark that the SFS , where , and is an obvious support feasible solution for the auxiliary problem. Hence, the primal support method can be applied to solve the problem (3.43) starting with the SFS .

Iteration 1. The initial support is , ; the initial feasible solution and the corresponding objective function value are: and .The vector of multipliers is , and . Hence, the reduced costs vector is .The suboptimality estimate is . So the current solution is not optimal. The set of nonoptimal indices is .In order to improve the objective function, we compute the search direction : we have , so ; . Hence, the search direction is .Since , . So , , and . Hence, the primal step length is . The new solution is , and the new objective value is is optimal for the auxiliary problem. Therefore, the pair , where and , is an SFS for the problem (3.41).

Phase 2. Iteration 1. The initial support is , and .The initial feasible solution is , and the objective value is .The multipliers vector and the reduced costs vector are: and . The suboptimality estimate is . So the initial solution is not optimal.The set of nonoptimal indices is the entering index is .The search direction is .The primal step length is . So the leaving index is . The new solution is , and .Iteration 2. The current support is , and .The current feasible solution is , and the objective value is .The multipliers vector and the reduced costs vector are: and . The suboptimality estimate is .Therefore, the optimal solution and the optimal objective value of the original problem (3.39) are

4. Experimental Results

In order to perform a numerical comparison between the simplex method and the different variants of the support method, we have programmed them under the MATLAB programming language version 7.4.0 (R2007a).

Since the test problems available in the NETLIB library present bounds on the variables which can be infinite, we have built a sample of 68 test problems having finite bounds and a same optimal objective value as those of NETLIB. The principle of the building process is as follows: let and be the obtained bounds after the conversion of a given test problem from the “mps” format to the “mat” format and the optimal solution. We put and . Thus, the constraint matrix and the objective coefficients vector of the new problem remains the same as those of NETLIB, but the new lower bounds and upper bounds will be changed as follows: Table 1 represents the listing of the main characteristics of the considered 68 test problems, where NC, NV, NEC, and represent, respectively, the number of constraints, the number of variables, the number of equality constraints, and the density of the constraints matrix (the ratio between the number of nonzero elements and the number of total elements of the constraints matrix, multiplied by 100).

Table 1: Characteristics of the test problems.

LP

LP

(1) afiro
27
32
8
9,61
(35) fffff800
524
854
350
1,39

(2) kb2
43
41
16
16,20
(36) grow22
440
946
440
1,98

(3) sc50a
50
48
20
5,42
(37) standata
359
1075
160
0,79

(4) sc50b
50
48
20
4,92
(38) scsd6
147
1350
147
2,17

(5) adlittle
56
97
15
7,05
(39) standmps
467
1075
268
0,73

(6) blend
74
83
43
7,99
(40) standgub
361
1184
162
0,73

(7) share2b
96
79
13
9,15
(41) scfxm2
660
914
374
0,86

(8) sc105
105
103
45
2,59
(42) scrs8
490
1169
384
0,56

(9) stocfor1
117
111
63
3,44
(43) gfrd-pnc
616
1092
548
0,35

(10) scagr7
129
140
84
2,33
(44) bnl1
643
1175
232
0,68

(11) israel
174
142
0
9,18
(45) ship04s
402
1458
354
0,74

(12) share1b
117
225
89
4,37
(46) fit1p
627
1677
627
0,94

(13) vtpbase
198
203
55
2,26
(47) modszk1
687
1620
687
0,29

(14) sc205
205
203
91
1,32
(48) shell
536
1775
534
0,37

(15) beaconfd
173
262
140
7,45
(49) scfxm3
990
1371
561
0,57

(16) grow7
140
301
140
6,20
(50) 25fv47
821
1571
516
0,81

(17) lotfi
153
308
95
2,29
(51) ship04l
402
2118
354
0,74

(18) brandy
220
249
166
3,92
(52) wood1p
244
2594
243
11,10

(19) e226
223
282
33
4,10
(53) sctap2
1090
1880
470
0,33

(20) bore3d
233
315
214
1,95
(54) ganges
1309
1681
1284
0,31

(21) capri
271
353
142
1,85
(55) scsd8
397
2750
397
0,79

(22) agg
488
163
36
3,03
(56) ship08s
778
2387
698
0,38

(23) scorpion
388
358
280
1,03
(57) ship12s
1151
2763
1045
0,26

(24) bandm
305
472
305
1,73
(58) ctap3
1480
2480
620
0,24

(25) sctap1
300
480
120
1,18
(59) stocfor2
2157
2031
1143
0,19

(26) scfxm1
330
457
187
1,72
(60) czprob
929
3523
890
0,33

(27) agg2
516
302
60
2,75
(61) ship08l
778
4283
698
0,38

(28) agg3
516
302
60
2,76
(62) bnl2
2324
3489
1327
0,17

(29) stair
356
467
209
2,32
(63) ship12l
1151
5427
1045
0,26

(30) scsd1
77
760
77
4,08
(64) d2q06c
2171
5167
1507
0,29

(31) grow15
300
645
300
2,90
(65) woodw
1098
8405
1085
0,41

(32) scagr25
471
500
300
0,66
(66) truss
1000
8806
1000
0,32

(33) fit1d
24
1026
1
54,40
(67) fit2d
25
10500
1
49,10

(34) finnis
497
614
47
0,76
(68) maros-r7
3136
9408
3136
0,49

There exist many LP solvers which include a primal simplex algorithm package for solving LP problems, we cite: commercial solvers such as CPLEX [37], MINOS [28] and open-source solvers such as LP_SOLVE [38], GLPK [39], and LPAKO [30]. The LP_SOLVE solver is well documented and widely used in applications and numerical experiments [40, 41]. Moreover, the latter has a mex interface called mxlpsolve which can be easily installed and used with the MATLAB language. That is why we compare our algorithm with the primal simplex algorithm implemented in LP_SOLVE. However, MATLAB is an interpreted language, so it takes much time in solving problems than the native language C++ used for the implementation of LP_SOLVE. For this reason, the numerical comparison carried out between our method and LP_SOLVE concerns only the iterations number. In order to compare our algorithm with the primal simplex algorithm in terms of CPU time, we have developed our own simplex implementation. The latter is based on the one given in [42].

In order to compare the different solvers, we have given them the following names.

Solver1. SupportSavThe two-phase support method, where we use the suggested single artificial variable technique in the first phase, that is, the initial support is found by applying Procedure 1, and the feasible solution is found by applying Procedure 2.

Solver2. SupportFabThe two-phase support method, where we use the full artificial basis technique presented above in the first phase.

Solver3. SimplexFabThe two-phase primal simplex method, where we use the full artificial basis technique presented above in the first phase (we use the BFS presented in Remark 3.3, with ).

Solver4. LP_Solve_PSAThe primal simplex method implemented in the open-source LP solver LP_SOLVE. The different options are (Primal-Primal, PRICER_DANTZIG, No Scaling, No Presolving). For setting these options, the following MATLAB commands are used.(i)mxlpsolve(“set_simplextype”, lp, 5); (Phase 1: Primal, Phase 2: Primal).(ii)mxlpsolve(“set_pivoting”, lp, 1); (Dantzig’s rule).(iii)mxlpsolve(“set_scaling”, lp, 0); (No scaling).

The Lagrange multipliers vector and the basic components of the search direction in the first three solvers are computed by solving the two systems of linear equations: and , using the factorization of [43]. The updating of the and factors is done, in each iteration, using the Sherman-Morrison-Woodbury formula [42].

In the different implementations, we have used the Dantzig’s rule to choose the entering variable. To prevent cycling, the EXPAND procedure [44] is used.

We have solved the 68 NETLIB test problems listed in Table 1 with the solvers mentioned above on a personal computer with Intel (R) Core (TM) 2 Quad CPU Q6600 2.4 GHz, 4 GB of RAM, working under the Windows XP SP2 operating system, by setting the different tolerances appropriately. We recall that the initial point , needed in the three methods (Solvers 1, 2 and 3), must be located between its lower and upper bounds, so after giving it some values and observing the variation of the CPU time, we have concluded that it’s more efficient to set . The upper bounds for the slack and artificial variables added for the methods SupportSav, SupportFab, and SimplexFab are put to .

Numerical results are reported in Tables 2, 3, 4, and 5, where nit₁, nit, and cput represent respectively the phase one iterations number, the total iterations number, and the CPU time in seconds of each method necessary to find the optimal objective values presented in [25] or [45]; cput₁, shown in columns 2 and 7 of Table 2, represents the CPU time necessary to find the initial support with Procedure 1. The number of artificial variables added to the original problem in our implementations is listed in Table 6.

Table 2: CPU time and iterations number for Solver1 (SupportSav).

LP

LP

afiro
0,00
0,02
15
18
fffff800
0,14
4,75
1339
1707

kb2
0,00
0,05
29
95
grow22
0,42
2,70
18
917

sc50a
0,00
0,02
27
38
standata
0,11
2,19
635
806

sc50b
0,03
0,05
19
33
scsd6
0,05
1,17
87
425

adlittle
0,02
0,08
25
118
standmps
0,16
3,17
998
1064

blend
0,00
0,05
59
81
standgub
0,11
2,09
616
741

share2b
0,00
0,11
134
170
scfxm2
0,27
4,02
990
1344

sc105
0,02
0,06
61
84
scrs8
0,44
2,27
173
707

stocfor1
0,02
0,06
56
74
gfrd-pnc
0,66
2,92
510
929

scagr7
0,02
0,11
114
138
bnl1
0,31
13,78
3541
3902

israel
0,02
0,59
272
589
ship04s
0,05
1,44
324
455

share1b
0,02
0,38
300
450
fit1p
0,88
3,36
4
673

vtpbase
0,03
1,03
942
989
modszk1
0,91
6,83
322
1759

sc205
0,08
0,23
128
169
shell
0,47
2,20
280
525

beaconfd
0,06
0,23
133
161
scfxm3
0,61
9,20
1546
2137

grow7
0,05
0,27
18
229
25fv47
0,33
62,47
5376
12998

lotfi
0,03
0,27
79
228
ship04l
0,08
2,20
324
521

brandy
0,03
0,58
419
461
wood1p
0,05
3,17
383
450

e226
0,05
0,89
165
690
sctap2
1,48
6,09
220
1015

bore3d
0,06
0,23
97
140
ganges
1,83
8,66
1311
1645

capri
0,06
1,05
636
741
scsd8
0,34
3,50
212
643

agg
0,05
0,22
72
127
ship08s
0,17
4,42
656
848

scorpion
0,09
0,64
288
316
ship12s
0,31
8,30
968
1309

bandm
0,13
1,03
360
630
sctap3
2,73
10,08
251
1237

sctap1
0,13
0,61
129
340
stocfor2
4,08
17,31
1325
2061

scfxm1
0,09
1,05
455
620
czprob
0,13
23,55
2477
3373

agg2
0,09
0,38
40
169
ship08l
0,17
8,23
656
1026

agg3
0,09
0,41
36
178
bnl2
4,19
88,17
3256
8840

stair
0,13
1,33
452
701
ship12l
0,38
17,36
979
1679

scsd1
0,02
0,31
48
188
d2q06c
5,14
643,03
6625
46311

grow15
0,20
1,23
18
573
woodw
1,31
49,59
2107
3003

scagr25
0,19
0,89
309
414
truss
2,25
153,02
448
9241

fit1d
0,03
3,36
14
1427
fit2d
0,16
290,91
11
13593

finnis
0,17
2,41
343
994
maros-r7
21,30
100,34
1757
3480

Table 3: CPU time and iterations number for Solver2 (SupportFab).

LP

LP

afiro
0,02
10
18
fffff800
4,48
1334
1659

kb2
0,06
84
143
grow22
3,59
442
1427

sc50a
0,02
26
49
standata
1,22
427
479

sc50b
0,02
26
52
scsd6
1,50
203
554

adlittle
0,09
35
127
standmps
2,00
667
718

blend
0,06
92
118
standgub
1,28
419
470

share2b
0,08
96
129
scfxm2
5,16
1384
1772

sc105
0,06
56
112
scrs8
3,09
620
1112

stocfor1
0,05
64
82
gfrd-pnc
3,11
719
1095

scagr7
0,19
242
285
bnl1
11,23
2752
3235

israel
0,36
9
346
ship04s
1,67
479
535

share1b
0,33
241
394
fit1p
12,47
1625
3067

vtpbase
1,02
951
1001
modszk1
8,59
1038
2325

sc205
0,22
112
232
shell
2,78
568
757

beaconfd
0,17
138
170
scfxm3
10,39
1853
2464

grow7
0,36
142
337
25fv47
50,19
3562
10694

lotfi
0,28
150
261
ship04l
3,27
706
789

brandy
0,66
520
566
wood1p
3,06
351
426

e226
0,94
160
757
sctap2
7,78
896
1452

bore3d
0,33
226
282
ganges
9,58
1637
1979

capri
0,91
527
678
scsd8
7,48
556
1432

agg
0,19
77
118
ship08s
5,73
913
1125

scorpion
0,73
378
423
ship12s
9,48
1334
1478

bandm
2,22
1095
1339
sctap3
13,50
1183
1902

sctap1
0,59
292
375
stocfor2
11,23
1144
1655

scfxm1
1,17
552
723
czprob
17,91
1647
2544

agg2
0,28
78
169
ship08l
14,63
1404
1806

agg3
0,33
80
181
bnl2
123,72
7209
12614

stair
2,17
860
1128
ship12l
28,77
2463
2719

scsd1
0,38
81
226
d2q06c
644,20
9240
45670

grow15
1,53
301
843
woodw
45,80
1916
2752

scagr25
4,05
1834
2129
truss
180,47
1320
11069

fit1d
3,52
10
1469
fit2d
297,03
11
13574

finnis
2,41
395
1083
maros-r7
137,19
4519
5612

Table 4: CPU time and iterations number for Solver3 (SimplexFab).

LP

LP

afiro
0,02
10
18
fffff800
5,38
1513
1920

kb2
0,05
68
125
grow22
3,38
441
1366

sc50a
0,02
26
51
standata
5,45
2609
2646

sc50b
0,03
26
52
scsd6
1,31
203
524

adlittle
0,06
33
123
standmps
7,19
3217
3232

blend
0,06
91
117
standgub
5,81
2610
2627

share2b
0,08
96
131
scfxm2
4,88
1245
1602

sc105
0,08
56
112
scrs8
2,69
529
975

stocfor1
0,05
64
82
gfrd-pnc
3,05
672
1035

scagr7
0,23
276
318
bnl1
11,06
2718
3100

israel
0,34
9
348
ship04s
1,69
479
534

share1b
0,33
234
383
fit1p
11,98
1716
3001

vtpbase
3,03
3921
4145
modszk1
8,47
1100
2275

sc205
0,22
111
224
shell
4,72
646
1507

beaconfd
0,17
138
170
scfxm3
10,55
1901
2420

grow7
0,34
141
317
25fv47
41,23
3350
8974

lotfi
0,22
155
235
ship04l
3,23
709
784

brandy
0,75
501
569
wood1p
3,11
355
426

e226
0,89
156
713
sctap2
7,88
894
1494

bore3d
0,52
431
486
ganges
9,95
1657
1991

capri
4,19
3769
3917
scsd8
6,27
536
1276

agg
0,20
88
133
ship08s
5,77
912
1121

scorpion
0,73
373
417
ship12s
9,66
1333
1477

bandm
2,13
1034
1251
sctap3
13,22
1176
1879

sctap1
0,63
295
374
stocfor2
11,55
1144
1635

scfxm1
1,08
513
656
czprob
20,03
2164
3027

agg2
0,30
76
167
ship08l
14,36
1404
1800

agg3
0,30
79
179
bnl2
131,38
6782
12918

stair
2,78
1216
1475
ship12l
28,69
2462
2715

scsd1
0,34
81
236
d2q06c
539,45
8708
39227

grow15
1,47
301
816
woodw
41,14
1844
2550

scagr25
3,08
1299
1563
truss
150,53
1359
9845

fit1d
3,06
10
1420
fit2d
275,03
11
13535

finnis
2,53
520
1190
maros-r7
132,11
4434
5477

Table 5: Iterations number for Solver4 (LP_SOLVE_PSA).

LP

LP

LP

LP

afiro
17
brandy
1215
fffff800
1771
wood1p
352

kb2
96
e226
909
grow22
1369
sctap2
1465

sc50a
50
bore3d
193
standata
221
ganges
1893

sc50b
51
capri
835
scsd6
594
scsd8
6165

adlittle
172
agg
583
standmps
454
ship08s
702

blend
129
scorpion
386
standgub
210
ship12s
1249

share2b
185
bandm
1040
scfxm2
1272
sctap3
1864

sc105
105
sctap1
359
scrs8
1170
stocfor2
3317

stocfor1
124
scfxm1
592
gfrd-pnc
895
czprob
3422

scagr7
184
agg2
597
bnl1
3810
ship08l
1153

israel
606
agg3
634
ship04s
485
bnl2
9579

share1b
379
stair
936
fit1p
2873
ship12l
2197

vtpbase
782
scsd1
249
modszk1
1736
d2q06c
39828

sc205
250
grow15
987
shell
754
woodw
2179

beaconfd
110
scagr25
898
scfxm3
1962
truss
14046

grow7
328
fit1d
2196
25fv47
12767
fit2d
14249

lotfi
296
finnis
999
ship04l
733
maros-r7
4474

Table 6: The number of artificial variables added in Phase one of the three Solvers.

LP
Solver1
Solver2
Solver3
LP
Solver1
Solver2
Solver3

afiro
7
8
8
fffff800
304
384
384

kb2
7
16
16
grow22
17
440
440

sc50a
19
20
20
standata
121
171
171

sc50b
15
20
20
scsd6
20
147
147

adlittle
9
16
16
standmps
229
279
279

blend
33
43
43
standgub
122
173
173

share2b
10
13
13
scfxm2
247
374
374

sc105
41
45
45
scrs8
65
386
386

stocfor1
50
63
63
gfrd-pnc
89
548
548

scagr7
47
91
91
bnl1
171
239
239

israel
1
8
8
ship04s
355
354
354

share1b
62
89
89
fit1p
1
627
627

vtpbase
40
81
81
modszk1
112
687
687

sc205
82
91
91
shell
151
534
534

beaconfd
100
140
140
scfxm3
370
561
561

grow7
17
140
140
25fv47
417
520
520

lotfi
34
95
95
ship04l
355
354
354

brandy
127
166
166
wood1p
234
244
244

e226
28
46
46
sctap2
1
521
521

bore3d
103
214
214
ganges
678
1284
1284

capri
125
170
170
scsd8
45
397
397

agg
1
63
63
ship08s
699
698
698

scorpion
245
333
333
ship12s
1046
1045
1045

bandm
138
305
305
sctap3
1
682
682

sctap1
1
154
154
stocfor2
889
1143
1143

scfxm1
124
187
187
czprob
870
890
890

agg2
1
60
60
ship08l
699
698
698

agg3
3
60
60
bnl2
864
1335
1335

stair
86
301
301
ship12l
1046
1045
1045

scsd1
13
77
77
d2q06c
558
1533
1533

grow15
17
300
300
woodw
608
1089
1089

scagr25
173
325
325
truss
62
1000
1000

fit1d
2
1
1
fit2d
2
1
1

finnis
24
129
129
maros-r7
1
3136
3136

Sum

13234
27389
27389

In order to compare the different solvers, we have ordered the problems according to the increasing order of the sum of the constraints and variables numbers (NC+NV), as they are presented in the different tables and we have computed the CPU time ratio (Table 7) and the iteration ratio (Table 8) of the different solvers over the solver SupportSav (Solver1), where for each test problem, we have The above ratios (see [46]) indicate how many times SupportSav is better than the other solvers. Ratios greater than one mean that our method is more efficient for the considered problem: let S be one of the solvers 2, 3, and 4. If , (resp., ), then our solver (Solver1) is competitive with SolverS in terms of CPU time, (resp., in terms of iterations number). Ratios greater or equal to one are mentioned with the bold character in Tables 7 and 8.

Table 7: CPU time ratio of the different solvers over SupportSav.

LPRatio

LPRatio

afiro
1,000
1,000
fffff800
0,943
1,133

kb2
1,200
1,000
grow22
1,330
1,252

sc50a
1,000
1,000
standata
0,557
2,489

sc50b
0,400
0.600
scsd6
1,282
1,120

adlittle
1,125
0,750
standmps
0,631
2,268

blend
1,200
1,200
standgub
0,612
2,780

share2b
0,727
0,727
scfxm2
1,284
1,214

sc105
1,000
1,333
scrs8
1,361
1,185

stocfor1
0,833
0,833
gfrd-pnc
1,065
1,045

scagr7
1,727
2,091
bnl1
0,815
0,803

israel
0,610
0,576
ship04s
1,160
1,174

share1b
0,868
0,868
fit1p
3,711
3,565

vtpbase
0,990
2,942
modszk1
1,258
1,240

sc205
0,957
0,957
shell
1,264
2,145

beaconfd
0,739
0,739
scfxm3
1,129
1,147

grow7
1,333
1,259
25fv47
0,803
0,660

lotfi
1,037
0,815
ship04l
1,486
1,468

brandy
1,138
1,293
wood1p
0,965
0,981

e226
1,056
1,000
sctap2
1,278
1,294

bore3d
1,435
2,261
ganges
1,106
1,149

capri
0,867
3,990
scsd8
2,137
1,791

agg
0,864
0,909
ship08s
1,296
1,305

scorpion
1,141
1,141
ship12s
1,142
1,164

bandm
2,155
2,068
sctap3
1,339
1,312

sctap1
0,967
1,033
stocfor2
0,649
0,667

scfxm1
1,114
1,029
czprob
0,761
0,851

agg2
0,737
0,789
ship08l
1,778
1,745

agg3
0,805
0,732
bnl2
1,403
1,490

stair
1,632
2,090
ship12l
1,657
1,653

scsd1
1,226
1,097
d2q06c
1,002
0,839

grow15
1,244
1,195
woodw
0,924
0,830

scagr25
4,551
3,461
truss
1,179
0,984

fit1d
1,048
0,911
fit2d
1,021
0,945

finnis
1,000
1,050
maros-r7
1,367
1,317

Mean

1,20
1,35

Table 8: Iteration ratio of the different solvers over SupportSav.

LPRatio

LPRatio

afiro
1,000
1,000
0,944
fffff800
0,972
1,125
1,037

kb2
1,505
1,316
1,011
grow22
1,556
1,490
1,493

sc50a
1,289
1,342
1,316
standata
0,594
3,283
0,274

sc50b
1,576
1,576
1,545
scsd6
1,304
1,233
1,398

adlittle
1,076
1,042
1,458
standmps
0,675
3,038
0,427

blend
1,457
1,444
1,593
standgub
0,634
3,545
0,283

share2b
0,759
0,771
1,088
scfxm2
1,318
1,192
0,946

sc105
1,333
1,333
1,250
scrs8
1,573
1,379
1,655

stocfor1
1,108
1,108
1,676
gfrd-pnc
1,179
1,114
0,963

scagr7
2,065
2,304
1,333
bnl1
0,829
0,794
0,976

israel
0,587
0,591
1,029
ship04s
1,176
1,174
1,066

share1b
0,876
0,851
0,842
fit1p
4,557
4,459
4,269

vtpbase
1,012
4,191
0,791
modszk1
1,322
1,293
0,987

sc205
1,373
1,325
1,479
shell
1,442
2,870
1,436

beaconfd
1,056
1,056
0,683
scfxm3
1,153
1,132
0,918

grow7
1,472
1,384
1,432
25fv47
0,823
0,690
0,982

lotfi
1,145
1,031
1,298
ship04l
1,514
1,505
1,407

brandy
1,228
1,234
2,636
wood1p
0,947
0,947
0,782

e226
1,097
1,033
1,317
sctap2
1,431
1,472
1,443

bore3d
2,014
3,471
1,379
ganges
1,203
1,210
1,151

capri
0,915
5,286
1,127
scsd8
2,227
1,984
9,588

agg
0,929
1,047
4,591
ship08s
1,327
1,322
0,828

scorpion
1,339
1,320
1,222
ship12s
1,129
1,128
0,954

bandm
2,125
1,986
1,651
sctap3
1,538
1,519
1,507

sctap1
1,103
1,100
1,056
stocfor2
0,803
0,793
1,609

scfxm1
1,166
1,058
0,955
czprob
0,754
0,897
1,015

agg2
1,000
0,988
3,533
ship08l
1,760
1,754
1,124

agg3
1,017
1,006
3,562
bnl2
1,427
1,461
1,084

stair
1,609
2,104
1,335
ship12l
1,619
1,617
1,309

scsd1
1,202
1,255
1,324
d2q06c
0,986
0,847
0,860

grow15
1,471
1,424
1,723
woodw
0,916
0,849
0,726

scagr25
5,143
3,775
2,169
truss
1,198
1,065
1,520

fit1d
1,029
0,995
1,539
fit2d
0,999
0,996
1,048

finnis
1,090
1,197
1,005
maros-r7
1,613
1,574
1,286

Mean

1,33
1,57
1,49

We plot the CPU time ratios of the solvers SupportFab and SimplexFab over SupportSav (Figures 1(a) and 1(c)), and the iteration ratios of each solver over SupportSav (Figures 1(b), 1(d), and 1(e)). Ratios greater than one correspond to the points which are above the line in the graphs of Figure 1.

(a) Ratio of the CPU time of SupportFab over the CPU time of SupportSav (cputr₁₂)

(b) Ratio of the iterations number of SupportFab over the iterations number of SupportSav (nitr₁₂)

(c) Ratio of the CPU time of SimplexFab over the CPU time of SupportSav (cputr₁₃)

(d) Ratio of the iterations number of SimplexFab over the iterations number of SupportSav (nitr₁₃)

(e) Ratio of the iterations number of LP_SOLVE_PSA over the iterations number of SupportSav (nitr₁₄)

Figure 1: Ratios of the different solvers over SupportSav.

The analysis of the different tables and graphs leads us to make the following observations.(i)In terms of iterations number, SupportSav is competitive with SupportFab in solving 74% of the test problems with an average iteration ratio of 1.33. In terms of CPU time, SupportSav is competitive with SupportFab in solving 66% of the test problems with an average CPU time ratio of 1.20. Particularly, for the LP “scagr25” (Problem number 32), SupportSav is 5.14 times faster than SupportFab in terms of iterations number and solves the problem 4.55 times faster than SupportFab in terms of CPU time.(ii)In terms of iterations number, SupportSav is competitive with SimplexFab in solving 79% of the test problems with an average iteration ratio of 1.57. In terms of CPU time, SupportSav is competitive with SimplexFab in solving 68% of the test problems with an average CPU time ratio of 1.35. The peaks of the graph ratios correspond to the problems where our approach is 2 up to 5 times faster than SimplexFab. Particularly, for the LP “capri” (Problem number 21), SupportSav is 5.29 times faster than SimplexFab in terms of iterations number and solves the problem 3.99 times faster than SimplexFab in terms of CPU time. (iii)In terms of iterations number, SupportSav is competitive with LP_SOLVE_PSA in solving 72% of the test problems with an average iteration ratio of 1.49 (the majority of iteration ratios are above the line in Figure 1(e)). Particularly, for the LP “scsd8” (Problem number 55), our method is 9.58 times faster than the primal simplex implementation of the open-source solver LP_SOLVE.(iv)We remark from the last row of Table 6 that the total number of artificial variables added in order to find the initial support for SupportSav (13234) is considerably less than the total number of artificial variables added for SimplexFab (27389) and SupportFab (27389).(v)If we compute the total number of iterations necessary to solve the 68 LPs for each solver, we find (143737) for SupportSav, (159306) for SupportFab, (163428) for SimplexFab, and (158682) for LP_SOLVE_PSA. Therefore, the total number of iterations is the smallest for our solver.

5. Conclusion

In this work, we have proposed a single artificial variable technique to initialize the primal support method with bounded variables. An implementation under the MATLAB environnement has been developed. In the implementation, we have used the LU factorization of the basic matrix to solve the linear systems and the Sherman-Morrison-Woodbury formula to update the LU factors. After that, we have compared our approach (SupportSav) to the full artificial basis support method (SupportFab), the full artificial basis simplex method (SimplexFab), and the primal simplex implementation of the open-source solver LP_SOLVE (LP_SOLVE_PSA). The obtained numerical results are encouraging. Indeed, the suggested method (SupportSav) is competitive with SupportFab, SimplexFab, and LP_SOLVE_PSA.

Note that during our experiments, we have remarked that the variation of the initial support and the initial point affects the performances (CPU time and iterations number) of the single artificial variant of the support method. Thus, how to choose judiciously the initial point and the initial support in order to improve the efficiency of the support method? In future works, we will try to apply some crash procedure like those proposed in [25, 27] in order to initialize the support method with a good initial support. Furthermore, we will try to implement some modern sparse algebra techniques to update the LU factors [47].

References

L. V. Kantorovich, Mathematical Methods in the Organization and Planning of Production, Publication House of the Leningrad State University, 1939, Translated in Management Science, vol. 6, pp. 366–422, 1960.

G. B. Dantzig, “Maximization of a linear function of variables subject to linear inequalities,” in Activity Analysis of Production and Allocation, R. C. Koopmans, Ed., pp. 339–347, Wiley, New York, NY, USA, 1951.

G. B. Dantzig, Linear Programming and Extensions, Princeton University Press, Princeton, NJ, USA, 1963.

V. Klee and G. J. Minty, “How good is the simplex algorithm?” in Inequalities III, O. Shisha, Ed., pp. 159–175, Academic Press, New York, NY, USA, 1972.

R. Gabasov and F. M. Kirillova, Methods of Linear Programming, vol. 1–3, The Minsk University, 1977, 1978 and 1980.

S. Radjef and M. O. Bibi, “An effective generalization of the direct support method,” mathematical Problems in Engineering, vol. 2011, Article ID 374390, 18 pages, 2011.

R. Gabasov, F. M. Kirillova, and S. V. Prischepova, Optimal Feedback Control, Springer, London, UK, 1995.

R. Gabasov, F. M. Kirillova, and O. I. Kostyukova, “Solution of linear quadratic extremal problems,” Soviet Mathematics Doklady, vol. 31, pp. 99–103, 1985.

R. Gabasov, F. M. Kirillova, and O. I. Kostyukova, “A method of solving general linear programming problems,” Doklady AN BSSR, vol. 23, no. 3, pp. 197–200, 1979 (Russian).

R. Gabasov, F. M. Kirillova, and A. I. Tyatyushkin, Constructive Methods of Optimization. Part1. Linear Problems, Universitetskoje, Minsk, Russia, 1984.

E. A. Kostina and O. I. Kostyukova, “An algorithm for solving quadratic programming problems with linear equality and inequality constraints,” Computational Mathematics and Mathematical Physics, vol. 41, no. 7, pp. 960–973, 2001.

E. Kostina, “The long step rule in the bounded-variable dual simplex method: numerical experiments,” Mathematical Methods of Operations Research, vol. 55, no. 3, pp. 413–429, 2002.

M. O. Bibi, “Support method for solving a linear-quadratic problem with polyhedral constraints on control,” Optimization, vol. 37, no. 2, pp. 139–147, 1996.

B. Brahmi and M. O. Bibi, “Dual support method for solving convex quadratic programs,” Optimization, vol. 59, no. 6, pp. 851–872, 2010.

M. Bentobache and M. O. Bibi, “Two-phase adaptive method for solving linear programming problems with bounded variables,” in Proceedings of the YoungOR 17, pp. 50–51, University of Nottingham, UK, 2011.

M. Bentobache and M. O. Bibi, “Adaptive method with hybrid direction: theory and numerical experiments,” in Proceedings of the Optimization, pp. 24–27, Universidade Nova de Lisboa, Portugal, 2011.

M. O. Bibi and M. Bentobache, “The adaptive method with hybrid direction for solving linear programming problems with bounded variables,” in Proceedings of the colloque International sur l’Optimisation et les Systèmes d’Information (COSI’ 11), pp. 80–91, University of Guelma, Algeria, 2011.

M. O. Bibi and M. Bentobache, “An hybrid direction algorithm for solving linear programs,” in Proceedings of the International Conference on Discrete Mathematics & Computer Science (DIMACOS’11), pp. 28–30, University of Mohammedia, Morocco, 2011.

L. G. Khachian, “A polynomial algorithm for linear programming,” Soviet Mathematics Doklady, vol. 20, pp. 191–194, 1979.

N. Karmarkar, “A new polynomial-time algorithm for linear programming,” Combinatorica, vol. 4, no. 4, pp. 373–395, 1984.

S. I. Gass, Linear Programming: Methods and Applications, McGraw-Hill, New York, NY, USA, 1964.

C. M. Shetty, “A simplified procedure for quadratic programming,” Operations Research, vol. 11, pp. 248–260, 1963.

C. B. Millham, “Fast feasibility methods for linear programming,” Opsearch, vol. 13, pp. 198–204, 1976.

P. Wolfe, “The Composite Simplex Algorithm,” SIAM Review, vol. 7, no. 1, pp. 42–54, 1965.

R. E. Bixby, “Implementing the simplex method: the initial basis,” ORSA Journal on Computing, vol. 4, no. 3, pp. 1–18, 1992.

N. I. M. Gould and J. K. Reid, “New crash procedures for large systems of linear constraints,” Mathematical Programming, vol. 45, no. 1–3, pp. 475–501, 1989.

I. Maros and G. Mitra, “Strategies for creating advanced bases for large-scale linear programming problems,” INFORMS Journal on Computing, vol. 10, no. 2, pp. 248–260, 1998.

B. A. Murtagh and M. A. Saunders, “MINOS 5.5 User’s Guide,” Tech. Rep. SOL 83–20, Systems Optimization Lab., Stanford University, Stanford, Calif, USA, 1998.

W. Orchard-Hays, Advanced Linear-Programming Computing Techniques, McGraw-Hill, New York, NY, USA, 1968.

S. Lim and S. Park, “LPAKO: a simplex-based linear programming program,” Optimization Methods and Software, vol. 17, no. 4, pp. 717–745, 2002.

H. D. Sherali, A. L. Soyster, and S. G. Baines, “Nonadjacent extreme point methods for solving linear programs,” Naval Research Logistics Quarterly, vol. 30, no. 1, pp. 145–161, 1983.

M. Bentobache, A new method for solving linear programming problems in canonical form and with bounded variables, M.S. thesis, University of Bejaia, Algeria, 2005.

M. Bentobache and M. O. Bibi, “Two-phase support method for solving linear programming problems with nonnegative variables: numerical experiments,” in Proceedings of the Colloque International sur l’Optimisation et les Systèmes d’Information (COSI’08), pp. 314–325, University of Tizi Ouzou, Algeria, 2008.

M. Bentobache and M. O. Bibi, “Two-phase support method for solving linear programming problems with bounded variables: numerical experiments,” in Proceedings of the Colloque International sur l’Optimisation et les Systèmes d’Information (COSI’09), pp. 109–120, University of Annaba, Algeria, 2009.

G. Mitra, M. Tamiz, and J. Yadegar, “Experimental investigation of an interior search method within a simplex framework,” Communications of the ACM, vol. 31, no. 12, pp. 1474–1482, 1988.

R. J. Vanderbei, Linear Programming: Foundations and Extensions, Kluwer Academic Publichers, Princeton University, 2001.

ILOG CPLEX, “9.0 User’s Manual,” 2003, http://www.ilog.com

“LP_SOLVE,” http://sourceforge.net/projects/lpsolve/files/lpsolve

A. Makhorin, “GNU linear programming Kit,” Reference Manual Version 4.9, Draft Edition, 2006, http://www.gnu.org/software/glpk/glpk.html

P. G. García and Á. Santos-Palomo, “A deficient-basis dual counterpart of Paparrizos, Samaras and Stephanides’s primal-dual simplex-type algorithm,” in Proceedings of the 2nd Conference on Optimization Methods & Software and 6th EUROPT Workshop on Advances in Continuous Optimization, Prague, Czech Republic, 2007.

S. R. Thorncraft, H. R. Outhred, and D. J. Clements, “Evaluation of open-source LP optimization codes in solving electricity spot market optimization problems,” in Proceedings of the 19th Mini-Euro Conference on Operations Research Models and Methods in the Energy Sector, Coimbra, Portugal, 2006.

M. C. Ferris, O. L. Mangasarian, and S. J. Wright, “Linear programming with MATLAB,” MPSSIAM Series on Optimization, 2007.

R. H. Bartels and G. H. Golub, “The simplex method of linear programming using LU decomposition,” Communications of the ACM, vol. 12, no. 5, pp. 266–268, 1969.

P. E. Gill, W. Murray, M. A. Saunders, and M. H. Wright, “A practical anti-cycling procedure for linearly constrained optimization,” Mathematical Programming, vol. 45, no. 1-3, pp. 437–474, 1989.

M. Gay, “Electronic mail distribution of linear programming test problems,” Mathematical Programming Society COAL, Bulletin no. 13, 1985, http://www.netlib.org/lp/data

K. Paparrizos, N. Samaras, and G. Stephanides, “An efficient simplex type algorithm for sparse and dense linear programs,” European Journal of Operational Research, vol. 148, no. 2, pp. 323–334, 2003.

J. J. H. Forrest and J. A. Tomlin, “Updated triangular factors of the basis to maintain sparsity in the product form simplex method,” Mathematical Programming, vol. 2, no. 1, pp. 263–278, 1972.