Dense Linear Programming Research Articles

A quantum interior-point predictor–corrector algorithm for linear programming

We introduce a new quantum optimization algorithm for dense linear programming problems, which can be seen as the quantization of the interior point predictor–corrector algorithm [] using a quantum linear system algorithm []. The (worst case) work complexity of our method is, up to polylogarithmic factors, for n the number of variables in the cost function, m the number of constraints, ϵ −1 the target precision, L the bit length of the input data, an upper bound to the Frobenius norm of the linear systems of equations that appear, ‖M‖F, and an upper bound to the condition number κ of those systems of equations. This represents a quantum speed-up in the number n of variables in the cost function with respect to the comparable classical interior point algorithms when the initial matrix of the problem A is dense: if we substitute the quantum part of the algorithm by classical algorithms such as conjugate gradient descent, that would mean the whole algorithm has complexity , or with exact methods, at least . Also, in contrast with any quantum linear system algorithm, the algorithm described in this article outputs a classical description of the solution vector, and the value of the optimal solution.

A boundary-point LP solution method and its application to dense linear programs

A boundary-point LP solution method and its application to dense linear programs

A boundary-point LP solution method and its application to dense linear programs

This paper presents a linear programming solution method that generates a sequence of boundary-points belonging to faces of the feasible polyhedron. The method is based on a steepest descent search by iteratively optimising over a two-dimensional cross section of the polyhedron. It differs from extreme point algorithms such as the simplex method in that optimality is detected by identifying an optimal face of the polyhedron which is not necessarily an extreme point. It also differs from the polynomial-time methods such as the ellipsoid algorithm or projective scaling method that avoids the boundary of the feasible polyhedron. Limited computational analysis with an experimental code of the method, EZLP, indicates that our method performs quite well in total solution time when the number of variables and the density of the constraint matrix increase.

Improvement and its computer implementation of an artificial-free simplex-type algorithm by Arsham

Arsham ever described a new phase 1 simplex-type algorithm which allegedly obviates the use of artificial variables. Soon after, Enge and Huhn gave a counterexample, in which Arsham’s algorithm declares the infeasibility of a feasible problem. For this reason, this paper proposes an improvement of Arsham’s algorithm to make it work well, which is searching for the nonbasic variables into the basic variable set (BVS) column by column in only one pivot sequence from beginning to end in order to decrease computational time spent by many repeated searching sequences after each iteration. Next, when the BVS is complete, the phase 1 algorithm ends with a feasible basic solution; otherwise, two variants are presented to pivot the artificial variables out of the basis. The idea of variant 1 is making all artificial variables in basis minimized in turn while maintaining the BVS feasible in the pivoting process. In variant 2, the objective is to minimize the sum of all artificial variables in basis while keeping basic variables (including artificial) feasible. Finally, a computer implementation is accomplished to test the efficiency of our improvement comparing to the ordinary simplex algorithm on some standard test instances and randomly generated problems. The computational results show that our improved algorithms averagely spends much less executive time at each iteration than the ordinary simplex algorithm on sparse linear programming problems, and variant 2 is also competitive on dense linear programming problems.

Efficient GPU-based implementations of simplex type algorithms

Recent hardware advances have made it possible to solve large scale Linear Programming problems in a short amount of time. Graphical Processing Units (GPUs) have gained a lot of popularity and have been applied to linear programming algorithms. In this paper, we propose two efficient GPU-based implementations of the Revised Simplex Algorithm and a Primal–Dual Exterior Point Simplex Algorithm. Both parallel algorithms have been implemented in MATLAB using MATLAB’s Parallel Computing Toolbox. Computational results on randomly generated optimal sparse and dense linear programming problems and on a set of benchmark problems (netlib, kennington, Mészáros) are also presented. The results show that the proposed GPU implementations outperform MATLAB’s interior point method.

GPU accelerated pivoting rules for the simplex algorithm

Simplex type algorithms perform successive pivoting operations (or iterations) in order to reach the optimal solution. The choice of the pivot element at each iteration is one of the most critical step in simplex type algorithms. The flexibility of the entering and leaving variable selection allows to develop various pivoting rules. In this paper, we have proposed some of the most well-known pivoting rules for the revised simplex algorithm on a CPU–GPU computing environment. All pivoting rules have been implemented in MATLAB and CUDA. Computational results on randomly generated optimal dense linear programs and on a set of benchmark problems (Netlib-optimal, Kennington, Netlib-infeasible, Mészáros) are also presented. These results showed that the proposed GPU implementations of the pivoting rules outperform the corresponding CPU implementations.

A Computational Comparison of Basis Updating Schemes for the Simplex Algorithm on a CPU-GPU System

The computation of the basis inverse is the most time-consuming step in simplex type algorithms. This inverse does not have to be computed from scratch at any iteration, but updating schemes can be applied to accelerate this calculation. In this paper, we perform a computational comparison in which the basis inverse is computed with five different updating schemes. Then, we propose a parallel implementation of two updating schemes on a CPU-GPU System using MATLAB and CUDA environment. Finally, a computational study on randomly generated full dense linear programs is preented to establish the practical value of GPU-based implementation.

Some Computational Results on MPI Parallel Implementation of Dense Simplex Method

There are two major variants of the Simplex Algorithm: the revised method and the standard, or tableau method. Today, all serious implementations are based on the revised method because it is more efficient for sparse linear programming problems. Moreover, there are a number of applications that lead to dense linear problems so our aim in this paper is to present some computational results on parallel implementation of dense Simplex Method. Our implementation is implemented on a SMP cluster using C programming language and the Message Passing Interface MPI. Preliminary computational results on randomly generated dense linear programs support our results.

Large-scale linear programming techniques for the design of protein folding potentials

We present large-scale optimization techniques to model the energy function that underlies the folding process of proteins. Linear Programming is used to identify parameters in the energy function model, the objective being that the model predict the structure of known proteins correctly. Such trained functions can then be used either for ab-initio prediction or for recognition of unknown structures. In order to obtain good energy models we need to be able to solve dense Linear Programming Problems with tens (possibly hundreds) of millions of constraints in a few hundred parameters, which we achieve by tailoring and parallelizing the interior-point code PCx.

An efficient simplex type algorithm for sparse and dense linear programs

We present a big- M method for solving general linear programming problems with a recently developed exterior point simplex algorithm (EPSA). We also provide intuitive motivations to EPSA. We describe major steps in implementing EPSA for large-scale linear programming. Our implementation was carried out under the MATLAB environment. This algorithm seems to be more efficient than the classical primal simplex algorithm (PSA), employing Dantzig’s rule. Preliminary computational studies on randomly generated sparse and dense small and medium linear programs support this belief. In particular, EPSA is up to 10 times faster than PSA on medium size linear programs. This translates into corresponding savings in CPU time. Although the computational effort required in each step of EPSA requires more time compared to an iteration step of PSA, the improvement of EPSA comes from the fact that it requires adequately less iterations than PSA. Moreover, as the problem size increases and the problem density decreases, EPSA gets relatively faster.

Portfolio Optimization under Lower Partial Risk Measures

Portfolio management using lower partial risk (downside risk) measures is attracting more attention of practitioners in recent years. The purpose of this paper is to review important characteristics of these riskmeasures and conduct simulation using four alternative measures, lower semi-variance, lower semi-absolute deviation, first order below targetrisk and conditional value-at-risk.We will show that these risk measures are useful to control downside risk whenthe distribution of assets is non-symmetric. Further, we will propose a computational scheme to resolve the difficultyassociated with solving a large dense linear programming problems resulting from these models. We will demonstrate that this method can in fact solve problems consisting of104 assets and 105 scenarios within a practical amount of CPU time.

On using exterior penalty approaches for solving linear programming problems

In this paper, we investigate three exterior penalty function approaches for solving linear programming problems. These methods are an active set ℓ2 penalty approach (ASL2), an inequality–equality-based ℓ2 penalty approach (IEL2), and an augmented Lagrangian approach (ALAG). Particular effective variants are explored for each method, along with comments and experience on alternative algorithmic strategies that were empirically investigated. Our motivation is that heretofore, there has been no empirical evidence on how variants of these exterior point algorithms that have been suitably tuned might perform with respect to solving moderately large-scale linear programming problems. Our experiments using a set of randomly generated problems of varying sizes and density, as well as a set of NETLIB test problems, provide insights into the relative performance of these different approaches derived from the basic ℓ2 penalty function, and into their viability for solving linear programs. Average rank tests based on the computational results obtained are performed using two different statistics which assess the speed of convergence and the quality or accuracy of the solution. Overall, a particular variant (ALAG2) of ALAG yielded the best performance with respect to the joint criteria of speed of convergence and the quality of the final solution attained. On the other hand, IEL2 invariably achieved the best quality solutions using comparatively designed termination criteria. However, for highly dense linear programming problems, ASL2 appeared to be the best-alternative among the tested algorithms. Moreover, although our implementation was rudimentary in comparison with CPLEX 6.0, a commercial solver, the tested methods were competitive (sometimes favorable) in attaining a final (though only near optimal) solution for the set of large-scale low-density problems. Scope and purposeAlgorithms based on interior point methods for solving linear programming problems have gained popularity due to some recent techniques which eliminate the ill-conditioning that is inherent within barrier function approaches. Yet, there is comparatively less evidence on the performance of exterior penalty function approaches for solving linear programs. This article investigates three exterior penalty function approaches for solving such problems based on the quadratic penalty function, including the augmented Lagrangian function. Several related algorithmic strategies are explored and tested on a set of randomly generated, degenerate problems, as well as on a standard collection of NETLIB problems. We provide insights into the algorithmic performance and suggest avenues for further research in this relatively less explored domain of approaches for solving linear programming problems.

Data-Parallel Implementations of Dense Simplex Methods on the Connection Machine CM-2

We describe three data-parallel implementations of the simplex method for dense linear programming problems. The first implementation uses a full tableau and the most-negative reduced cost pivot rule, the second uses a tableau and the steepest-edge pivot rule, and the third is a revised method with explicit inverse. All are implemented on a Connection Machine CM-2 massively parallel computer system, using a variant of Fortran 90. Using special data structures called stripe arrays, we produce efficient implementations. We compare the implementations to one another and to MINOS 5.4 on a Sun workstation. Test problems are from NETLIB, supplemented by a few additional, genuinely dense models from real applications. An appendix also gives recent results on the Connection Machine CM-5. INFORMS Journal on Computing, ISSN 1091-9856, was published as ORSA Journal on Computing from 1989 to 1995 under ISSN 0899-1499.