Simplex QP-based methods for minimizing a conic quadratic objective over polyhedra

Abstract

We consider minimizing a conic quadratic objective over a polyhedron. Such problems arise in parametric value-at-risk minimization, portfolio optimization, and robust optimization with ellipsoidal objective uncertainty; and they can be solved by polynomial interior point algorithms for conic quadratic optimization. However, interior point algorithms are not well-suited for branch-and-bound algorithms for the discrete counterparts of these problems due to the lack of effective warm starts necessary for the efficient solution of convex relaxations repeatedly at the nodes of the search tree. In order to overcome this shortcoming, we reformulate the problem using the perspective of the quadratic function. The perspective reformulation lends itself to simple coordinate descent and bisection algorithms utilizing the simplex method for quadratic programming, which makes the solution methods amenable to warm starts and suitable for branch-and-bound algorithms. We test the simplex-based quadratic programming algorithms to solve convex as well as discrete instances and compare them with the state-of-the-art approaches. The computational experiments indicate that the proposed algorithms scale much better than interior point algorithms and return higher precision solutions. In our experiments, for large convex instances, they provide up to 22x speed-up. For smaller discrete instances, the speed-up is about 13x over a barrier-based branch-and-bound algorithm and 6x over the LP-based branch-and-bound algorithm with extended formulations. The software that was reviewed as part of this submission was given the Digital Object identifier https://doi.org/10.5281/zenodo.1489153.

Appendices

Appendix A. Branch-and-bound algorithm

Algorithm 3 describes the branch-and-bound algorithm used in computations. Throughout the algorithm, we maintain a list L of the nodes to be processed. Each node is a tuple (S, B, lb), where S is the subproblem, B is a basis for warm starting the continuous solver and lb is a lower bound on the objective value of S. In line 3 list L is initialized with the root node. For each node, the algorithm calls a continuous solver (line 9) which returns a tuple $(x,{\bar{B}},z)$, where x is an optimal solution of S, ${\bar{B}}$ is the corresponding optimal basis and z is the optimal objective value (or $\infty$ if S is infeasible). The algorithm then checks whether the node can be pruned (lines 10–11), x is integer (lines 12–15), or it further branching is needed (lines 16–18).

We now describe the specific implementations of the different subroutines. For branching (line 17) we use the maximum infeasibility rule, which chooses the variable $x_i$ with value $v_i$ furtherest from an integer (ties broken arbitrarily). The subproblems $S_{\le }$ and $S_{\ge }$ in line 18 are created by imposing the constraints $x_i\le \lfloor v_i \rfloor$ and $x_i\ge \lceil v_i \rceil$, respectively. The PULL routine in line 5 chooses, when possible, the child of the previous node which violates the bound constraint by the least amount, and chooses the node with the smallest lower bound when the previous node has no child nodes. The list L is thus implemented as a sorted list ordered by the bounds, so that the PULL operation is done in O(1) and the insertion is done in $O(\log |L|)$ (note that in line 18 we only add to the list the node that is not to be processed immediately). A solution x is assumed to be integer (line 12) when the values of all variables are within $10^{-5}$ of an integer. Finally, the algorithm is terminated when $\frac{ub-lb_{best}}{\left| lb_{best}+10^{-10}\right| }\le 10^{-4}$, where $lb_{best}$ is the minimum lower bound among all the nodes in the tree.

The maximum infeasibility rule is chosen due to its simplicity. The other rules and parameters correspond to the ones used in CPLEX branch-and-bound algorithm in default configuration.

Appendix B. Code

We provide a Java implementation of the proposed algorithms in “Simplex QP-based methods for minimizing a conic quadratic objective over polyhedra,” identified with DOI https://www.doi.org/10.5281/zenodo.1489153. Using the code requires having Java and CPLEX software installed on the computer. We now provide a brief description of the contents of the software, as well as a quick guide on how to run the experiments described in the paper.

1.1 Contents

The main directory contains two scripts, generateScript.bat and generateScript.sh, for running the code in Windows and Linux, respectively. The rest of the key directories are:

$\texttt {dist}$ :

Contains the executable jar file, LagrangeanConic.jar, for running the code. Also contains a lib directory with required libraries.

$\texttt {doc}$ :

Javadoc.

$\texttt {results}$ :

Directory where the results are stored.

$\texttt {src}$ :

Directory with the source code. Subdirectory src/cplex contains the codes corresponding to the proposed methodology. Specifically,

$\texttt {QuadraticSolver.java}$ :

Code for Algorithm 1.

$\texttt {QuadraticSolverCoordinateLP.java}$ :

Algorithm 1 with $t_0=\infty$.

$\texttt {QuadraticSolverBisection.java}$ :

Code for Algorithm 2.

$\texttt {ConicSolver.java}$ :

Code for solving with CPLEX default algorithms.

$\texttt {BranchAndBound.java}$ :

Code for the branch-and-bound algorithm.

Subdirectory src/instances contains code pertaining to the generation of the instances, subdirectory src/results contains code for processing the results, and subdirectory src/interfaces contains auxiliary code.

1.2 Running the experiments

The file README.txt in the main directory contains detailed instructions for running experiments. We now present a quick summary on how to run the experiments.

The files generateScript.bat and generateScript.sh contain two commands:

• (1) java -cp ./dist/LagrangeanConic.jar instances.FileGeneratorLinux #path

• (2) ./run.bat (or ./run.sh)

In command (1), # should be replaced with a number between 1 and 6, and path should be replaced with the path to CPLEX .dll file. When executing command (1), another script called run.bat or run.sh will be created for running all the experiments corresponding to Table # in the paper. For example, if # is replaced with 1, then the command will create a file that, when executed, runs the code 24 times, one for each precision and algorithm, and stores the results in the directory results. Command (2) simply executes the newly created file.