Efficient nested pricing in the simplex algorithm

https://doi.org/10.1016/j.orl.2007.10.001Get rights and content

Abstract

We report a remarkable success of nested pricing rules over major pivot rules commonly used in practice, such as Dantzig’s original rule as well as the steepest-edge rule and Devex rule.

Introduction

Consider the linear programming problem in the standard form [5], [14]minimizecTxsubject toAx=b,x0, where ARm×n(m<n) and rank(A)=m. It will be a simple matter to extend results of this paper to more general LP problems with bounds and ranges.

We will use ai to denote the i-indexed column of A, and ei the unit (nm)-vector with its i-th component one, and the 2-norm of a vector .

Let B be the basis and N the associated nonbasis at current iteration of the simplex algorithm. Without confusion, denote basic and nonbasic index sets again by B and N, respectively. The nonbasic reduced costs may be obtained by a so-called pricing operation: c̄N=cNNTπ,BTπ=cB. Optimality is achieved if the index set J={jc̄j<0,jN} is empty. In the other case, any index in J can be taken to enter the basis to improve the current feasible basic solution. Goodness of entering indices is crucial to the algorithm’s efficiency, however, as it essentially determines the number of iterations required for solving LP problems.

Recently, Pan, Li and Cao presented a scheme [23] that might be viewed as a variant of multiple pricing, but can better be termed nested pricing. Using a nested version of Dantzig’s criterion, it was implemented with a dense data structure within the deficient basis simplex algorithm [19], [20], [21]. The associated computational results were preliminary but encouraging. This paper considers more nested rules, and reports their computational performance against major commonly used rules on large-scale problems. Over 80 problems from Netlib, Kennington and BPMPD test sets, the nested Dantzig rule outperformed the Devex rule with iterations ratio 3.48 and time ratio 5.73. Over 77 problems of the test sets, it defeated the steepest-edge rule even with time ratio 25.22 despite requiring more iterations (with iterations ratio 0.34).

There are basically three types of commonly used pivot rules: full pricing rules, finite rules and partial pricing rules. In the remaining part of this section, we review some of them briefly. In Section 2, we describe pivot rules with nested pricing. In Section 3, we report computational results and make final remarks.

A rule involving all nonbasic reduced costs at each iteration is called a full pricing rule, such as Dantzig’s original rule [6], [8], the largest decrease rule [6] (see also [5], [13]), the steepest-edge rule [10] and the Devex rule [11]. These are standard commonly used rules in practice.

If J is nonempty, Dantzig’s original rule selects an entering index q such that q=argmin{c̄jjJ}. As a result, the objective value will decrease the most (by amount |c̄q|) with the value of the associated variable increasing by a unit.

Dantzig’s rule had been used in practice for several decades since the simplex algorithm came out.

If some index jJ is chosen to enter the basis, a pivot row index, say i, has to be determined such that αj=b̄i/āi,j=min{b̄l/āl,jāl,j>0,l=1,,m}, where b̄l is the l-th entry of B1b and āl,j the l-th entry of B1aj. The resulting decrease in the objective value will be |c̄jαj|. The rule selects a nonbasic index q to enter the basis such that q=argmin{c̄jαjjJ}, consequently achieving the largest possible decrease in the objective value after that iteration.

This criterion was also mentioned in Dantzig’s original paper. But since then this rule has been abandoned because of the overelaborate computation involved.

For simplicity, assume that basis B consists of the first m columns of the constraint matrix. Then the set of edge directions emanating from the current vertex can be written as dj=[B1NI]ejm,jN. where IR(nm)×(nm). It is noted that c̄j=cTdj. When J is nonempty, the steepest-edge rule chooses an index q to enter the basis such that c̄q/dq=min{c̄j/dj|jN}<0. Thus, edge direction dq is the most downhill with respect to the objective gradient c among the edges. If implemented explicitly, computation of the edge direction norms is too expensive to be practical. To expedite calculations, Goldfarb and Reid [10] derive recurrence formulas as follows. Assume that q replaces p in the basis. Introduce the notation αq=πpTaq;αj=πpTaj,jN,jq, where BTπp=ep. Then recurrence formulas for the edge directions are easily derived: d̄p=(1/αq)dq;d̄j=dj(αj/αq)dq,jN,jq, from which it follows that d̄p2=(1/αq2)dq2=1+āq2,d̄j2=dj22(αj/αq)ajTv+(αj/αq)2dq2,jN,jq, where Bāq=aq,BTv=āq. Only the second of the preceding equations should be solved, since āq is computed independently of updating dj2 in the simplex algorithm.

The steepest-edge rule involves more computational effort per iteration than Dantzig’s rule. But, it usually requires much less iteration to solve large-scale LP problems [9]. Unfortunately, however, it has to compute dj2’s associated with all nonbasic indices from scratch initially and periodically. The related costs are very high, especially if advantage of computer architecture is not taken to solve systems of equations with the same coefficient matrix. As a remedy, the Devex rule eliminates such shortcomings to a large extent, as reviewed as follows.

Harris’ Devex Code [11] approximates the steepest-edge rule, in which the norms dj of the edge directions are replaced by weights wj. Initially and periodically, a so called “reference framework” is set to the current set of nonbasic indices, and the wj are set to one for all j in the set. At other iterations, it uses wj to approximate the norms of the subvectors dˆj consisting of only those components of the edge directions dj associated with the reference framework. The weights wj are updated using w̄p=max{1,dˆq/αq};w̄j=max{wj,|(αj/αq)|dˆq},jN,jq. which results from using the larger of the norms of the two vectors dˆj and (αj/αq)dˆq to approximate the norm of their sum. Note that dˆq can be easily computed since dq is calculated at each iteration independent of the updating of weights.

Accepted as the best for simplex algorithms, steepest-edge/Devex rules are now commonly used in commercial packages, such as CPLEX [2], [12].

The preceding rules are infinite in the sense that in the presence of degeneracy, the rule could yield zero-length steps, and hence even cycling. Although it turns out that cycling rarely occurs in practice, the solution process could be stuck at a degenerate vertex for too long a time before exiting it. Therefore, a number of finite rules were proposed in the past, such as Bland’s rule and the lexicographic rule [4], [7], [3], [24]; for a survey, see [25]. Although Pan’s finite rule [18] seems to be more practical, such rules are not competitors of the standard rules, and therefore have never been used in practice.

Important variants of the standard rules result from taking only a part of nonbasic costs into account.

MINOS [15] uses a sectional variant of Dantzig’s rule as follows. With option p, all indices are partitioned into p roughly equal segments. The pricing operation begins on the segment that follows the one from which the previous entering index was selected. If a reduced cost is found that is less than some dynamic negative tolerance, the associated index is selected to enter the basis; otherwise, the same is repeated on the next segment, and so on. It turns out that such a strategy reduces not only the computational work per iteration but also the number of iterations required, in general (see, e.g., [11]).

So-called “multiple-pricing” rules are a special type of partial pricing ones (see, for example, [1], [5], [14], [16], [17]). Beginning with determining a small set of nonbasic indices with negative reduced costs, such rules select from this set by some criterion an entering index but retain the other indices in the set as candidates for the next iteration. They continue in this way until the reduced costs associated with all the indices in the set are nonnegative. Then, they identify a new set of indices with negative reduced costs, and repeat the process.

Section snippets

The nested pricing

At each iteration, one is faced with a subset J of N, indices in which are given priority to become basic. Pricing is conducted on J to determine a reduced cost by some criterion. If one is found significantly negative, the associated index is selected to enter B. If it is not, the same is done with the remaining set to determine an entering index; if no such one is found, then optimality is declared.

In particular, we describe the nested version of Dantzig’s original rule.

Rule 1 Nested Dantzig

Let ε>0 be the

Computational experiments

Computational experiments with the nested pricing were carried out extensively. In view of the limit on space, we only outline numerical results obtained and make final remarks in this section. For more details, the reader is referred to [22].

To have comparisons that are easy and fair, in our tests each rule is implemented within MINOS 5.51, the latest version of MINOS. Actually, all resulting codes are the same as MINOS 5.51, except for its pivot rule being replaced by relevant ones. Our first

Acknowledgments

This work was supported by Project 10371017 of the National Natural Science Foundation of China.

The author would like thank Professor Michael A. Saunders for very useful comments and for kindly providing us with the MINOS 5.51 package. The author is also grateful to an anonymous referee for his/her valuable comments, which pointed out that any full pricing rule can be recast to its nested version, and suggested comparing the nested pricing rules with the steepest-edge rule and Devex rule. This

References (25)

  • P.-Q. Pan

    A basis-deficiency-allowing variation of the simplex method

    Computers and Mathematics with Applications

    (1998)
  • P.-Q. Pan

    A projective simplex method for linear programming

    Linear Algebra and Its Applications

    (1999)
  • P.-Q. Pan

    A projective simplex algorithm using LU factorization

    Computers and Mathematics with Applications

    (2000)
  • M.J. Benichou et al.

    The efficient solution of large scale linear programming problems

    Mathematical Programming

    (1977)
  • R.E. Bixby

    Solving real-world linear programs: A decade and more of progress

    Operations Research

    (2002)
  • R.G. Bland

    New finite pivoting rules for the simplex method

    Mathematics of Operations Research

    (1977)
  • A. Charnes

    Optimality and degeneracy in linear programming

    Econometrica

    (1952)
  • V. Chvatal

    Linear Programming

    (1983)
  • G.B. Dantzig

    Maximization of a linear function of variables subject to linear inequalities

  • G.B. Dantzig et al.

    The generalized simplex method for minimizing a linear form under linear inequality restraints

    Pacific Journal of Mathematics

    (1955)
  • G.B. Dantzig

    Linear Programming and Extensions

    (1963)
  • J.J.H. Forrest et al.

    Steepest-edge simplex algorithms for linear programming

    Mathematical Programming

    (1992)
  • Cited by (10)

    View all citing articles on Scopus
    View full text