On the implementation and usage of SDPT3 – a Matlab software package for semidefinite-quadratic-linear programming, version 4.0 K. C. Toh ∗, R. H. T¨ ut¨ unc¨ u †, and M. J. Todd
‡
Draft, 17 July 2006
Abstract This software is designed to solve conic programming problems whose constraint cone is a product of semidefinite cones, second-order cones, nonnegative orthants and Euclidean spaces; and whose objective function is the sum of linear functions and log-barrier terms associated with the constraint cones. This includes the special case of determinant maximization problems with linear matrix inequalities. It employs an infeasible primal-dual predictor-corrector path-following method, with either the HKM or the NT search direction. The basic code is written in Matlab, but key subroutines in C are incorporated via Mex files. Routines are provided to read in problems in either SDPA or SeDuMi format. Sparsity and block diagonal structure are exploited. We also exploit low-rank structures in the constraint matrices associated the semidefinite blocks if such structures are explicitly given. To help the users in using our software, we also include some examples to illustrate the coding of problem data for our SQLP solver. Various techniques to improve the efficiency and stability of the algorithm are incorporated. For example, step-lengths associated with semidefinite cones are calculated via the Lanczos method. Numerical experiments show that this general purpose code can solve more than 80% of a total of about 300 test problems to an accuracy of at least 10−6 in relative duality gap and infeasibilities. ∗
Department of Mathematics, National University of Singapore, 2 Science Drive 2, Singapore 117543 (
[email protected]); and Singapore-MIT Alliance, E4-04-10, 4 Engineering Drive 3, Singapore 117576. Research supported in parts by NUS Research Grant R146-000-076-112 and SMA IUP Research Grant. † Department of Mathematical Sciences, Carnegie Mellon University, Pittsburgh, PA 15213, USA (
[email protected]). Research supported in part by NSF through grants CCR-9875559, CCF-0430868 and by ONR through grant N00014-05-1-0147 ‡ School of Operations Research and Industrial Engineering, Cornell University, Ithaca, New York 14853, USA (
[email protected]). Research supported in part by NSF through grant DMS-0209457 and by ONR through grant N00014-02-1-0057.
1
1
Introduction
The current version of SDPT3, version 4.0, is designed to solve conic programming problems whose constraint cone is a product of semidefinite cones, second-order cones, nonnegative orthants and Euclidean spaces; and whose objective function is the sum of linear functions and log-barrier terms associated with the constraint cones. It solves the following standard form of such problems, henceforth called SQLP problems: (P ) min
ns X
[hcsj , xsj i − νjs log det(xsj )] +
j=1
+ hcl , xl i − s.t.
nl X
νkl log xlk
Asj (xsj ) j=1 s xsj ∈ Ks j ∀j,
+
nq X
i=1
[hcqi , xqi i − νiq log γ(xqi )]
+ hcu , xu i
k=1
ns X
nq X
Aqi xqi
+ Al xl
+ Au xu = b,
i=1
xqi
∈ Kqqi ∀i, xl ∈ Klnl , xu ∈ IRnu . s
Here, csj , xsj are symmetric matrices of dimension sj and Ks j is the cone of positive semidefinite symmetric matrices of the same dimension. Similarly, cqi , xqi are vectors in IRqi and Kqqi is the quadratic or second-order cone defined by Kqqi := {x = [x0 ; x ¯] ∈ √ nl qi l l T IR : x0 ≥ x ¯ x ¯}. Finally, c , x are vectors of dimension nl , Kl is the nonnegative orthant IRn+l , and cu , xu are vectors of dimension nu . In the notation above, Asj is s the linear map from Ks j to IRm defined by h
i
Asj (xsj ) = hasj,1 , xsj i; . . . ; hasj,m , xsj i , where asj,1 , . . . , asj,m ∈ S sj are constraint matrices associated with the jth semidefinite block variable xsj . The matrix Aqi is an m × qi dimensional constraint matrix corresponding to the ith quadratic block variable xqi , and Al and Au are the m × nl and m × nu dimensional constraint matrices corresponding to the linear block variable xl and the unrestricted block variable xu . The notation hp, qi denotes the standard ¯] in a second inner product in the appropriate q space. For a given vector u = [u0 ; u
order cone, we define γ(u) := u20 − u ¯T u ¯. In the problem (P ), νjs , νiq , and νkl are given nonnegative parameters. In this paper, the vector 2-norm and Frobenius norm are denoted by k·k and k·kF , respectively. We use the Matlab notation [U ; V ] to denote the matrix obtained by appending V below the last row of U . For a given matrix U , we use the notation U (k, :) and U (:, k) to denote the kth row and column of U , respectively. operator Let svec : S n → IRn(n+1)/2 √ be the vectorization √ √ on symmetric matrices defined by svec(X) = [X11 , 2X12 , X22 , . . . , 2X1n , . . . , 2Xn−1,n , Xnn ]T . For computational purpose, it is convenient to identify Asj with the following m × s¯j matrix (where s¯j = sj (sj + 1)/2): h
i
Asj = svec(asj,1 ); . . . ; svec(asj,m ) .
2
With the matrix representation of Asj , we have that Asj (xsj ) = Asj svec(xsj ). The software also solves the dual problem associated with the problem above: (D) max bT y +
ns X
[νjs log det(zjs ) + sj νjs (1 − log νjs )]
j=1
+
nq X i=1
nl X
[νiq log γ(ziq ) + νiq (1 − log νiq )] +
s.t. (Asj )T y + zjs = csj , (Aqi )T y + ziq = cqi , (Al )T y +
k=1
s
zjs ∈ Ks j , ziq ∈ Kqqi ,
z l = cl ,
z l ∈ Klnl ,
= cl ,
y ∈ IRm .
(Au )T y
[νkl log zkl + νkl (1 − log νkl )] j = 1 . . . , ns i = 1 . . . , nq
In the notation above, (Asj )T is the adjoint of Asj defined by (Asj )T y = For later convenience, we introduce the following notation: xq = [xq1 ; . . . ; xqnq ],
xs = (xs1 ; . . . ; xsns ),
i
h
Pm
s k=1 yk aj,k .
Aq = Aq1 , . . . , Aqnq ,
where the notation (xs1 ; . . . ; xsns ) means that the objects xsj are placed in a column P s format. We define cs , z s , cq , and z q analogously. Let As (xs ) = nj=1 Asj (xsj ), (As )T y = s T s T s q l u s q l u ((A1 ) y; . . . ; (Ans ) y), and c = (c ; c ; c ; c ), x = (x ; x ; x ; x ), z = (z s ; z q ; z l ; 0). Finally, we define
A(x) = As (xs ) + Aq xq + Al xl + Au xu ,
AT (y) = (As )T y; (Aq )T y; (Al )T y; (Au )T y ,
s
qnq
K = Kss1 × · · · × Ks ns × Kqq1 × · · · × Kq
× Klnl × IRnu ,
qnq
s
K ∗ = Kss1 × · · · × Ks ns × Kqq1 × · · · × Kq
× Klnl × {0},
so that the equality constraints of (P ) and (D) can be written more compactly as follows: A(x) = b,
x ∈ K,
AT (y) + z = c,
The matrix representation of A is given by h
z ∈ K ∗. i
A = As1 , . . . , Asns , Aq , Al , Au .
(1)
(2)
The software package was originally developed to provide researchers in semidefinite programming with a collection of reasonably efficient and robust algorithms that could solve general SDPs (semidefinite programming problems) with matrices of dimensions of the order of a hundred. The current release expands the family of problems solvable by the software in several dimensions. 1. This version is faster than the previous releases, e.g. [27], [30], especially on large sparse problems, and consequently can solve larger problems.
3
2. The current release can also solve problems that have explicit log-barrier terms in the objective functions. Hence determinant maximization problems can be solved. 3. The solver is more robust in handling unrestricted variables. 4. Low-rank structures in the constraint matrices associated with the semidefinite blocks can be exploited to improve computational efficiency and memory requirement. All the numerical experiments in this paper are performed on a Pentium IV 3.0GHz personal computer with 4GB of physical memory using Matlab version 7 on a Linux operating system. Organization of the paper. In Section 2, we describe the representation of SQLP data by cell arrays. The SQLP solver sqlp.m in our software is described in Section 3. In Section 4, we present a few SQLP examples to illustrate the usage of our software. Implementation details such as the computation of search directions are given in Section 5. Finally, the last section reports computational results obtained by SDPT3 on about 300 SQLP problems. Installation. The current version is written in Matlab version 6.5 and is compatible with Matlab version 7.0. It is available from the internet sites: http://www.math.nus.edu.sg/~mattohkc/sdpt3.html http://www.math.cmu.edu/~reha/sdpt3.html Our software uses a number of Mex routines generated from C programs written to carry out certain operations that Matlab is not efficient at. In particular, operations such as extracting selected elements of a matrix, and performing arithmetic operations on these selected elements are all done in C. As an example, the vectorization operation svec is coded in the C program mexsvec.c. To install SDPT3 and generate these Mex routines, the user can simply follow the steps below: (a) unzip SDPT3-4.0.zip; (b) run Matlab in the directory SDPT3-4.0; (c) run the m-file Installmex.m. After that, to see whether you have installed SDPT3 correctly, run the m-files: >> startup >> sqlpdemo
2
Cell array representation of problem data
Our implementation exploits the block structure of the given SQLP problem. In the internal representation of the problem data, we classify each semidefinite block into one of the following two types:
4
1. a dense or sparse matrix of dimension greater than or equal to 100; 2. a sparse block-diagonal matrix consisting of numerous sub-blocks each of dimension less than 100. The reason for using the sparse matrix representation to handle the case when we have numerous small diagonal blocks is that it is less efficient for Matlab to work with a large number of cell array elements compared to working with a single cell array element consisting of a large sparse block-diagonal matrix. Technically, no problem will arise if one chooses to store the small blocks individually instead of grouping them together as a sparse block-diagonal matrix. For the quadratic part, we typically group all quadratic blocks (small or large) into a single block, though it is not mandatory to do so. If there are a large number of small blocks, it is advisable to group them all together as a single large block consisting of numerous small sub-blocks for the same reason we just mentioned. Let L be the total number of blocks in the SQLP problem. If all the various types of blocks are present in (P ), then L = ns + nq + 2. For each SQLP problem, the block structure of the problem data is described by an L × 2 cell array named blk. The content of each of the elements of the cell arrays is given as follows. If the jth block is a semidefinite block consisting of a single block of size sj , then blk{j,1} = ’s’,
blk{j, 2} = [sj ],
At{j} = [¯ sj x m sparse], C{j}, X{j}, Z{j} = [sj x sj double or sparse], where s ¯j = sj (sj + 1)/2. If the jth block is a semidefinite block consisting of numerous small sub-blocks, P say p of them, of dimensions sj1 , sj2 , . . . , sjp such that pk=1 sjk = sj , then blk{j,1} = ’s’,
blk{j, 2} = [sj1 , sj2 , · · · , sjp ],
At{j} = [¯ sj x m sparse],
C{j}, X{j}, Z{j} = [sj x sj sparse], Pp
where s ¯j = k=1 sjk (sjk + 1)/2. Notice that we store all the constraint matrices associated with the jth semidefinite block in vectorized form as a single s¯j × m matrix where the kth column of this matrix corresponds to the kth constraint matrix. That is, At{j}(:,k) = svec(asj,k ). The above storage scheme for the data matrix Asj associated with the semidefinite blocks of the SQLP problem represents a departure from earlier versions (version 2.3 or earlier) of our implementation, such as the one described in [27]. Previously, the constraint matrices were stored in an ns × m cell array AA, where AA{j,k} = asj,k , and it was stored as an individual matrix in either dense or sparse format. The data format we used in earlier versions of SDPT3 was more natural, but our current data representation was adopted for the sake of computational efficiency. The reason for such a change is again due to the fact that it is less efficient for Matlab to work with a single cell array with many cells.
5
But note that it is easy to use the function svec.m provided in SDPT3 to convert AA into the new storage scheme as follows: At(j) = svec(blk(j,:),AA(j,:)). While we now store the constraint matrix in vectorized form, the parts of the iterates X and Z corresponding to semidefinite blocks are still stored as matrices, since that is how the user wants to access them. The data storage scheme corresponding to quadratic, linear, and unrestricted blocks is rather straightforward. If the ith block is a quadratic block consisting of numerous sub-blocks, say p of them, of dimensions qi1 , qi2 , . . . , qip such that Pp k=1 qik = qi , then blk{i,1} = ’q’,
At{i} = [qi x m sparse],
blk{i, 2} = [qi1 , qi2 , · · · , qip ],
C{i}, X{i}, Z{i} = [qi x 1 double or sparse]. If the kth block is the linear block, then blk{k,1} = ’l’,
blk{k, 2} = nl ,
At{k} = [nl x m sparse], C{k}, X{k}, Z{k} = [nl x 1 double or sparse]. Similarly, if the kth block is the unrestricted block, then blk{k,1} = ’u’,
blk{k, 2} = nu ,
At{k} = [nu x m sparse], C{k}, X{k}, Z{k} = [nu x 1 double or sparse]. (It is possible to have several linear or unrestricted blocks, but it is more efficient to reformulate such a problem by combining all linear blocks and similarly all unrestricted blocks.)
2.1
Specifying the block structure of problems
Our software requires the user to specify the block structure of the SQLP problem. Although no technical difficulty will arise if the user choose to lump a few blocks together and consider it as a single large block, the computational time can be dramatically different. For example, the problem qpG11 in the SDPLIB library [2] actually has block structure blk{1,1} = ’s’, blk{1,2} = 800, blk{2,1} = ’l’, blk{2,2} = 800, but the structure specified in the library is blk{1,1} = ’s’, blk{1,2} = 1600. That is, in the former, the linear variables are explicitly identified, rather than being part of a large sparse semidefinite block. The difference in the running time for specifying the block structure differently is dramatic: the former representation is at least six times faster when the HKM direction is used, besides using much less memory space. It is thus crucial to present problems to the algorithms correctly. We could add our own preprocessor to detect this structure, but believe users are aware of linear
6
variables present in their problems. Unfortunately the versions of qpG11 (and also qpG51) in SDPLIB do not show this structure explicitly. In our software, we provide an m-file, detect diag.m, to detect problems with linear variables. The user can call this m-file after loading the problem data into Matlab as follows: >> [blk,At,C,b] = read_sdpa(’./sdplib/qpG11.dat-s’); >> [blk,At,C,b] = detect_diag(blk,At,C,b);
2.2
Storing constraint matrices with low-rank structures
A new feature of the current version of SDPT3 is that it can exploit low-rank structures present in the constraint matrices associated with the semidefinite blocks. To do so, the user needs to specify the low-rank structures in the constraint matrices explicitly when coding the problem data. The purpose here is to explain how this is done. Suppose the jth row of blk corresponds to a semidefinite block. To simplify implementation, we exploit possible low-rank structures only when this semidefinite block is a single block. That is, blk{j, 2} = [sj ]. Suppose that the first p matrices, asj,1 , . . . asj,p , have no low-rank structures, and the remaining matrices asj,p+1 , . . . , asj,m have such structures with asj,k = Vk Dk VkT ,
k = p + 1, . . . , m,
where Vk ∈ IRsj ×rj,k is a low-rank matrix with rj,k sj , and Dk ∈ IRrj,k ×rj,k is a symmetric matrix. The low-rank structures of these matrices should be recorded as follows: blk{j,1} = ’s’,
blk{j, 2} = [sj ],
At{j, 1} = [¯ sj x p sparse],
blk{j, 3} = [rj,p+1 , . . . , rj,m ],
At{j, 2} = [Vj,p+1 , . . . , Vj,m ],
At{j, 3} = dd,
where dd is a 4-column matrix that records the non-zero elements of Dk , k = p + 1, . . . , m, and a row (say, ith row) of dd has the following form: d(i, :) = [constraint number − p, row index, column index, non-zero value]. If all the matrices Dk are diagonal, then the user can simply set dd to be the following column vector: dd = [diag (Dp+1 ); . . . ; diag (Dm )]. In the subdirectory Examples, we give an m-file randlowranksdp.m to generate random SDP problems with low-rank constraint matrices, whose calling syntax is: [blk,At,C,b,bblk,AAt] = randlowranksdp(n,p,m2,r) It will generate an SDP where the first p constraint matrices have no low-rank structures, and the remaining m2 matrices have low-rank structures and each matrix has rank r. The output [blk,At,C,b] explicitly describes the low-rank structure as above, while [bblk,AAt,C,b] encodes the same SDP, but without including the lowrank structure information.
7
3
The main function: sqlp.m
The algorithm implemented in SDPT3 is an infeasible primal-dual path-following algorithm, described in detail in Appendix A. At each iteration, we first compute a predictor search direction aimed at decreasing the duality gap as much as possible. After that, the algorithm generates a Mehrotra-type corrector step [17] with the intention of keeping the iterates close to the central path. However, we do not impose any neighborhood restrictions on our iterates.1 Initial iterates need not be feasible — the algorithm tries to achieve feasibility and optimality of its iterates simultaneously. It should be noted that in our implementation, the user has the option to use a primal-dual path-following algorithm that does not use corrector steps. The main routine that corresponds to Algorithm IPC described in Appendix A is sqlp.m, whose calling syntax is as follows: [obj,X,y,Z,info,runhist] = sqlp(blk,At,C,b,OPTIONS,X0,y0,Z0). Input arguments. blk: a cell array describing the block structure of the SQLP problem. At, C, b: SQLP data. OPTIONS: a structure array of parameters (optional). X0, y0, Z0: an initial iterate (optional). If the input argument OPTIONS is omitted, default values specified in the function sqlparameters.m are used. More detail on OPTIONS is given in Section 3.1. Output arguments. The names chosen for the output arguments explain their contents. The argument info is a structure array containing performance information such as info.termcode, info.obj, info.gap, info.pinfeas, info.dinfeas, info.cputime whose meanings are explained in sqlp.m. The argument runhist is a structure array which records the history of various performance measures during the run; for example, runhist.gap records the complementarity gap at each interior-point iteration. Note that, while (X,y,Z) normally gives approximately optimal solutions, if info.termcode is 1 the problem is suspected to be primal infeasible and (y,Z) is an approximate certificate of infeasibility, with bT y = 1, Z in the appropriate cone, and AT y + Z small, while if info.termcode is 2 the problem is suspected to be dual infeasible and X is an approximate certificate of infeasibility, with hC, Xi = −1, X in the appropriate cone, and AX small. Note that A is defined in (2). Caveats. 1
This strategy works well on most of the problems we tested. However, it should be noted that the occasional failure of the software on problems with poorly chosen initial iterates is likely due to the lack of a neighborhood enforcement in the algorithm.
8
(a) The user should be aware that SQLP is more complicated than linear programming. For example, it is possible that both primal and dual problems are feasible, but their optimal values are not equal. Also, either problem may be infeasible without there being a certificate of that fact (so-called weak infeasibility). In such cases, our software package is likely to terminate after some iterations with an indication of short step-length or lack of progress. Also, even if there is a certificate of infeasibility, our infeasible-interior-point methods may not find it. In our very limited testing on strongly infeasible problems, our algorithms have been quite successful in detecting infeasibility. (b) Since our algorithm is a primal-dual method storing the primal iterate X, it cannot exploit common sparsity in C and the constraint matrices as well as dual methods or nonlinear-programming based methods. Thus our software may not be able to handle dense or sparse semidefinite blocks (with a single block) with dimension more than 2000 on an average PC available today. (c) Our interior-point algorithms are designed based on the existence of a central path in the interior of the primal-dual feasible region of (P ) and (D). For problems where the primal-dual feasible region is non-empty but has an empty interior, our SQLP solver can generally still deliver a reasonably good approximate optimal solution, but the solver tends to encounter numerical difficulties before a high accuracy solution can be obtained.
3.1
The structure array OPTIONS for parameters
sqlp.m uses a number of parameters which are specified in a Matlab structure array called OPTIONS in the m-file sqlparameters.m. If desired, the user can change the values of these parameters. The meaning of the specified fields in OPTIONS are given in the m-file itself. As an example, if the user does not wish to use corrector steps in Algorithm IPC, then he can do so by setting OPTIONS.predcorr = 0. If the user wants to use a fixed value, say 0.98, for the step-length parameter γ in Algorithm IPC instead of the adaptive strategy used in the default, he can achieve that by setting OPTIONS.gam = 0.98. Similarly, if the user wants to solve the SQLP problem to an accuracy tolerance of 1e-4 instead of the default value of 1e-8 while using the default values for all other parameters, he only needs to set OPTIONS.gaptol = 1e-4. The defaults in sqlparameters.m assume that the parameters νjs , νiq , νkl in (P ) are all 0. For an SQLP problem where some of the parameters νjs , νiq , νkl are positive, the user needs to specify an L × 1 cell array OPTIONS.parbarrier to store the values of these parameters (including zeros) as follows. If the jth block is a semidefinite block consisting of one or more sub-blocks, say p of them, of dimensions sj1 , sj2 , . . . , sjp , then s , ν s , · · · , ν s ]. OPTIONS.parbarrier{j} = [νj1 j2 jp
If the ith block is a quadratic block consisting of one or more sub-blocks, say p of them, of dimensions qi1 , qi2 , . . . , qip , then q
q
q
OPTIONS.parbarrier{i} = [νi1 , νi2 , · · · , νip ].
9
If the kth block is the linear block, then OPTIONS.parbarrier{k} = [ν1l , ν2l , · · · , νnll ], while if the kth block is the unrestricted block, then OPTIONS.parbarrier{k} = zeros(1, nu ). The reader is referred to Section 4.2 for an example where the objective function in (D) is given by log det(z s ).
3.2
Running problems in SDPA and SeDuMi format
We provide two m-files, read sdpa.m and read sedumi.m, to respectively convert problem data stored in SDPA [6] and SeDuMi [22] format into Matlab cell arrays described above. The subdirectory sdplib in SDPT3 contains a few problems in SDPA format that are extracted from the SDPLIB library [2], while the subdirectory dimacs contains problems in SeDuMi format that are extracted from the DIMACS library [20]. Assuming that the current directory is SDPT3-4.0, we can read in and run the test problem mcp250-1.dat-s in the subdirectory sdplib as follows: >> startup % set up Matlab paths >> [blk,At,C,b] = read_sdpa(’./sdplib/mcp250-1.dat-s’); >> [obj,X,y,Z,info] = sqlp(blk,At,C,b); num. of constraints = 250 dim. of sdp var = 250, num. of sdp blk = 1 ******************************************************************* SDPT3: Infeasible path-following algorithms ******************************************************************* version predcorr gam expon scale_data HKM 1 0.000 1 0 it pstep dstep p_infeas d_infeas gap mean(obj) cputime ------------------------------------------------------------------0 0.000 0.000 1.4e+03 9.5e+01 7.0e+05 -1.462827e+04 0:0:0 spchol 1 0.981 1.000 2.6e+01 9.8e-15 1.7e+04 -2.429708e+03 0:0:0 spchol 2 1.000 1.000 5.0e-14 0.0e+00 2.4e+03 -1.352811e+03 0:0:1 spchol : : : : : : : : : 13 1.000 0.996 9.4e-13 5.1e-16 2.1e-05 -3.172643e+02 0:0:4 spchol 14 1.000 1.000 2.5e-12 4.3e-16 6.5e-07 -3.172643e+02 0:0:5 Stop: max(relative gap, infeasibilities) < 1.00e-08 ------------------------------------------------------------------number of iterations = 14 primal objective value = -3.17264340e+02 dual objective value = -3.17264340e+02 gap := trace(XZ) = 6.45e-07 relative gap = 1.02e-09 actual relative gap = 1.02e-09 rel. primal infeas = 2.52e-12
10
1 1 1
1 1 1
1
1
rel. dual infeas = 4.29e-16 norm(X), norm(y), norm(Z) = 1.3e+02, 2.3e+01, 1.3e+01 norm(A), norm(b), norm(C) = 1.6e+01, 1.6e+01, 1.4e+01 Total CPU time (secs) = 4.7 CPU time per iteration = 0.3 termination code = 0 DIMACS: 2.5e-12 0.0e+00 4.3e-16 0.0e+00 1.0e-09 1.0e-09 -------------------------------------------------------------------
We can solve a DIMACS test problem in a similar manner. >> OPTIONS.vers = 2; % use NT direction >> [blk,At,C,b] = read_sedumi(’./dimacs/nb.mat’); >> [obj,X,y,Z,info] = sqlp(blk,At,C,b,OPTIONS);
3.3
Stopping criteria
We define X
n =
sj +
{j:νjs =0}
gap = hx, zi − −
{i:νiq =0}
nα 1 X X n α∈{s,q,l} j=1
µ(x, z) =
X
{i:νiq >0}
X
X
(
qi + |{k : νkl = 0}|
(3)
hxαj , zjα i if νjα = 0 0
(4)
otherwise.
νjs sj + log det(xsj zjs /νjs )
{j:νjs >0}
νiq 1 + log(γ(xqi )γ(ziq )/νiq )
−
X
{k:νkl >0}
νkl 1 + log(xlk zkl /νkl ) . (5)
Note that if n = 0, we define µ(x, z) = 0. The algorithm is stopped when any of the following cases occur. 1. solutions with the desired accuracy have been obtained, i.e., φ := max {relgap, pinfeas, dinfeas} ≤ OPTIONS.gaptol,
(6)
where relgap =
gap kA(x) − bk kAT (y) + z − ck , pinfeas = , dinfeas = . 1 + |hc, xi| + |bT y| 1 + kbk 1 + kck
2. primal infeasibility is suggested because bT y/kAT y + zk > 108 ; 3. dual infeasibility is suggested because −cT x/kAxk > 108 ;
11
4. slow progress is detected, measured by a rather complicated set of tests including relgap < max{pinfeas, dinfeas} ; 5. numerical problems are encountered, such as the iterates not being positive definite or the Schur complement matrix not being positive definite; or 6. the step sizes fall below 10−6 .
3.4
Initial iterates
Our algorithms can start with an infeasible starting point. However, the performance of these algorithms is quite sensitive to the choice of the initial iterate. As observed in [7], it is desirable to choose an initial iterate that at least has the same order of magnitude as an optimal solution of the SQLP. If a feasible starting point is not known, we recommend that the following initial iterate be used: y 0 = 0, (xsj )0 = ξjs Isj ,
(zjs )0 = ηjs Isj ,
j = 1, . . . , ns ,
(xqi )0 = ξiq eqi ,
(ziq )0 = ηiq eqi ,
i = 1, . . . , nq ,
(xl )0 = ξ l el ,
(z l )0 = η l el ,
(xu )0 = 0,
where Isj is the identity matrix of order sj , eqi is the first qi -dimensional unit vector, el is the vector of all ones, and (
√
n
o √ sj , max{kcsj kF , kasj,1 kF , . . . , kasj,m kF } ,
ξjs = max 10, ηjs = max 10 , ξiq
(
= max 10 ,
ηiq = max {10 , ξ
l
1 + |bk | sj , sj max 1≤k≤m 1 + kasj,k kF
√ √
qi ,
√
n
,
)
1 + |bk | qi max , q 1≤k≤m 1 + kAi (k, :)k
qi , max{kcqi k, kAqi (1, :)k, . . . , kAqi (m, :)k}},
√ √ = max 10 , nl , nl max
η l = max 10 ,
)
1 + |bk | , 1≤k≤m 1 + kAl (k, :)k
o √ nl , max{kcl k, kAl (1, :)k, . . . , kAl (m, :)k} .
By multiplying the identity matrix Isj by the factors ξjs and ηjs for the semidefinite blocks, and similarly for the quadratic and linear blocks, the initial iterate has a better chance of having the appropriate order of magnitude. The initial iterate above is set by calling infeaspt.m, with syntax
12
[X0,y0,Z0] = infeaspt(blk,At,C,b,options,scalefac), where options = 1 (default) corresponds to the initial iterate just described, and options = 2 corresponds to the choice where the blocks of X0, Z0 are scalefac times identity matrices or unit vectors, and y0 is a zero vector.
3.5
Preprocessing
Nearly dependent constraints. The primal-dual path-following algorithm we implemented assumes that the matrix A in (2) has full column rank. But in our software, the presence of (nearly) dependent constraints is detected automatically, and warning messages are displayed if such constraints exist. When this happens, the user has the option of removing these (nearly) dependent constraints by calling a preprocessing routine to remove them by setting OPTIONS.rmdepconstr = 1. The routine, checkdepconstr.m, we have coded to detect nearly dependent constraints is based on computing the sparse LDLT factorization of AAT . Such a method is fast but is not as reliable as the method that is based on sparse LU factorization of A. Detecting diagonal blocks. We provide the m-file, detect diag.m, to look for diagonal blocks in semidefinite blocks in the data: see Subsection 2.1 for the use of this subroutine. Detecting unrestricted blocks. We have provided a routine, detect ublk.m, to detect unrestricted variables that have been modeled as the difference of two nonnegative variables. The calling syntax is: [bblk,AAt,CC] = detect_ublk(blk,At,C); Complex data. In earlier versions, 2.3 or earlier, SDPT3 can directly handle complex data in SDP, i.e., the constraint matrices are hermitian matrices. However, as problems with complex data rarely occur in practice, and in an effort to simplify the code, we removed this flexibility from subsequent versions. But we intend to keep version 2.3 of the code available for users who wish to solve SDP problem (with no quadratic blocks) with complex data directly. Users can also solve an SDP with complex data using SDPT3-4.0. This is done by calling the m-file convertcmpsdp.m to convert the SDP into one with real data. But unlike the earlier versions, here we convert the problem into one with real data by doubling the size of the constraint matrices. Let B be an n × n hermitian matrix. The conversion is based on the following equivalence: B is positive semidefinite ⇔
"
B R −B I BI
BR
13
#
is positive semidefinite,
where B R and B I denote the real and imaginary parts of B, respectively. Note that since B is hermitian, B R is symmetric and B I is skew-symmetric. P Now suppose C, A1 , . . . Am are given n×n hermitian matrices. Then C− m k=1 yk Ak 0 if and only "
C R −C I CI
CR
#
−
m X
k=1
ykR
"
AR −AIk k AIk
AR k
#
−
m X
ykI
k=1
"
−AIk −AR k AR k
−AIk
#
0.
(7)
R I Notice that the matrices [−AIk , −AR k ; Ak , −Ak ] are skew-symmetric. For a complex SDP, the vector b must necessarily be real, and the linear term in the objective function in (D) is replaced by hb, y R i. Since the skew symmetric matrices in (7) do not affect the positiveness condition and y I does not appear in the objective function in (D), we can take yIk = 0, k = 1, . . . , m. Note that the conversion of a complex SDP into a real SDP based on (7) would double the storage and if the data is dense, the cost of each interior-point iteration for solving the resulting real SDP is about twice as expensive as that for solving the complex SDP directly. Suppose AA is an 1 × m cell array such that AA{k} = Ak . Then convertcmpsdp.m has the calling syntax:
[bblk,AAt,CC,bb] = convertcmpsdp(blk,AA,C,b); where AAt corresponds to the first m real symmetric constraint matrices in (7), CC corresponds to the real constant matrix in (7), and bb = bR . Rotated cones. Let Krn (n ≥ 3) be the rotated cone defined by Krn = {xr = [u; v; w] ∈ IRn : kwk2 ≤ 2uv, u, v ≥ 0}. Note the constant ”2” above. Define the symmetric as follows: √ √ 1/ 2 1/ 2 √ √ Tn = 1/ 2 −1/ 2
In−2
orthogonal matrix Tn ∈ IRn×n
.
It is easy to show that xr ∈ Krn if and only if xq := Tn xr ∈ Kqn , i.e., Tn Krn = Kqn . Thus we can always convert a rotated cone variable into one belonging to a second-order cone. In SDPT3-4.0, the user can code a rotated cone block consisting of several subblocks, say p of them of dimension ri1 , ....,rip , as follows: blk{i,1} = ’r’; blk{i,2} = [ri1 , ....,rip ]; Let D be the block diagonal matrix defined by D = diag (Tri1 , ..., Trip ). Internally, SDPT3 would convert such a rotated cone block and its associated data into a secondorder cone block as follows:
14
blk{i,1} = ’q’; blk{i,2} = [ri1 , ..., rip ]; At{i,1} = D*At{i,1}; C{i,1} = D*C{i,1};
4
Examples
For an user to solve his SQLP problem using SDPT3, the first task he needs to do is to code the problem data corresponding to the standard form in (P). The simplest way to learn how to generate the data of an SQLP problem in SDPT3 format is through examples. The subdirectory Examples in SDPT3 contains many such example files. Here we will just mention a few. Note that the user can also store the problem data in either the SDPA or SeDuMi format, and then use the m-files read sdpa.m or read sedumi.m to read the data into SDPT3.
4.1
MAXCUT problem
n be the space of n × n symmetric positive semidefinite matrices. Let B be the Let S+ weighted adjacency matrix of a graph. The SDP relaxation of the MAXCUT problem associated with B has the following form:
min hC, Xi s.t.
diag (X) = e,
n, X ∈ S+
where e is the vector of ones, and C = −(Diag (Be) − B)/4. It is clear that we need the cell array, blk{1,1}=’s’, blk{1,2}=n, to record the block structure of the problem. The constraint matrices can be constructed conveniently via an 1 × n cell array as follows: AA = cell(1,n); for k=1:n; AA{k}=spconvert([k,k,1;n,n,0]); end At = svec(blk,AA); For more details, see the m-file maxcut.m in the subdirectory Examples. (We could also create a version of the problem explicitly showing the low-rank structure; however, as the constraint matrices are so sparse, this would not be more efficient.)
15
4.2 D-optimal experiment design - an example with an explicit barrier term Given a set of points {v1 , . . . , vp } in IRn with n ≤ p, the D-optimal experiment design problem [31] needs to solve the following dual SQLP: max log det(Z) s.t.
Pp
+ z l = 0,
eT y
= 1,
T k=1 yk (−vk vk )
−y
+ Z
= 0,
n Z ∈ S++
z l ∈ IRp+ y ∈ IRp .
The associated problem data can be coded in SDPT3 format as follows: b = zeros(p,1); blk{1,1} = ’s’; blk{1,2} = n; AA = cell(1,p); for k=1:p; AA{k} = At(1) = svec(blk(1,:),AA); C{1,1} blk{2,1} = ’l’; blk{2,2} = p; At{2,1} = -speye(p); C{2,1} = blk{3,1} = ’u’; blk{3,2} = 1; At{3,1} = ones(1,p); C{3,1}
-vk*vk’; end = sparse(n,n); zeros(p,1); = 1;
Because the problem contains an explicit log-barrier term in the objective function, we also need to set up OPTIONS.parbarrier as follows: OPTIONS.parbarrier{1} = 1; OPTIONS.parbarrier{2} = zeros(1,p); OPTIONS.parbarrier{3} = 0; For more details, see the m-file Doptdesign.m in the subdirectory Examples. The constraint matrices corresponding to the semidefinite block in this example are all rank-one matrices. The user can explicitly code such structures for SDPT3 as follows: blk{1,1} = ’s’, blk{1,2} = n; blk{1,3} = ones(1,p); At{1,1} = []; At{1,2} = [v1,...,vp]; At{1,3} = -ones(p,1);
4.3
An LMI example
Consider the following LMI problem [3]: max −η s.t.
GY + Y GT −Y
Y − ηI Y11
0
−I 0
= 1,
16
(8) Y ∈ S n,
where G ∈ IRn×n . This problem can be viewed as a dual SDP with Y identified as a vector y in IRn(n+1)/2 . In this case, we have (As1 )T y = svec(Gsmat(y)+smat(y)GT ), where smat is the inverse of svec. The SDP data can be generated for SDPT3 as follows: blk{1,1} = ’s’; blk{1,2} = n; blk{2,1} = ’s’; blk{2,2} = n; blk{3,1} = ’s’; blk{3,2} = n; blk{4,1} = ’u’; blk{4,2} = 1; n2 = n*(n+1)/2; zz = sparse(n2,1); I = speye(n); At{1,1} = [lmifun(G,I), zz]; At{2,1} = [-lmifun(I/2,I), zz]; At{3,1} = [lmifun(I/2,I), svec(blk(1,:),-I)]; At{4,1} = [1, zz’]; C{1,1} = sparse(n,n); C{2,1} = -I; C{3,1} = sparse(n,n); C{4,1} = 1; b = [zz; -1]; In the above, lmifun(G,H) is a function (available in Examples) that generates the matrix representation of the linear map y ∈ IRn(n+1)/2 7→ svec(Gsmat(y)H T + Hsmat(y)GT ). For more details, see the m-file lmiexamp1.m in the subdirectory Examples.
4.4
Nearest correlation matrix problem
Given an n × n symmetric matrix H, the nearest correlation matrix problem is the following [12]: n min{kH − XkF : diag (X) = e, X ∈ S+ }. X
The above problem can be converted to the following SQLP: n min{eT1 y : diag (X) = e, svec(X) + [0, In2 ]y = svec(H), X ∈ S+ , y ∈ Qn2 +1 },
where n2 = n(n + 1)/2, In2 denotes the identity matrix of dimension n2 , and Qn2 +1 denotes the second-order cone of dimension n2 + 1. The corresponding SQLP data can be coded for SDPT3 as follows: blk{1,1} = ’s’; blk{1,2} = n; n2 = n*(n+1)/2; for k=1:n; AA{1,k} = spconvert([k,k,1; n,n,0]); end; matrepdiag = svec(blk(1,:),AA); At{1,1} = [matrepdiag{1}, speye(n2)]; blk{2,1} = ’q’; blk{2,2} = n2+1; At{2,1} = [sparse(n,n2+1); sparse(n2,1), speye(n2)]; b = [ones(n,1); svec(blk(1,:),H)]; C{1,1} = sparse(n,n); C{2,1} = [1; zeros(n2,1)]; For more details, see the m-file corrmat.m in the subdirectory Examples.
17
4.5
An example from distance geometry
Consider a graph G = (V, E, D) where V = {1, 2, . . . , n}, E, and D = (dij ) denote the nodes, edges, and associated weight matrix on the edges, respectively. The problem is to find points x1 , . . . , xn in IRp (for some p) such that the pairwise Euclidean distance between xi and xj is as close as possible to dij if (i, j) ∈ E. The associated minimization problem is the following: min
n X o kxi − xj k2 − d2ij : X := [x1 , . . . , xn ] ∈ IRp×n . (i,j)∈E
By noting that kxi − xj k2 = eTij X T Xeij , where eij = ei − ej , the above problem can P equivalently be written as min { (i,j)∈E |heij eTij , Y i − d2ij | : Y = X T X, X ∈ IRp×n }. P One of the SDP relaxations of the above problem is min { (i,j)∈E |heij eTij , Y i − d2ij | : n }, where the corresponding problem in standard form is given by Y ∈ S+ min
n X
(i,j)∈E
Let m = |E|. The SQLP data can be coded as follows:
blk{1,1} = ’s’; blk{1,2} = n; AA = cell(1,m); b = zeros(m,1); cnt = 0; for i = 1:n-1 for j = i+1:n if (D(i,j) ~= 0) cnt = cnt + 1; AA{cnt} = spconvert([i,i,1; i,j,-1; j,i,-1; j,j,1; n,n,0]); b(cnt) = D(i,j)^2; end end end At(1) = svec(blk(1,:),AA); C{1,1} = sparse(n,n); blk{2,1} = ’l’; blk{2,2} = 2*m; At{2,1} = [-speye(m), speye(m)]; C{2,1} = ones(2*m,1);
4.6
Norm minimization problem with complex data
Let B0 , . . . Bm be p × q matrices that are possibly complex. Consider the norm minimization problem: min{t : k
m X
k=1
xk Bk + B0 k2 ≤ t, x ∈ Cm , t ∈ IR},
where k · k2 denotes the matrix 2-norm. The problem above can equivalently be written as follows: max s.t.
o
− + − + − T 2 n α+ ij + αij : heij eij , Y i − αij + αij = dij , αij , αij ≥ 0 ∀ (i, j) ∈ E, Y ∈ S+ .
−t
m X
k=1
xR k
"
0
Bk
Bk∗
0
#
+
m X
k=1
xIk
"
0
iBk
(iBk )∗
0
18
#
− tI −
"
0
B0
B0∗
0
#
.
This is a complex SDP written in the format as in (D). Such a problem can be solve by SDPT3 as follows: blk{1,1} = ’s’; blk{1,2} = p+q; AA = cell(1,2*m+1); for k = 1:m; AA{1,k} = [zeros(p), Bk ; B0k , zeros(q)]; end for k = 1:m; AA{1,m+k} = [zeros(p), i*Bk ; -i*B0k , zeros(q)]; end AA{1,2*m+1} = -speye(p+q); C{1} = -[zeros(p), B0 ; B00 , zeros(q)]; b = [zeros(2*m,1); -1]; [bblk,AAt,CC,bb] = convertcmpsdp(blk,AA,C,b); [obj,X,y,Z] = sqlp(bblk,AAt,CC,bb); x = y(1:m) + i*y(m+[1:m]); t = y(2*m+1); For more details, see the m-file norm min.m in the subdirectory Examples.
4.7
Logarithmic Chebyshev approximation problem
This is an example that contains variables in a rotated cone. The orginal problem [16] is given by minx∈IRm max{log(fiT x)−log(di ) : i = 1, . . . , p}, which can equivalently be formulated as: min{s : t ≤ fiT x/di ≤ s, i = 1, . . . , p, 1 ≤ st}. Let F = [f1T ; . . . ; fpT ] and d = [d1 ; . . . ; dp ]. The latter problem can be formulated in the following standard dual form: max s.t.
−s
h h
i
− F, d, 0, 0 [x; s; t; u] ≥ 0 i
F, 0, −d, 0 [x; s; t; u] ≥ 0
h
i
0, I3 [x; s; t; u] ∈ Kr3
h
i
0, 0, 0, 1 [x; s; t; u] =
√
2.
The corresponding data for SDPT3 can be coded as follows: blk{1,1} = ’l’; blk{1,2} = p; blk{2,1} = ’l’; blk{2,2} = p; blk{3,1} = ’r’; blk{3,2} = 3; blk{4,1} = ’u’; blk{4,2} = 1; zz = sparse(p,1); At{1,1} = [-F, d, zz, zz]; At{2,1} = [F, zz, -d, zz]; At{3,1} = [sparse(3,m), speye(3)]; At{4,1} = [sparse(1,m+2), 1]; b = [zeros(m,1); -1; 0; 0];
C{1,1} C{2,1} C{3,1} C{4,1}
= = = =
zeros(p,1); zeros(p,1); zeros(3,1); sqrt(2);
For more details, see the m-file logchebyRcone.m in the subdirectory Examples.
19
4.8
Maximizing the geometric mean of affine functions
Another example with rotated cone variables comes from maximizing the geometric mean of nonnegative affine functions [16]: Π4i=1 (aTi x + bi )1/4
maxx∈IRm
aTi x + bi ≥ 0, i = 1, . . . , 4.
s.t.
The above can be reformulated as the following SQLP problem with rotated cone constraints: n √ o √ max t3 / 2 : 2yi = aTi x + bi , yi ≥ 0, i = 1, . . . , 4, t21 ≤ 2y1 y2 , t22 ≤ 2y3 y4 , t23 ≤ 2t1 t2 . The corresponding standard (dual) form is as follows: √ max t3 / 2 √ T √ a1 / 2 0 0 0 b1 / 2 √ √ aT / 2 0 0 0 b / 2 2 2 s.t.
0 T √ a3 / 2 T √ a4 / 2 0 0 0
0
4.9
1 0 0 0 √ x 0 0 0 b3 / 2 t1 √ 3 3 3 + 0 0 0 b / 2 ∈ Kr × Kr × Kr . 4 t2
0 1 0 1 0 0 0 1
t3
0
0 0 1
0 0 0 0
Conversion of problems into the standard form
SDP problems are usually not formulated in the standard form (P) or (D). It is often quite tedious to convert such problems into the standard form. As such, there is an increasing demand for interfaces to automate the conversion process. Currently, one of the few interfaces that is publicly available for SQLP solvers is YALMIP [15]. Here we shall just give an example on how an SDP with linear inequality constraints can be converted into the standard form given in the Introduction. Suppose we have an SDP of the following form: (P1 ) min s.t.
hcs , xs i As (xs ) ≤ b, xs ∈ Ksn .
That is, it has inequality instead of equality constraints. But by introducing a slack
20
variable xl , we can easily convert (P1 ) into standard form, namely, (P1∗ ) min s.t.
hcs , xs i +
hcl , xl i
As (xs ) +
Al xl
xs ∈ Ksn .
= b,
xl ∈ Klm ,
where cl = 0, and Al = Im×m . With our use of cell arrays to represent SQLP data, it is easy to take the problem data of (P1 ) and use them for the standard form (P1∗ ) as follows:
5
blk{1,1} = ’s’;
blk{1,2} = n;
At{1} = (As )T ;
C{1} = cs ;
blk{2,1} = ’l’;
blk{2,2} = m;
At{2} = speye(m);
C{2} = cl ;
Implementation details
The main step at each iteration of our algorithms is the computation of the search direction (∆x, ∆y, ∆z) from the symmetrized Newton equation with respect to some invertible block diagonal scaling matrix that is usually chosen as a function of the current iterate x, z.
5.1
The HKM search direction
Let Jiq
=
"
1
0
0 −Iqi −1
#
.
(9)
For the choice of the HKM scaling matrix [10, 14, 18, 28, 29], the search direction (∆x, ∆y, ∆z) is obtained from the following system of equations: As (∆xs ) + Aq (∆xq ) + Al ∆xl + Au ∆xu = Rp := b − As (xs ) − Aq (xq ) − Al xl − Au xu (As )T ∆y + ∆z s = Rds := cs − z s − (As )T y (Aq )T ∆y + ∆z q = Rdq := cq − z q − (Aq )T y (Al )T ∆y + ∆z l = Rdl := cl − z l − (Al )T y (Au )T ∆y
= Rdu := cu − (Au )T y
ns
nl
∆xs + H s (∆z s ) = Rcs := max{σµ(x, z), νjs }(zjs )−1 − xsj
∆xq + H q (∆z q ) = Rcq := max{σµ(x, z), νiq }(ziq )−1 − xqi ∆xl + H l (∆z l ) = Rcl := max{σµ(x, z), νkl }(zkl )−1 − xlk
21
(10)
j=1
nq
i=1 k=1
,
where σ ∈ (0, 1) is the centering parameter; (zjs )−1 and (zkl )−1 have the usual meaning, and (ziq )−1 := Jiq ziq /γ(ziq )2 . In the above,
ns
H s (∆z s ) = Hjs (∆zjs ) := 12 ((zjs )−1 ∆zjs xsj + xsj ∆zjs (zjs )−1 )
H q (∆z q ) = Hiq (∆ziq ) := −
j=1
,
hxqi , ziq i q q q q −1 T q q −1 q T q nq , q 2 Ji ∆zi + xi ((zi ) ) ∆zi + (zi ) (xi ) ∆zi i=1 γ(zi )
H l (∆z l ) = Diag (xl )Diag (z l )−1 ∆z l . We compute the search direction via a Schur complement equation as follows (the reader is referred to [1] and [23] for details). First compute ∆y from the Schur complement equation "
|
where M
=
ns X
j=1
M
Au
(Au )T
0
{z
M
Asj Hjs (Asj )T |
{z
}
Mjs
+
nq X i=1
#" }
∆y ∆xu
#
=
"
h Rdu
#
(12)
Aqi Hiq (Aqi )T + Al H l (Al )T |
{z
Miq
}
|
{z
Ml
}
(13)
h = Rp + As H s (Rds ) − Rcs + Aq H q (Rdq ) − Rcq + Al H l (Rdl ) − Rcl . (The notation in (13) should be interpreted as follows: the kth columns of Mjs and Miq are Asj Hjs (asj,k ) and Aqi Hiq (aqi,k ), with aqi,k the kth column of (Aqi,k )T . Note that the matrices Mjs , Miq , M l are all symmetric positive definite.) Then compute ∆x and ∆z from the equations
5.2
∆z s = Rds − (As )T ∆y,
∆z q = Rdq − (Aq )T ∆y,
∆z l = Rdl − (Al )T ∆y
∆xs = Rcs − H s (∆z s ),
∆xq = Rcq − H q (∆z q ),
∆xl = Rcl − H l (∆z l ).
The NT search direction
The user also has the choice of using the NT direction [21, 28, 29]. Let wjs be the unique positive definite matrix such that wjs zjs wjs = xsj . Let s √ γ(ziq ) 1 q 2 q q q q q q ωi = ξi = q zi + ωi Ji xi , ti = q J q ξq . (14) q , γ(xi ) ωi ωi γ(ξiq ) i i In this case, the search direction (∆x, ∆y, ∆z) satisfies the same system as in (10) except that H s and H q are replaced by
H s (∆z s ) = Hjs (∆zjs ) := wjs ∆zjs wjs
H q (∆z q ) = Hiq (∆ziq ) := −
ns
j=1
,
1 q q q q T q nq J ∆z + t (t ) ∆z i i i i i=1 . (ωiq )2 i
22
(15)
(11)
5.3
Choice of search direction
The current version of the code allows only two search directions, HKM and NT. In older versions, version 2.3 or earlier, also allowed the AHO direction of Alizadeh, Haeberly, and Overton [1] and the GT direction [25], but these are uncompetitive when the problems are of large scale. We intend to keep version 2.3 of the code available for those who wish to experiment with these other search directions, which tend to give more accurate results on smaller problems. For the HKM and NT search directions, our computational experience on problems tested in Section 7 is that the HKM direction is almost universally faster than NT on problems with semidefinite blocks, especially for sparse problems with large semidefinite blocks. The reason that the latter is slower is because computing the NT scaling matrix wjs requires a full eigenvalue decomposition. This computation can dominate the work at each interior-point iteration when the problem is sparse. The NT direction, however, was faster on sparse SOCP problems. The reason for this behavior is not hard to understand. By comparing the formulae for Hiq for the HKM and NT directions in (11) and (15), it is clear that more computation is required to assemble the Schur complement matrix and more low-rank updating is necessary for the former direction.
5.4
Computation of the Schur complement matrix
Generally, the most expensive part in each iteration of Algorithm IPC lies in the computation and factorization of the Schur complement matrix M defined in (12). And this depends critically on the size and density of M . Note that the density of this matrix depends on two factors: (i) The density of As , Aq , and Al , and (ii) any additional fill-in introduced because of the terms H s , H q , and H l in (13).
5.4.1
Semidefinite blocks
For problems with semidefinite blocks, the contribution by the jth semidefinite block to M is given by Mjs := Asj Hjs (Asj )T . The matrix Mjs is generally dense even if Asj is sparse. The computation of each entry of Mjs involves matrix products, which has the form (Mjs )αβ
=
(
hasj,α , xsj asj,β (zjs )−1 i for the HKM direction. hasj,α , wjs asj,β wjs i
for the NT direction.
This computation can be very expensive if it is done naively without properly exploiting the sparsity that is generally present in the constraint matrices in Asj . In our earlier papers [23, 27], we discussed briefly how sparsity of Asj is exploited in our implementation by following the ideas presented by Fujisawa, Kojima, and Nakata in [7]. Further details on the efficient implementation of these ideas are given in [30]. When the constraint matrices have low-rank structures as described in Section 2.2, we can also compute the element (Mjs )α,β as follows: (Mjs )αβ = Tr(VeβT Vα Dα VαT Vbβ Dβ ),
23
where Veβ = xsj Vβ , and Vbβ = (zjs )−1 Vβ if the HKM direction is used; and Veβ = Vbβ = wjs Vβ if the NT direction is used. Assume for simplicity that all the constraint matrices associated with the jth semidefinite block are dense and low-rank, i.e., p = 0 in Section 2.2. Suppose that the matrices Vek , Vbk , k = 1, . . . , m, are pre-computed (at P Pm 2 the cost of Θ(s2j m k=1 rj,k ) flops). Then it would take an additional Θ(sj ( k=1 rj,k ) ) s s flops to compute Mj since each element (Mj )αβ can be computed at Θ(sj rj,α rj,β ) flops. In contrast, without exploiting the low-rank structures, it would take Θ(s3j m)+ Θ(s2j m2 ) flops to compute Mjs . If the average rank of the constraint matrices is r, then the latter complexity is Θ(sj /r 2 ) times larger than the former of Θ(s2j mr) + Θ(sj m2 r 2 ). Thus it is definitely advantageous to exploit low-rank structures. As example, we generated a random SDP with low rank structure using the m-file randlowranksdp.m described in Section 2.2 with n = 200 and m = 1000, the solver sqlp.m runs about 6 times faster when the low-rank structure is exploited.
5.4.2
Quadratic and linear blocks
For the linear block, H l is a diagonal matrix and it does not introduce any additional fill-in. This matrix does, however, affect the conditioning of the Schur complement matrix. From equation (13), it is easily shown that the contribution of the quadratic blocks to the matrix M is given by Miq =
hxq , z q i q q q q q q q − γ 2i(z qi) Ai Ji (Ai )T + ui (vi )T + vi (ui )T , for HKM direction i
− 1q 2 Aq J q (Aq )T + wq (wq )T i i i i i (ω )
(16)
for NT direction
i
uqi
Aqi xqi ,
where = viq = Aqi (ziq )−1 , wiq = Aqi tqi . In the rest of this subsection, we focus our discussion on the HKM direction, but the same holds true for the NT direction. The appearance of the outer-product terms in the equation above is potentially alarming. If the vectors uqi , viq are dense, then even if Aqi is sparse, the corresponding matrix Miq , and hence the Schur complement matrix M , will be dense. A direct factorization of the resulting dense matrix will be very expensive for even moderately large m. The density of the matrix Miq depends largely on the particular problem structure. When the problem has many small quadratic blocks, it is often the case that each block appears in only a small fraction of the constraints. In this case, all Aqi matrices are sparse and the vectors uqi and viq turn out to be sparse vectors for each i. Consequently, the matrices Miq remain relatively sparse for these problems. As a result, M is also sparse and it can be factorized directly with reasonable cost. This behavior is typical for all nql and qssp problems from the DIMACS library. The situation is drastically different for problems where one of the quadratic blocks, say the ith block, is large. For such problems the vectors uqi , viq are typically dense, and therefore, Miq is likely be a dense matrix even if the data Aqi is sparse. However, observe that Miq is a rank-two perturbation of a sparse matrix when Aqi (Aqi )T is sparse. In such a situation, it is advantageous to use the dense-column handling
24
technique described in Section 5.7 to reduce the computational cost in solving (12). This approach helps tremendously on the scheduling problems from the DIMACS library. To apply the dense-column handling technique, we need to modify the sparse portion of the matrix Miq slightly. Since the diagonal matrix −Ji has a negative component, the matrix −Aqi Jiq (Aqi )T need not be a positive definite matrix, and therefore the Cholesky factorization of the sparse portion of Miq need not exist. To overcome this difficulty, we use the following identity: Miq =
hxqi , ziq i q q T A (A ) + uqi (viq )T + viq (uqi )T − ki kiT , γ 2 (ziq ) i i
(17)
√ where ki = 2hxqi , ziq i/γ 2 (ziq ) Aqi (:, 1). Note that if Aqi is a large sparse matrix with a few dense columns, we can also explicitly separate the outer-product terms contributed by these dense columns from the sparse part of Aqi (Aqi )T in (17).
5.5
Solving the Schur complement equation
The linear system (12) typically becomes more and more ill-conditioned as µ creases to 0. Thus iterative refinement is generally recommended to improve accuracy of the computed solution. An even better approach to solve (12) is a preconditioned symmetric quasi-minimal residual method (PSQMR) [5] with preconditioner computed based on the following analytical expression of M−1 :
M−1 =
M −1 − M −1 Au S −1 (Au )T M −1 M −1 Au S −1 S −1 (Au )T M −1
−S −1
,
dethe via the
(18)
where S = (Au )T M −1 Au . Note that for a given vector [u; v], M−1 [u; v] can be evaluated efficiently as follows: u ˆ
= M −1 u
t
= S −1 (Au )T u ˆ−v
M−1 [u; v] = [ˆ u − M −1 Au t; t].
Thus if the Cholesky factorization of M and that of S are computed, then each evaluation involves solving four triangular linear systems for M and two triangular linear systems for S. We should mention that the state-of-the-art Cholesky factorization softwares are highly developed and optimized. Thus our preference is to solve a linear system via Cholesky factorizations whenever possible. For most SDP problems, the matrix M is typically dense even when the constraint matrices are sparse. In this case, we use the routine chol (based on the LAPACK routine dpotrf) in Matlab to compute the Cholesky factorization of a dense matrix. For most sparse SOCP problems, the matrix M is usually sparse after densecolumn handling. Let Msp be the sparse part of M after dense-column handling.
25
In this case, the Cholesky factorization routine chol for a dense matrix is not efficient enough since it does not exploit sparsity. To factorize the sparse matrix Msp more efficiently, we imported (with slight modifications) the sparse Cholesky solver in SeDuMi [22], which is a C translation of the Fortran programs developed by Esmond Ng, Barry Peyton, and Joseph Liu for sparse Cholesky factorization [19]. When SDPT3 uses the sparse Cholesky solver, it first performs a symmetric re-ordering on Msp and generates a symbolic factorization of the re-ordered Msp to determine the pivot order by examining the sparsity structure of this matrix carefully. Then, this pivot order is re-used in later iterations to compute the Cholesky factors. Contrary to the case of linear programming, however, the sparsity structure of Msp can change during the course of interior-point iterations for SOCP problems. If this happens, the symbolic factorization has to be recomputed. We detect changes in the sparsity structure of Msp by monitoring the nonzero elements of Msp . Since the default initial iterates we use for an SOCP problem are unit vectors but subsequent iterates are not, there is always a change in the sparsity pattern of Msp after the first iteration. After the second iteration, the sparsity pattern remains unchanged for most problems, and only one more change occurs in a small fraction of the test problems in the DIMACS library. The effect of using a sparse Cholesky solver for sparse SOCP problems was dramatic. We observed speed-ups of up to two orders of magnitude. In our implementation, SDPT3 automatically makes a choice between Matlab’s built-in chol routine and the sparse Cholesky solver based on the density of M . The cutoff density is specified in the parameter OPTIONS.spdensity. The approach of solving (12) by the SQMR method with preconditioner (18) works reasonably well if the following conditions are satisfied: (i) the number of columns of Au is small and Au is well-conditioned; (ii) the matrix M is not extremely illconditioned. (iii) the matrix S is not extremely ill-conditioned. However, when these conditions are not satisfied, preconditioning (12) based on (18) may not be advisable because either (a) computing S becomes very expensive due to large number of columns in Au , or (b) the computed preconditioner based on (18) is no longer an accurate approximation of M−1 . Note that S is typically much more ill-conditioned than Au , especially when Au is ill-conditioned. When conditions (i)–(iii) are not satisfied, it is advisable to use an LDLT factorization of the symmetric indefinite matrix M to compute an approximation of M−1 . But unfortunately the state-of-the-art LDLT factorization software available in the public domain is not as highly developed as its counterpart for Cholesky factorization, especially for sparse matrices. When the use of LDLT factorization of M is unavoidable, we use the publicly available Fortran subroutine MA47 from the Harwell Subroutine Library [9] to compute such a factorization if M is sparse. When M is dense, the implementation we have at the moment is a little bit complicated. By rights, we should use the LDLT factorization routine dsysvx in LAPACK to compute the required factorization for M, but we have yet to modify and incorporate that routine into SDPT3. At the moment, we simply use the Matlab routine lu to compute an LU factorization of M, and use the computed LU factors to precondition the BiCGSTAB iterative method used to solve (12). Note that because the preconditioner in the latter case is no longer symmetric,
26
we have to replace the SQMR method by a nonsymmetric iterative method such as the BiGSTAB method.
5.6
Internal handling of unrestricted blocks
As mentioned in the last sub-section, solving the symmetric indefinite system (12) can potentially be very expensive when Au is ill-conditioned or has a large number of columns because computing an LDLT factorization of a sparse matrix can be much more costly than that for a symmetric positive definite matrix of the same dimension. It is possible to avoid the need to solve a symmetric indefinite system if we reformulate the equality constraint in (D) as u = cu , (Au )T y + z+
u ≥0 z+
u = −cu , −(Au )T y + z−
u ≥ 0, z−
with the corresponding primal variable xu expressed as xu = xu+ − xu− ,
xu+ , xu− ≥ 0.
In this case, the system (12) is replaced by
u −1 u −1 M + Au Diag (xu+ )Diag (z+ ) (Au )T + Au Diag (xu− )Diag (z− ) (Au )T ∆y = rhs
where rhs denotes the right-hand-side vector. Notice that in contrast to (12), the coefficient matrix is now symmetric positive definite. But such a reformulation is not without difficulties. In fact, the variables xu+ , xu− u , z u tend to become extremely small as the interiortend to become very large and z+ − point iteration progresses, and this generally makes the component matrices, u )−1 (Au )T and Au Diag (xu )Diag (z u )−1 (Au )T , extremely ill-conditioned. Au Diag (xu+ )Diag (z+ − − Fortunately, the following heuristic to modify the vectors xu+ , xu− can typically ameliorate such an ill-conditioning problem: xu+ := xu+ − 0.8 min(xu+ , xu− ),
xu− := xu− − 0.8 min(xu+ , xu− ).
This modification does not change the original variable xu but does slow down the growth of xu+ , xu− . After these modified vectors have been obtained, we also add u , z u . Such a modification in z u , z u ensures that positive perturbations the vectors z+ − + − they approach 0 at the same rate as µ, and thus prevents the dual problem (D) from approaching the equality constraint too closely prematurely. In the current implementation of SDPT3, we always reformulate an unrestricted vector by the difference of 2 non-negative vectors.
5.7
Dense-column handling
Here we describe our technique to handle dense columns when M is a low-rank perturbation of a sparse matrix. In such a case, the Schur complement matrix M can be written in the form M = Msp + U DU T
27
(19)
where Msp is a sparse symmetric positive semidefinite matrix, U has only few columns, and D is a non-singular matrix. If Msp is positive definite, then we can solve (12) by solving a slightly larger but sparse linear system as follows. Let λ = DU T ∆y. It is easy to show that (12) is equivalent to the following linear system:
Msp
(Au )T
UT
Au
U
0
0
0
−D−1
∆y
h
∆xu = Ru . d
λ
(20)
0
We can use the same method described in Section 5.5 to solve (20).
5.8 User supplied routine to compute Schur complement matrix The current version of SDPT3 allows the user to supply specialized routines to compute the Schur complement matrices Mjs corresponding to the semidefinite blocks. The specialized routine to compute Mjs should have first line that look like: function schurmat = schurfun_jth(U,V,schurfun_jth_par); where the input arguments U and V should correspond to xsj and (zjs )−1 if the HKM direction is used; and they should correspond to the NT scaling matrix wjs if the NT direction is used. The third optional argument schurfun jth par can be a structure array that stores the parameters needed inside the function schurfun jth.m. The user can tell SDPT3 to use the specialized routine by setting the L× 1 cell array OPTIONS.schurfun as follows: set OPTIONS.schurfun{j} = schurfun jth if Mjs is to be computed by the specialized routine coded in the function schurfun jth.m; otherwise set OPTIONS.schurfun{j} = []. If the function schurfun jth.m requires some parameters, then the L × 1 cell array OPTIONS.schurfun par must also be set correspondingly as follows: set OPTIONS.schurfun par{j} = schurfun jth par; otherwise set OPTIONS.schurfun par{j} = []. Below is an example on we how use the specialized routine mcpschur.m in the subdirectory Examples to compute the Schur complement matrix when solving the SDP problem mcp250-1.dat-s. >> [blk,At,C,b] = read_sdpa(’./sdplib/mcp250-1.dat-s’); >> OPTIONS.schurfun{1} = ’mcpschur’; >> [obj,X,y,Z]=sqlp(blk,At,C,b,OPTIONS); In the above example, there is no need to set the cell array OPTIONS.schurfun par since the function mcpschur.m does not need any additional parameters.
5.9
Step-length computation
Once a direction ∆x is computed, a full step will not be allowed if x + ∆x violates the conic constraints. Thus, the next iterate must take the form x + α∆x for an
28
appropriate choice of the step-length α. In this subsection, we discuss an efficient strategy to compute the step-length α. For semidefinite blocks, it is straightforward to verify that, for the jth block, the maximum allowed step-length that can be taken without violating the positive semidefiniteness of the matrix xsj + αsj ∆xsj is given as follows: αsj
−1 , λmin ((xsj )−1 ∆xsj ) = ∞
if the minimum eigenvalue λmin is negative
(21)
otherwise.
If the computation of eigenvalues necessary in αsj above becomes expensive, then we resort to finding an approximation of αsj by estimating extreme eigenvalues using Lanczos iterations [24]. This approach is quite accurate in general and represents a good trade-off between the computational effort versus quality of the resulting stepsizes. For quadratic blocks, the largest step-length αqi that keeps the next iterate feasible with respect to the ith quadratic cone can be computed as follows. Let ai = γ(∆xqi )2 ,
bi = h∆xqi , Jiq xqi i,
ci = γ(xqi )2 ,
di = b2i − ai ci ,
where Jiq is the matrix defined in (9). We want the largest positive α ¯ for which 2 ai α + 2bi α + ci > 0 for all smaller positive α’s, which is given by √ −b − di i if ai < 0 or bi < 0, ai ≤ b2i /ci ai −ci αqi = if ai = 0, bi < 0 2bi ∞ otherwise.
For the linear block, the maximum allowed step-length αlk for the kth component is given by αlk
l −xk , = ∆xlk
if ∆xlk < 0
∞
otherwise.
Finally, an appropriate step-length α that can be taken in order for x+α∆x to satisfy all the conic constraints takes the form
α = min 1, γ min αsj , γ min αqi , γ min αlk , 1≤j≤ns
1≤i≤nq
1≤k≤nl
(22)
where γ (known as the step-length parameter) is typically chosen to be a number slightly less than 1, say 0.98, to ensure that the next iterate x + α∆x stays strictly in the interior of all the cones. For the dual direction ∆z, we let the analog of αsj , αqi and αlk be βjs , βiq and βkl , respectively. Similar to the primal direction, the step-length that can be taken by the dual direction ∆z is given by
β = min 1, γ min βjs , γ min βiq , γ min βkl . 1≤j≤ns
1≤i≤nq
29
1≤k≤nl
(23)
6
Distances to infeasibilities
Let d = (A, c, b) be the SQLP data assocated with (P ) and (D). Let FP (d) and FD (d) be the feasible regions of (P ) and (D) respectively. It is often of interest to know whether the interiors, FP◦ (d) and FD◦ (d), are empty, and how “thick” these regions are. A natural quantitative measure of “thickness” of FP (d) and FD (d) is the concept of primal distance to infeasibility defined by Renegar [?]: ρP (d) = inf{k∆dk : FP (d + ∆d) = ∅},
ρD (d) = inf{k∆dk : FD (d + ∆d) = ∅}.
With appropriately chosen norm in the above definitions, the computation of ρD (d) amounts to solving an SQLP problem with roughly the same dimension and structure as the original primal instance. Unfortunately, the computation of ρP (d) is extremely costly, which requires solving 2m SQLP problems each with roughly the same dimension and structure as the original dual instance; see [4]. However, one is typically interested in the magnitudes of ρP (d) and ρD (d) rather than the exact values. It turns out that the following cheaper upper estimates proposed by Freund [?] usually give enough information about the size of FP (d) and FD (d):
gP (d) = inf max{kxk,
kxk 1 , } : A(x) = b, x ∈ K dist(x, ∂K) dist(x, ∂K)
kzk 1 gD (d) = inf max{kzk, , } : AT (y) + z = c, z ∈ K ∗ . dist(x, ∂K) dist(x, ∂K) It is readily shown that 1/gP (d) ≥ ρP (d) and 1/gD (d) ≥ ρD (d), and gP (d) = ∞ ⇔ ρP (d) = 0, gD (d) = ∞ ⇔ ρD (d) = 0. Freund showed that gP (d) (gD (d)) can be computed at the cost of solving an SQLP problem with roughly the same dimension and and structure as the original primal (dual) instance. In the current release of SDPT3, we include the following m-files to compute gP (d) and gD (d): function gp = gpcomp(blk,At,C,b); function gd = gdcomp(blk,At,C,b);
7
Computational results
Here we describe the results of our computational testing of SDPT3-4.0 using the default parameters, on problems from the following sources: 1. SDPLIB collection of Borchers, available at http://www.nmt.edu/∼borchers/sdplib.html 2. DIMACS Challenge test problems, available at http://dimacs.rutgers.edu/Challenges/Seventh/Instances/
30
3. Sparse SDPs from structural optimization, available at http://www2.am.uni-erlangen.de/∼kocvara/pennon/problems.html 4. Sparse SDP collection of Hans Mittelmann, available at ftp://plato.asu.edu/pub/sdp/ 5. SDPs from electronic structure calculations, available at http://www.cims.nyu.edu/∼mituhiro/software.html 6. SDPs from polynomial optimizations [11]. 7. SOCP problems generated by the Matlab FIR filter toolbox, available at http://www.csee.umbc.edu/∼dschol2/opt.html Our results were obtained on a Pentium IV PC (3.0GHz) with 4G of memory running Linux, using Matlab 7.0. Figure 1 shows the performance of SDPT3-4.0 on a total of about 300 SQLP problems. It shows that SDPT3 was able to solve 80% of the problems to an accuracy of at least 10−6 in the measure φ defined in (6). Performance of SDPT3 on 306 SQLP problems (HKM direction) 2
accuracy exponent attained
0
−2
−4
−6
−8
−10 0
20
40 60 Percentage of problems solved
80
100
Figure 1: The accuracy exponent is defined to be log10 (φ), where φ is defined as in (6). DIMACS error measures
Appendix: A primal-dual infeasible-interior-point algorithm Here we give a pseudo-code for the algorithm we implemented. Note that this description makes references to earlier sections where details related to the algorithm are explained.
31
Algorithm IPC. Suppose we are given an initial iterate (x0 , y 0 , z 0 ) with x0 , z 0 strictly satisfying all the conic constraints. Decide on the type of search direction to use. Set γ 0 = 0.9. For k = 0, 1, . . . (Let the current and the next iterate be (x, y, z) and (x+ , y + , z + ) respectively. Also, let the current and the next step-length parameter be denoted by γ and γ + respectively.) • Compute µ(x, z) defined in (5), and the accuracy measure φ defined in (6). Stop the iteration if φ is sufficiently small. • (Predictor step) Solve the linear system (12) with σ = 0 in the right-side vector (14). Denote the solution of (10) by (δx, δy, δz). Let αp and βp be the steplengths defined as in (22) and (23) with ∆x, ∆z replaced by δx, δz, respectively. • Take σ to be
µ(x + αp δx, z + βp δz) σ = min 1, µ(x, z)
e
,
where the exponent e is chosen as follows: e =
(
max[1, 3 min(αp , βp )2 ] if µ(x, z) > 10−6 , if µ(x, z) ≤ 10−6 .
1
• (Corrector step) Solve the linear system (12) with Rc in the the right-hand side vector (14) replaced by b τ = Rτ − Mehrotra-corrector term generated from δxτ and δz τ , R c c
τ ∈ {s, q, l}.
Denote the solution of (10) by (∆x, ∆y, ∆z). • Update (x, y, z) to (x+ , y + , z + ) by x+ = x + α ∆x,
y + = y + β ∆y,
z + = z + β ∆z,
where α and β are computed as in (22) and (23) with γ chosen to be γ = 0.9 + 0.09 min(αp , βp ). • Update the step-length parameter by γ + = 0.9 + 0.09 min(α, β).
References [1] F. Alizadeh, J.-P. A. Haeberly, and M. L. Overton, Primal-dual interior-point methods for semidefinite programming: convergence results, stability and numerical results, SIAM J. Optimization, 8 (1998), pp. 746–768. [2] B. Borchers, SDPLIB 1.2, a library of semidefinite programming test problems, Optimization Methods and Software, 11 & 12 (1999), pp. 683–690. Available at http://www.nmt.edu/~borchers/sdplib.html.
32
[3] S. Boyd, L. El Ghaoui, E. Feron, and V. Balakrishnan. Linear Matrix Inequalities in System and Control Theory. SIAM Studies in Applied Mathematics. SIAM, Philadelphia, USA, 1994 [4] R.M. Freund, F. Ord´ on ˜ez, and K.-C. Toh, Behavioral Measures and their Correlation with IPM Iteration Counts on Semi-Definite Programming Problems, preprint, 2005. [5] R. W. Freund and N. M. Nachtigal, A new Krylov-subspace method for symmetric indefinite linear systems, Proceedings of the 14th IMACS World Congress on Computational and Applied Mathematics, Atlanta, USA, W.F. Ames ed., July 1994, pp. 1253–1256. [6] K. Fujisawa, M. Kojima, K. Nakata, and M. Yamashita, SDPA (SemiDefinite Programming Algorithm) User’s manual — version 6.2.0, Research Report B308, Department Mathematical and Computing Sciences, Tokyo Institute of Technology, December 1995, revised September 2004. [7] K. Fujisawa, M. Kojima, and K. Nakata, Exploiting sparsity in primal-dual interior-point method for semidefinite programming, Mathematical Programming, 79 (1997), pp. 235–253. [8] G. H. Golub and C. F. Van Loan, Matrix Computations, 2nd ed., Johns Hopkins University Press, Baltimore, MD, 1989. [9] Harwell Subroutine Library: http://www.cse.clrc.ac.uk/Activity/HSL [10] C. Helmberg, F. Rendl, R. Vanderbei, and H. Wolkowicz, An interior-point method for semidefinite programming, SIAM Journal on Optimization, 6 (1996), pp. 342–361. [11] D. Henrion, private communication. [12] N. J. Higham, Computing the nearest correlation matrix — a problem from finance, IMA J. Numerical Analysis, 22 (2002), pp. 329–343. [13] N. J. Higham, Accuracy and Stability of Numerical Algorithms, SIAM, Philadelphia, 1996. [14] M. Kojima, S. Shindoh, and S. Hara, Interior-point methods for the monotone linear complementarity problem in symmetric matrices, SIAM J. Optimization, 7 (1997), pp. 86–125. [15] J. L¨ ofberg, A Toolbox for Modeling and Optimization in MATLAB, Proceedings of the CACSD Conference, 2004, Taipei, Taiwan. Available at http://control.ee.ethz.ch/~joloef/yalmip.php [16] M. S. Lobo, L. Vandenberghe, S. Boyd and H. Lebret, Applications of Secondorder Cone Programming, Linear Algebra Appl., 284 (1998), pp.193–228. [17] S. Mehrotra, On the implementation of a primal-dual interior point method, SIAM J. Optimization, 2 (1992), pp. 575–601. [18] R. D. C. Monteiro, Primal-dual path-following algorithms for semidefinite programming, SIAM J. Optimization, 7 (1997), pp. 663–678.
33
[19] J.W. Liu, E.G. Ng, and B.W. Peyton, On finding supernodes for sparse matrix computations, SIAM J. Matrix Anal. Appl., 1 (1993), pp. 242–252. [20] G. Pataki and S. Schmieta, The DIMACS library of mixed semidefinite-quadraticlinear programs. Available at http://dimacs.rutgers.edu/Challenges/Seventh/Instances [21] Yu. E. Nesterov and M. J. Todd, Self-scaled barriers and interior-point methods in convex programming, Math. Oper. Res., 22 (1997), pp. 1–42. [22] J. F. Sturm, Using SeDuMi 1.02, a Matlab toolbox for optimization over symmetric cones, Optimization Methods and Software, 11 & 12 (1999), pp. 625–653. [23] M. J. Todd, K. C. Toh, and R. H. T¨ ut¨ unc¨ u, On the Nesterov-Todd direction in semidefinite programming, SIAM J. Optimization, 8 (1998), pp. 769–796. [24] K. C. Toh, A note on the calculation of step-lengths in interior-point methods for semidefinite programming, Computational Optimization and Applications, 21 (2002), pp. 301–310. [25] K. C. Toh, Some new search directions for primal-dual interior point methods in semidefinite programming, SIAM J. Optimization, 11 (2000), pp. 223–242. [26] K. C. Toh, Primal-dual path-following algorithms for determinant maximization problems with linear matrix inequalities, Computational Optimization and Applications, 14 (1999), pp. 309–330. [27] K. C. Toh, M. J. Todd, and R. H. T¨ ut¨ unc¨ u, SDPT3 — a Matlab software package for semidefinite programming, Optimization Methods and Software, 11/12 (1999), pp. 545-581. [28] T. Tsuchiya, A polynomial primal-dual path-following algorithm for second-order cone programming, Technical Report, The Institute of Statistical Mathematics, Minato-Ku, Tokyo, October 1997. [29] T. Tsuchiya, A convergence analysis of the scaling-invariant primal-dual pathfollowing algorithms for second-order cone programming, Optimization Methods and Software, 11/12 (1999), pp. 141–182. [30] R. H. T¨ ut¨ unc¨ u, K. C. Toh, and M. J. Todd, Solving semidefinite-quadratic-linear programs using SDPT3, Mathematical Programming Ser. B, 95 (2003), pp. 189– 217. [31] L. Vandenberghe, S. Boyd, and S.-P. Wu, Determinant maximization with linear matrix inequalities, SIAM J. Matrix Analysis and Applications, 19 (1998), pp. 499–533.
34
problem
35
arch0 arch2 arch4 arch8 control1 control2 control3 control4 control5 control6 control7 control8 control9 control10 control11 gpp100 gpp124-1 gpp124-2 gpp124-3 gpp124-4 gpp250-1 gpp250-2 gpp250-3 gpp250-4 gpp500-1 gpp500-2 gpp500-3 gpp500-4 hinf1 hinf2
m | ns ; nq ; nl ; nu
it.
primal obj
dual obj
err1
err3
err5
err6
174 | 161; ; 174; 174 | 161; ; 174; 174 | 161; ; 174; 174 | 161; ; 174; 21 | 15; ; ; 66 | 30; ; ; 136 | 45; ; ; 231 | 60; ; ; 351 | 75; ; ; 496 | 90; ; ; 666 | 105; ; ; 861 | 120; ; ; 1081 | 135; ; ; 1326 | 150; ; ; 1596 | 165; ; ; 101 | 100; ; ; 125 | 124; ; ; 125 | 124; ; ; 125 | 124; ; ; 125 | 124; ; ; 251 | 250; ; ; 251 | 250; ; ; 251 | 250; ; ; 251 | 250; ; ; 501 | 500; ; ; 501 | 500; ; ; 501 | 500; ; ; 501 | 500; ; ; 13 | 14; ; ; 13 | 16; ; ;
26 24 22 24 17 21 21 21 23 22 24 21 21 25 26 15 17 15 14 17 17 16 15 14 21 16 15 17 21 21
-5.66517269-1 -6.71515401-1 -9.72627407-1 -7.05697992 0 -1.77846269 1 -8.30000364 0 -1.36332672 1 -1.97942358 1 -1.68836048 1 -3.73043552 1 -2.06250645 1 -2.02863293 1 -1.46754201 1 -3.85329154 1 -3.19586089 1 4.49435469 1 7.34307507 0 4.68622922 1 1.53014124 2 4.18987602 2 1.54449168 1 8.18689572 1 3.03539317 2 7.47328311 2 2.53205446 1 1.56060388 2 5.13017612 2 1.56701880 3 -2.03282194 0 -1.09676614 1
-5.66517274-1 -6.71515409-1 -9.72627420-1 -7.05698005 0 -1.77846267 1 -8.29999999 0 -1.36332665 1 -1.97942305 1 -1.68836008 1 -3.73044256 1 -2.06250748 1 -2.02863711 1 -1.46754272 1 -3.85330586 1 -3.19586886 1 4.49435488 1 7.34307566 0 4.68622934 1 1.53014125 2 4.18987613 2 1.54449168 1 8.18689580 1 3.03539321 2 7.47328304 2 2.53205438 1 1.56060387 2 5.13017602 2 1.56701879 3 -2.03271083 0 -1.09673573 1
5.5-8 2.8-9 5.4-9 1.4-7 5.9-9 2.0-7 4.7-7 3.1-7 4.3-7 1.1-6 6.6-7 7.7-8 2.9-7 7.4-7 6.4-7 2.9-8 6.2-9 3.3-8 3.8-8 4.1-8 1.0-9 2.2-8 8.2-8 8.2-8 9.0-11 4.4-9 2.8-9 1.7-8 5.8-8 6.2-7
3.9-14 3.7-14 5.0-14 4.7-13 7.4-11 4.1-11 1.8-10 4.5-10 6.1-10 1.5-9 1.7-9 1.9-9 2.0-9 5.1-9 5.0-9 1.7-13 4.6-13 2.3-13 1.3-13 3.1-13 2.7-12 4.7-13 4.7-12 2.1-13 2.8-10 8.4-13 9.9-13 3.0-13 1.8-13 4.4-14
2.2-9 3.5-9 4.4-9 8.9-9 -4.0-9 -2.1-7 -2.2-8 -1.3-7 -1.2-7 9.3-7 2.4-7 1.0-6 2.3-7 1.8-6 1.2-6 -2.2-8 -3.8-8 -1.3-8 -3.5-9 -1.2-8 -1.4-9 -4.8-9 -5.2-9 4.4-9 1.5-8 2.1-9 9.4-9 1.6-9 -2.2-5 -1.3-5
2.3-9 3.5-9 4.4-9 6.0-9 2.0-10 3.4-10 1.8-8 2.2-9 1.4-7 4.9-7 1.6-7 1.0-6 3.6-7 1.9-6 1.2-6 3.7-10 6.7-10 4.1-9 3.8-9 3.5-9 1.5-9 3.3-10 7.0-10 8.5-9 1.6-8 3.2-9 9.6-9 1.8-9 1.0-8 7.1-9
time 05 05 05 05 00 01 03 06 16 31 1:05 1:39 2:48 1:41 2:45 01 01 01 01 01 04 04 04 04 29 23 22 24 00 00
problem
36
hinf3 hinf4 hinf5 hinf6 hinf7 hinf8 hinf9 hinf10 hinf11 hinf12 hinf13 hinf14 hinf15 infd1 infd2 infp1 infp2 mcp100 mcp124-1 mcp124-2 mcp124-3 mcp124-4 mcp250-1 mcp250-2 mcp250-3 mcp250-4 mcp500-1 mcp500-2 mcp500-3 mcp500-4 qap5
m | ns ; nq ; nl ; nu
it.
primal obj
dual obj
err1
13 | 16; ; ; 13 | 16; ; ; 13 | 16; ; ; 13 | 16; ; ; 13 | 16; ; ; 13 | 16; ; ; 13 | 16; ; ; 21 | 18; ; ; 31 | 22; ; ; 43 | 24; ; ; 57 | 30; ; ; 73 | 34; ; ; 91 | 37; ; ; 10 | 30; ; ; 10 | 30; ; ; 10 | 30; ; ; 10 | 30; ; ; 100 | 100; ; ; 124 | 124; ; ; 124 | 124; ; ; 124 | 124; ; ; 124 | 124; ; ; 250 | 250; ; ; 250 | 250; ; ; 250 | 250; ; ; 250 | 250; ; ; 500 | 500; ; ; 500 | 500; ; ; 500 | 500; ; ; 500 | 500; ; ; 136 | 26; ; ;
21 21 21 21 19 21 21 32 34 46 34 26 29 5 5 7 7 12 13 13 12 13 14 13 13 14 15 16 15 13 10
-5.69615098 1 -2.74766003 2 -3.62704607 2 -4.49067325 2 -3.90831441 2 -1.16170056 2 -2.36249283 2 -1.08872461 2 -6.59694072 1 -1.47406847-1 -4.45474269 1 -1.29918409 1 -2.43319484 1 -5.13280346 0 5.35505784 0 -5.64104972 9 -3.85845797 9 -2.26157350 2 -1.41990477 2 -2.69880170 2 -4.67750108 2 -8.64411863 2 -3.17264340 2 -5.31930080 2 -9.81172565 2 -1.68196009 3 -5.98148516 2 -1.07005676 3 -1.84797002 3 -3.56673799 3 4.36000000 2
-5.69511425 1 -2.74764932 2 -3.62458662 2 -4.48998222 2 -3.90821867 2 -1.16157996 2 -2.36249258 2 -1.08792100 2 -6.59157089 1 -7.37049304-2 -4.44451072 1 -1.29908452 1 -2.41545357 1 1.5952217617 5.2954130616 -7.62162314 0 -6.90007199 0 -2.26157352 2 -1.41990477 2 -2.69880171 2 -4.67750115 2 -8.64411864 2 -3.17264340 2 -5.31930084 2 -9.81172572 2 -1.68196011 3 -5.98148517 2 -1.07005677 3 -1.84797002 3 -3.56673805 3 4.36000000 2
8.8-6 1.1-7 2.9-4 1.2-5 5.0-5 4.5-5 5.9-6 1.1-6 5.0-7 3.5-10 7.9-5 5.2-7 3.5-5
2.3-10 2.7-11 5.5-12 3.7-13 2.5-11 5.4-12 6.3-11 5.9-11 6.3-12 4.5-12 9.0-12 7.4-12 1.9-11 1.2-10
err3
err5
1.1-13 -9.0-5 8.5-13 -1.9-6 7.1-13 -3.4-4 2.9-13 -7.7-5 1.4-13 -1.2-5 1.7-13 -5.2-5 2.4-14 -5.2-8 3.5-11 -3.7-4 2.7-11 -4.0-4 2.7-9 -6.0-2 1.2-11 -1.1-3 7.2-12 -3.7-5 1.9-11 -3.6-3 primal infeasible primal infeasible dual infeasible dual infeasible 3.0-16 4.3-9 2.7-16 4.4-10 4.0-16 5.4-10 4.6-16 6.7-9 4.8-16 6.1-10 4.7-16 1.1-9 5.1-16 3.4-9 6.0-16 3.6-9 0.8-15 6.2-9 5.2-16 5.9-10 6.7-16 1.3-9 0.9-15 2.5-10 1.0-15 8.5-9 7.3-14 4.6-10
err6 5.8-9 1.8-10 4.1-8 1.4-6 4.2-8 3.2-7 3.7-10 1.4-7 5.5-8 2.0-9 4.5-6 6.1-8 5.1-4
4.3-9 4.5-10 5.4-10 6.7-9 6.2-10 1.1-9 3.4-9 3.6-9 6.2-9 5.9-10 1.3-9 2.5-10 8.5-9 6.1-10
time 00 00 00 00 00 00 00 01 01 01 01 01 02 00 00 00 00 01 01 01 01 01 02 02 02 03 07 11 12 11 00
problem
37
qap6 qap7 qap8 qap9 qap10 ss30 theta1 theta2 theta3 theta4 theta5 theta6 truss1 truss2 truss3 truss4 truss5 truss6 truss7 truss8 maxG11 maxG32 maxG51 qpG11 qpG51 thetaG11 thetaG51 equalG11 equalG51 bm1 copo14
m | ns ; nq ; nl ; nu
it.
primal obj
dual obj
err1
err3
err5
err6
229 | 37; ; ; 358 | 50; ; ; 529 | 65; ; ; 748 | 82; ; ; 1021 | 101; ; ; 132 | 294; ; 132; 104 | 50; ; ; 498 | 100; ; ; 1106 | 150; ; ; 1949 | 200; ; ; 3028 | 250; ; ; 4375 | 300; ; ; 6 | 12; ; 1; 58 | 132; ; 1; 27 | 30; ; 1; 12 | 18; ; 1; 208 | 330; ; 1; 172 | 450; ; 1; 86 | 300; ; 1; 496 | 627; ; 1; 800 | 800; ; ; 2000 | 2000; ; ; 1000 | 1000; ; ; 800 | 1600; ; ; 1000 | 2000; ; ; 2401 | 801; ; ; 6910 | 1001; ; ; 801 | 801; ; ; 1001 | 1001; ; ; 883 | 882; ; ; 1275 | 196; ; 364;
19 13 20 20 21 21 11 14 14 14 14 14 11 17 12 10 17 28 27 16 15 15 17 15 17 19 34 16 18 20 17
3.81432573 2 4.24830442 2 7.56939331 2 1.40993093 3 1.09258508 3 -2.02395100 1 -2.29999996 1 -3.28791689 1 -4.21669813 1 -5.03212213 1 -5.72323069 1 -6.34770870 1 8.99999632 0 1.23380356 2 9.10999622 0 9.00999632 0 1.32635678 2 9.01001420 2 9.00001403 2 1.33114589 2 -6.29164777 2 -1.56763962 3 -4.00625552 3 -2.44865909 3 -1.18179999 4 -3.99999995 2 -3.48999315 2 -6.29155280 2 -4.00560126 3 2.34398777 1 2.62856497-10
3.81435498 2 4.24810252 2 7.56947355 2 1.40993599 3 1.09259635 3 -2.02395106 1 -2.30000001 1 -3.28791690 1 -4.21669815 1 -5.03212220 1 -5.72323073 1 -6.34770872 1 8.99999631 0 1.23380356 2 9.10999619 0 9.00999626 0 1.32635678 2 9.01001363 2 9.00001391 2 1.33114588 2 -6.29164783 2 -1.56763964 3 -4.00625552 3 -2.44865913 3 -1.18180000 4 -4.00000000 2 -3.49000166 2 -6.29155293 2 -4.00560132 3 2.34398186 1 -6.99780924-10
3.3-8 1.8-8 2.0-7 3.8-8 1.0-7 4.2-7 9.9-12 6.2-13 2.6-12 3.4-14 1.9-13 1.7-12 5.8-12 3.8-10 9.0-12 6.0-12 9.1-11 5.0-8 5.3-8 1.4-10 2.8-11 1.3-10 2.6-12 3.3-11 2.3-10 5.0-9 1.4-10 8.7-10 6.5-8 2.2-6 2.5-11
9.6-13 5.3-13 3.1-12 1.3-12 1.1-12 2.3-13 5.6-15 1.2-14 1.4-14 2.1-14 2.9-14 3.2-14 1.0-15 7.2-15 5.7-16 1.2-15 1.0-14 2.3-13 2.4-13 9.3-15 7.4-16 1.1-15 3.6-16 0.0-16 0.0-16 1.7-13 6.8-13 1.0-15 1.3-15 1.8-11 6.2-15
-3.8-6 2.4-5 -5.3-6 -1.8-6 -5.2-6 1.4-8 9.5-9 1.4-9 2.1-9 7.8-9 3.9-9 1.9-9 2.7-10 3.8-10 1.6-9 3.1-9 9.3-10 3.1-8 6.9-9 3.5-9 5.2-9 9.1-9 2.8-10 8.6-9 2.2-9 6.8-9 1.2-6 9.9-9 7.4-9 1.2-6 9.6-10
2.3-9 3.3-5 7.4-9 4.4-9 2.3-9 1.0-8 9.5-9 1.4-9 2.1-9 7.8-9 3.9-9 1.9-9 2.7-10 3.8-10 1.6-9 3.1-9 8.9-10 4.4-8 2.2-8 3.5-9 5.2-9 9.1-9 2.8-10 8.6-9 2.2-9 6.8-9 1.2-6 9.9-9 7.5-9 1.2-6 9.6-10
time 01 01 05 09 17 22 00 01 05 16 49 2:10 00 01 00 00 02 02 02 04 26 4:21 1:06 26 1:03 1:33 37:14 1:17 2:38 2:04 08
problem
38
copo23 hamming-7hamming-9minphase torusg3-8 toruspm3-8 torusg3-15 toruspm3-1 filter48 filtinf1 nb nb-L1 nb-L2 nb-L2-bess nql30 nql60 nql180 qssp30 qssp60 qssp180 sched-50-5 sched-100sched-100sched-200sched-50-5 sched-100sched-100sched-200biggs buck1 buck2
m | ns ; nq ; nl ; nu
it.
primal obj
dual obj
err1
5820 | 529; ; 1771; 1793 | 128; ; ; 2305 | 512; ; ; 48 | 48; ; ; 512 | 512; ; ; 512 | 512; ; ; 3375 | 3375; ; ; 3375 | 3375; ; ; 969 | 48; 49; 931; 983 | 49; 49; 945; 123 | ; 2379; 4; 915 | ; 2379; 797; 123 | ; 4191; 4; 123 | ; 2637; 4; 3680 | ; 2700; 3602; 14560 | ; 10800; 14402; 130080 | ; 97200; 129602; 3691 | ; 7564; 2; 14581 | ; 29524; 2; 130141 | ; 261364; 2; 2527 | ; 2477; 2502; 4844 | ; 4744; 5002; 8338 | ; 8238; 10002; 18087 | ; 17887; 20002; 2526 | ; 2475; 2502; 4843 | ; 4742; 5002; 8337 | ; 8236; 10002; 18086 | ; 17885; 20002; 1819 | 702; ; ; 36 | 49; ; 36; 144 | 193; ; 144;
21 9 9 29 15 14 16 16 43 33 22 23 17 19 35 33 39 17 23 28 31 34 29 35 27 29 29 37 53 17 21
2.56114272-9 -4.26666666 1 -2.23999997 2 5.97872628 0 -4.83409459 7 -5.27808660 2 -6.37621845 3 -3.47513185 3 1.41612972 0 0.00000000-16 -5.07030865-2 -1.30122706 1 -1.62897195 0 -1.02569502-1 -9.46028502-1 -9.35052951-1 -9.27728621-1 -6.49667573 0 -6.56270608 0 -6.63960843 0 2.66753929 4 1.81900808 5 7.17597254 5 1.41946190 5 7.85203874 0 6.71650648 1 2.73307879 1 5.18119615 1 -1.41425775 3 -1.46419152 2 -2.92368313 2
-6.38325819-9 -4.26666667 1 -2.24000001 2 5.98119359 0 -4.83409459 7 -5.27808663 2 -6.37621855 3 -3.47513186 3 1.41612914 0 2.98905416 1 -5.07030948-2 -1.30122709 1 -1.62897198 0 -1.02569511-1 -9.46028517-1 -9.35052975-1 -9.27728643-1 -6.49667575 0 -6.56270649 0 -6.63961086 0 2.66728864 4 1.81887534 5 7.17350508 5 1.41176207 5 7.85203843 0 6.71650261 1 2.73307855 1 5.18119610 1 -1.41425841 3 -1.46419152 2 -2.92368295 2
2.2-12 6.8-11 3.4-13 1.3-8 3.4-12 6.9-11 1.2-9 2.1-11 2.9-7 3.1-13 1.6-10 1.7-10 1.0-13 5.2-11 5.0-11 7.8-10 1.9-10 2.9-8 3.1-7 1.5-5 3.4-4 1.4-2 1.3-4 2.3-7 1.3-7 1.1-7 1.0-7 3.4-9 8.2-10 8.3-7
err3
err5
err6
8.1-15 8.9-9 8.9-9 0.0-16 2.7-10 2.0-10 8.4-14 8.3-9 8.3-9 5.7-13 -1.9-4 4.8-7 7.8-16 9.5-10 9.5-10 6.0-16 2.8-9 2.8-9 1.5-15 7.6-9 7.6-9 1.5-15 2.0-9 2.0-9 8.9-14 1.5-7 1.2-8 primal infeasible 6.1-16 7.5-9 7.5-9 9.7-14 9.0-9 9.0-9 1.9-15 7.2-9 7.2-9 1.1-15 7.4-9 7.4-9 2.6-10 4.9-9 5.7-9 7.4-11 8.2-9 9.4-9 2.0-11 7.8-9 8.8-9 1.1-13 1.5-9 1.5-9 4.0-15 2.8-8 3.4-9 1.0-14 1.7-7 4.2-9 1.5-7 4.7-5 4.7-5 1.1-9 3.6-5 3.6-5 1.0-10 1.7-4 1.7-4 5.6-7 2.7-3 2.7-3 4.3-15 1.9-8 1.9-8 8.6-14 2.9-7 2.9-7 2.8-14 4.3-8 4.3-8 1.2-13 4.5-9 4.5-9 1.9-11 2.3-7 4.7-9 3.2-14 7.7-10 8.1-10 7.0-14 -3.1-8 2.0-8
time 18:20 10 24 01 11 10 23:41 23:46 1:01 48 07 13 10 07 04 17 4:38 03 17 6:31 03 07 13 46 03 06 12 44 1:30 01 04
problem
39
buck3 buck4 buck5 cnhil10 cnhil8 cphil10 cphil12 G40-mb G40mc G48mc G55mc G59mc mater-1 mater-2 mater-3 mater-4 mater-5 mater-6 neosfbr12 neosfbr20 neosfbr21 neosfbr22 neosfbr24 neosfbr25 neosfbr30e neu1 neu2 neu2c neu2g neu3 neu3g
m | ns ; nq ; nl ; nu
it.
primal obj
dual obj
err1
err3
err5
err6
time
544 | 641; ; 544; 1200 | 1345; ; 1200; 3280 | 3521; ; 3280; 5005 | 220; ; ; 1716 | 120; ; ; 5005 | 220; ; ; 12376 | 364; ; ; 2001 | 2000; ; ; 2000 | 2000; ; ; 3000 | 3000; ; ; 5000 | 5000; ; ; 5000 | 5000; ; ; 103 | 220; ; 2; 423 | 1012; ; 2; 1439 | 3586; ; 2; 4807 | 12496; ; 2; 10143 | 26818; ; 2; 20463 | 54626; ; 2; 1441 | 122; ; ;
28 33 37 27 25 9 10 22 18 12 16 19 21 20 24 29 30 32 17
-6.07589498 2 -4.86141048 2 -4.36170859 2 0.00000000-16 0.00000000-16 0.00000000-16 0.00000000-16 -2.86432310 3 -5.72957909 3 -1.20000000 4 -2.20789206 4 -1.46246530 4 1.43465439 2 1.41591867 2 1.33916258 2 1.34262716 2 1.33801638 2 1.33538673 2 5.29319164 2
-6.07608699 2 -4.86143830 2 -4.36283022 2 -1.65482516-4 -1.78946733-5 -8.11544501-9 -2.93810832-10 -2.86432323 3 -5.72957911 3 -1.20000000 4 -2.20789208 4 -1.46246531 4 1.43465438 2 1.41591866 2 1.33916256 2 1.34262716 2 1.33801640 2 1.33538714 2 5.29319158 2
1.2-4 9.9-6 2.2-5 6.4-8 1.8-8 1.1-14 1.5-14 9.1-10 1.1-10 5.6-12 9.6-10 6.6-10 1.4-10 6.3-12 7.3-11 1.6-9 9.9-9 6.2-8 3.5-11
2.1-13 4.0-13 6.5-13 3.2-12 1.1-12 0.0-16 0.0-16 2.1-11 5.8-16 5.7-15 2.2-15 1.0-15 1.6-14 7.2-14 2.5-13 8.8-13 1.8-12 3.1-12 0.8-15
1.6-5 2.9-6 1.3-4 1.7-4 1.8-5 8.1-9 2.9-10 2.1-8 1.1-9 4.2-10 4.7-9 4.7-9 3.5-9 1.1-9 9.6-9 2.6-9 -6.4-9 -1.5-7 5.7-9
1.7-5 2.8-6 1.3-4 2.9-7 5.0-8 8.1-9 2.9-10 2.1-8 1.1-9 4.2-10 4.7-9 4.7-9 3.5-9 1.1-9 9.7-9 3.8-9 4.4-9 8.0-9 5.7-9
20 2:12 25:33 55 07 31 4:01 21:04 7:07 10:06 1:14:47 1:36:36 01 04 16 1:11 3:03 8:21 18
31 40 59 38 46 47
4.36376962-7 -1.61121339-4 3.41771574 4 3.40999994 4 1.33597463-7 9.25315729-9
-1.34195143-5 -2.36860767-4 3.40921240 4 3.40999997 4 -1.96267080-4 -1.56570129-4
7.3-10 1.6-8 3.8-3 3.0-9 2.4-9 1.6-9
2.3-11 6.8-11 2.5-11 1.1-10 8.7-10 7.7-10
1.4-5 7.6-5 1.2-3 -5.3-9 2.0-4 1.6-4
3.6-5 6.5-4 2.0-4 1.4-8 2.7-6 2.0-7
8:21 10:21 32:28 9:12 8:01 11:02
3003 3003 3002 3002 7364 8007
| | | | | |
252; ; 2; 252; ; 2; 1253; ; 2; 252; ; ; 418; ; 2; 462; ; ;
problem
40
r1-6-0 r1-6-1 r1-6-1e-6 rose13 rose15 sdmint3 shmup1 shmup2 shmup3 shmup4 shmup5 taha1a taha1b trto1 trto2 trto3 trto4 trto5 vibra1 vibra2 vibra3 vibra4 vibra5 yalsdp cancer-100 checker-1. foot hand inc-600 inc-1200 swissroll
m | ns ; nq ; nl ; nu
it.
primal obj
dual obj
err1
err3
err5
err6
time
601 | 600; ; ; 601 | 600; ; ; 601 | 600; ; ; 2379 | 105; ; ; 3860 | 135; ; 2; 5255 | 379; 5255; ; 16 | 81; ; 32; 200 | 881; ; 400; 420 | 1801; ; 840; 800 | 3361; ; 1600; 1800 | 7441; ; 3600; 3002 | 1680; ; ; 8007 | 1606; ; 3; 36 | 25; ; 36; 144 | 97; ; 144; 544 | 321; ; 544; 1200 | 673; ; 1200; 3280 | 1761; ; 3280; 36 | 49; ; 36; 144 | 193; ; 144; 544 | 641; ; 544; 1200 | 1345; ; 1200; 3280 | 3521; ; 3280; 5051 | 300; ; ; 10469 | 569; ; ; 3970 | 3970; ; ; 2209 | 2208; ; ; 1297 | 1296; ; ; 2515 | 600; ; 2514; 5175 | 1200; ; 5174; 3380 | 800; ; ;
21 14 14 31 38 29 17 39 31 38 36 27 37 21 21 24 27 29 13 23 29 29 57 13 14 24 20 21 25 15 31
-5.57968708 4 -5.58043922 4 -5.57968722 4 1.20000012 1 1.82090663-5 -4.78135763 3 -1.88414831 2 -3.46242668 3 -2.09883698 3 -7.99254514 3 -2.38576762 4 -9.31533327-1 -7.73313007-1 -1.10450000 3 -1.27999978 4 -1.27999344 4 -1.27606346 4 -1.27928272 4 -4.08190124 1 -1.66015338 2 -1.72605378 2 -1.27636319 4 -1.65803004 2 -1.79212601 0 -2.76091613 4 3.30388458 3 -5.85252481 5 -2.47477792 4 -6.60104091-1 2.12231915 1 -5.48284431 5
-5.57968706 4 -5.58043924 4 -5.57968731 4 1.19999998 1 -1.26745042-5 -4.78131886 3 -1.88414832 2 -3.46242684 3 -2.09883796 3 -7.99255230 3 -2.38591658 4 -1.25589295 0 -7.73313020-1 -1.10450000 3 -1.28000007 4 -1.28000857 4 -1.27701954 4 -1.28021188 4 -4.08190124 1 -1.66015364 2 -1.72614934 2 -1.27676506 4 -1.65935491 2 -1.79212676 0 -2.76233961 4 3.30388454 3 -5.85298195 5 -2.47477791 4 -6.68915553-1 -1.41967770 0 -5.59816094 5
6.5-7 2.8-10 1.1-7 8.4-9 7.3-8 2.5-4 1.1-9 1.0-6 2.3-6 7.8-6 6.5-6 9.2-2 2.5-11 4.4-8 3.7-7 3.7-4 1.4-3 5.7-4 3.3-10 1.2-5 1.1-4 1.5-3 7.2-5 1.5-11 6.0-6 3.6-10 5.8-5 6.0-7 2.1-5 2.0-5 2.7-3
5.9-11 2.1-14 6.7-12 5.9-16 1.7-13 9.4-14 3.0-15 7.3-15 6.5-15 7.4-15 3.1-14 4.7-12 3.2-15 4.5-14 1.2-12 3.1-12 7.4-12 1.7-11 3.2-15 2.0-14 8.0-14 9.4-12 2.6-13 1.6-13 9.8-12 0.1-16 2.0-8 2.4-10 1.5-9 1.1-9 6.4-9
-1.6-9 2.2-9 8.3-9 5.6-8 3.1-5 -4.1-6 2.8-9 2.3-8 2.3-7 4.5-7 3.1-5 1.0-1 4.9-9 6.4-10 1.1-7 5.9-6 3.7-4 3.6-4 4.7-10 8.0-8 2.8-5 1.6-4 4.0-4 1.6-7 2.6-4 6.4-9 3.9-5 -1.4-9 3.8-3 9.6-1 1.0-2
1.3-10 2.2-9 7.9-9 7.4-9 5.7-8 9.3-6 2.8-9 2.6-8 2.2-7 4.5-7 3.1-5 9.0-2 5.9-9 3.5-10 1.1-7 5.9-6 3.7-4 3.6-4 4.8-10 8.8-8 2.8-5 1.6-4 4.0-4 1.6-7 3.0-4 6.4-9 3.9-5 1.1-10 4.1-3 9.6-1 1.1-1
41 29 29 1:08 5:44 47:47 01 57 4:06 20:54 2:36:00 15:27 47:32 01 01 09 52 10:43 01 05 20 1:50 39:13 10:33 26:16 45:04 24:57 5:31 2:07 7:16 5:30
problem
41
tiger-text diamond-pa ice-2.0 p-auss2-3. butcher rabmo reimer5 chs-500 nonc-500 ros-500 fp210 fp22 fp23 fp24 fp25 fp26 fp27 fp32 fp33 fp34 fp35 fp410 fp42 fp43 fp44 fp45 fp46 fp47 fp48 fp49 l1
m | ns ; nq ; nl ; nu
it.
primal obj
1802 | 1801; ; ; 5478 | 5477; ; ; 8113 | 8113; ; ;
25 31 28
3.48084179 2 3.22638853 1 6.80838634 3
6434 | 330; ; 22512; 5004 | 220; ; 6606; 6187 | 462; ; 102144; 9974 | 4980; ; ; 4990 | 2998; ; ; 4988 | 2992; ; ; 1000 | 176; ; ; 66 14 | 15; ; ; 209 | 119; ; ; 2379 | 595; ; ; 209 | 133; ; ; 1000 | 407; ; ; 1000 | 341; ; ; 3002 | 1155; ; ; 125 | 117; ; ; 209 | 140; ; ; 164 | 195; ; ; 14 | 18; ; ; 1 6 | 10; ; ; 50 | 76; ; ; 6 | 10; ; ; 4 | 7; ; ; 27 | 22; ; ; 6 | 10; ; ; 4 | 7; ; ; 14 | 18; ; ; 1 14 | 6; ; ;
43 47 24 23 22 17 25 12 29 22 18 22 21 44 39 22 18 16 10 16 22 13 21 16 9 16 8
-1.41958589 1 -3.72725362 0 -1.51824956 1 9.32785242-10 6.25761159-2 2.49499943 0 3.74999982-1 -7.99999999 0 2.13000000 2 1.95000000 2 1.10000000 1 2.68014631 2 3.90000000 1 -7.04227560 0 -1.01265940 4 1.72000000 2 3.99999993 0 1.67388932 1 7.58731237 0 6.54776263 2 4.43671691 2 1.24858128-9 9.94242098-10 2.43000000 2 7.50000000 0 1.67388932 1 4.92634657-1
dual obj
err1
err3
err5
err6
time
3.44294211 2 1.56694179 1 6.80838622 3
2.1-5 1.6-5 1.1-10
1.7-8 1.6-7 0.0-16
5.5-3 3.4-1 9.1-9
1.5-2 1.2 0 9.1-9
6:22 2:45:18 7:13:27
-1.40018649 1 -3.72725497 0 -1.51835452 1 -8.36219073-9 6.25597999-2 2.49499945 0 3.74999999-1 -8.00000007 0 2.12999999 2 1.95000000 2 1.10000000 1 2.68014631 2 3.89999997 1 -7.05278292 0 -1.01266024 4 1.72000000 2 3.99999965 0 1.67388931 1 7.58731235 0 6.63152380 2 4.43671704 2 -5.52323520-10 -4.64240829-9 2.43000000 2 7.50000000 0 1.67388931 1 4.92634644-1
3.7-2 6.2-6 1.0-3 8.2-14 1.3-8 1.2-8 1.3-7 4.2-10 2.0-11 1.0-11 1.2-12 9.5-10 4.2-10 4.4-3 2.6-10 1.2-12 4.2-9 1.6-11 6.5-12 2.5-4 2.7-8 1.1-9 1.3-10 5.3-11 2.1-11 1.6-11 4.3-12
1.1-6 5.1-8 1.0-9 0.0-16 2.2-15 1.8-15 3.9-10 1.4-15 1.2-13 3.5-13 1.2-14 3.0-15 4.7-13 9.7-12 4.3-11 1.0-13 1.1-13 4.7-16 6.4-16 2.1-10 4.5-14 5.0-16 2.1-16 1.9-14 1.5-16 4.7-16 0.2-16
-6.6-3 1.6-7 3.3-5 9.3-9 1.5-5 -3.5-9 -10.0-9 4.7-9 1.3-9 1.1-9 8.7-10 4.5-10 4.5-9 7.0-4 4.1-7 -2.9-10 3.0-8 3.3-9 1.1-9 -6.4-3 -1.5-8 1.8-9 5.6-9 2.1-10 3.1-10 3.3-9 6.5-9
1.7-3 1.7-5 1.6-4 9.3-9 1.4-5 3.1-9 4.4-9 6.9-9 2.0-9 1.4-9 1.1-9 7.7-10 6.4-9 2.9-4 2.5-9 6.2-10 5.3-8 3.6-9 1.1-9 1.7-6 1.9-9 2.4-9 7.3-9 1.6-10 3.0-10 3.6-9 6.5-9
45:05 15:53 59:43 30 10 08 09 00 02 56 01 10 09 7:05 02 01 03 00 00 01 00 00 00 00 00 00 00
problem
42
l2 l4 l5 5n a12 aw29 c5 fp1131 fp1132 fp1133 fp1134 fp1135 fp1136 fp1137 fp1138 fp1139 k5 p10 bifur boom brown butcher camera1s caprasse cassou cdpm5 chemequ chemequs cohn2 cohn3 comb3000
m | ns ; nq ; nl ; nu
it.
primal obj
dual obj
err1
14 | 6; ; ; 152 | 45; ; ; 14 | 15; ; ; 31 | 26; ; ; 793 | 79; ; ; 465 | 130; ; ; 31 | 26; ; ; 847 | 176; ; ; 847 | 176; ; ; 847 | 176; ; ; 847 | 176; ; ; 847 | 176; ; ; 847 | 176; ; ; 847 | 176; ; ; 847 | 176; ; ; 847 | 176; ; ; 31 | 31; ; ; 847 | 176; ; ; 454 | 84; ; ; 1661 3002 | 210; ; ; 8764 461 | 56; ; ; 925 6434 | 330; ; ; 11256 209 | 28; ; ; 168 209 | 35; ; ; 60 4844 | 495; ; ; 35126 125 | 21; ; ; 5 461 | 56; ; ; 525 125 | 21; ; ; 45 209 | 35; ; ; 4 209 | 35; ; ; 4 1000 | 66; ; ; 595
9 19 12 9 12 11 8 11 12 12 12 12 12 12 13 12 8 11 21 29 34 48 57 17 27 11 75 15 41 15 19
1.14580631 1 3.70370379-2 -7.99999999 0 2.24000000 0 2.10000000 1 3.00000000 0 1.50000001 0 4.50000001 0 1.55000000 1 1.75000000 1 1.95000000 1 2.20000000 1 1.45000000 1 1.65000000 1 1.75000000 1 2.30000000 1 1.00000001 0 4.50000001 0 -3.37301697-1 -3.23707245 2 3.04680725-11 -1.39810186 1 -1.78688795 4 -2.36780178-1 -3.8317999911 4.81891306-10 -7.55021050 8 -1.46594733 7 2.44989647-10 1.34558839-11 -4.74520651-10
1.14580630 1 3.70371914-2 -8.00000007 0 2.23999999 0 2.10000000 1 3.00000000 0 1.49999999 0 4.49999996 0 1.54999999 1 1.75000000 1 1.94999999 1 2.20000000 1 1.44999999 1 1.64999999 1 1.75000000 1 2.29999999 1 9.99999995-1 4.49999996 0 -3.37301697-1 -3.23707248 2 0.00000000-16 -1.39324497 1 -1.78686202 4 -2.36780183-1 -6.15988262 6 -7.57760884-9 -4.87753741 7 -1.25336541 5 -1.17751717-8 -4.75678015-10 -6.87418379-10
5.1-11 4.0-10 4.2-10 6.8-12 3.8-11 6.8-11 1.1-11 1.4-12 5.9-14 5.4-14 4.8-14 1.5-11 5.9-14 8.3-14 5.9-14 2.4-12 3.7-11 2.9-12 2.1-9 1.1-8 1.7-11 4.4-6 2.0-4 9.3-11 5.4-15
2.7-7 2.9-13 1.6-11
err3
err5
2.2-16 1.5-9 1.4-14 -1.4-7 1.4-15 4.7-9 2.6-16 2.8-9 1.6-15 9.3-10 4.9-16 1.1-9 1.1-16 3.9-9 1.6-15 4.9-9 5.2-15 3.8-9 5.4-15 1.7-9 5.1-15 3.0-9 1.7-15 8.8-10 5.1-15 4.8-9 4.1-15 2.5-9 5.1-15 6.8-10 2.6-15 3.1-9 2.1-16 4.5-9 1.3-15 4.9-9 2.1-10 -3.4-11 1.2-6 4.6-9 3.0-11 3.0-11 6.1-4 -1.7-3 6.0-8 -7.3-6 2.1-9 3.8-9 dual infeasible 0.0-16 8.1-9 dual infeasible dual infeasible 1.1-8 1.2-8 4.1-15 4.9-10 4.4-10 2.1-10
err6
time
1.5-9 8.6-9 6.9-9 2.8-9 9.3-10 1.2-9 4.0-9 4.9-9 3.8-9 1.7-9 3.0-9 8.8-10 4.8-9 2.5-9 6.8-10 3.1-9 4.5-9 4.9-9 1.7-9 8.5-7 3.8-9 2.2-2 8.3-6 6.8-9
00 01 00 00 03 06 00 22 24 24 24 24 24 24 26 24 00 22 04 4:00 04 47:32 02 01 1:17:04 00 07 00 01 01 05
8.1-9
1.2-8 4.9-10 2.2-9
problem
43
conform1 conform3 conform4 des18-3 des22-24 discret3 eco5 eco6 eco7 eco8 fourbar geneig heart i1 ipp katsura5 kinema ku10 lorentz manocha noon3 noon4 noon5 proddeco puma quadfor2 quadgrid rabmo rbpl redeco5 redeco6
m | ns ; nq ; nl ; nu
it.
primal obj
dual obj
83 | 20; ; ; 30 285 | 56; ; ; 630 454 | 84; ; ; 1890 12869 | 495; ; ; 58920 1000 | 66; ; ; 660 44 | 9; ; ; 8 461 | 56; ; ; 525 923 | 84; ; ; 924 1715 | 120; ; ; 1512 3002 | 165; ; ; 2340 69 | 15; ; ; 4 923 | 84; ; ; 546 3002 | 165; ; ; 4320 1000 | 66; ; ; 10 494 | 45; ; ; 360 209 | 28; ; ; 168 714 | 55; ; ; 495 1000 | 66; ; ; 660 69 | 15; ; ; 60 90 | 28; ; ; 42 83 | 20; ; ; 30 209 | 35; ; ; 60 461 | 56; ; ; 105 69 | 15; ; ; 4 3002 | 165; ; ; 8280 209 | 35; ; ; 270 461 | 56; ; ; 505 5004 | 220; ; ; 3303 923 | 84; ; ; 546 20 | 6; ; ; 5 27 | 7; ; ; 6
13 22 21 82 23 11 19 26 24 26 11 16 17 12 30 22 28 24 16 27 11 15 17 11 37 19 82 59 18 8 8
-6.04355528 8 -9.45599155-12 3.66213726-11 -3.23787125 6 -6.74166365 3 -3.70033135 1 -1.20463311 3 -1.00281559 4 -3.91531048 3 -5.82038418 3 1.16235821-10 -2.52663014 0 -8.70927422 1 -1.66775273 0 -1.31158853 1 -8.16044579-2 -4.19683963 4 -7.13900000 3 -5.00000000 0 -2.45943538-1 -2.08695033 1 -1.71283759 1 -1.58524243 1 1.84597568-11 -3.05299490 1 -6.18518518 0 -2.96150529 7 -3.72725312 0 -7.94063377 0 -2.53906250-1 -2.01600000-1
-6.64897488 3 0.00000000-16 0.00000000-16 -2.76403795 6 -6.74166365 3 -3.70033140 1 -1.20463311 3 -1.00281559 4 -3.91531047 3 -5.82038418 3 -4.24153800-9 -2.52663014 0 -8.70927422 1 -1.66775273 0 -1.31158853 1 -8.16044579-2 -4.19683963 4 -7.13900000 3 -5.00000000 0 -2.45956385-1 -2.08695034 1 -1.71283761 1 -1.58524243 1 -3.37004061-10 -3.05299490 1 -6.18518519 0 -2.95257544 7 -3.72725312 0 -7.94063378 0 -2.53906251-1 -2.01600002-1
err1 1.8-9 2.6-9 1.6-10 3.2-11 2.5-9 4.7-11 7.3-9 2.7-10 4.7-12 5.6-12 2.5-11 2.3-13 9.9-10 3.3-9 2.8-8 2.0-10 5.9-12 4.0-8 3.6-13 1.9-11 1.7-12 4.3-14 2.4-8 2.8-12 8.6-8 5.1-10 1.6-15 3.4-14
err3
err5
dual infeasible 5.0-11 -9.5-12 2.0-11 3.7-11 dual infeasible 6.9-9 4.5-11 3.4-15 6.7-9 2.6-9 -2.2-12 3.1-9 5.8-11 2.0-9 -4.0-10 8.1-9 -4.2-12 1.8-12 4.4-9 1.5-9 9.6-11 8.1-9 2.2-11 0.9-16 8.6-10 1.5-9 -6.0-11 1.3-10 3.6-11 4.6-9 -1.0-10 2.9-9 9.0-11 2.7-9 6.1-11 1.6-5 8.6-6 1.6-9 1.2-9 1.8-9 5.7-9 4.9-9 3.3-10 0.0-16 3.6-10 2.4-9 -7.9-10 4.3-9 6.7-10 dual infeasible 3.9-10 -3.9-10 9.8-10 5.2-10 0.4-16 1.2-9 1.1-16 1.6-9
err6 6.7-10 3.0-9 1.0-9 6.7-9 8.1-10 3.7-10 4.8-10 1.5-10 4.5-9 7.9-9 4.6-9 8.6-10 2.1-9 2.0-9 1.2-9 2.0-9 2.0-9 8.9-4 2.6-9 8.1-9 2.1-9 3.6-10 1.7-9 4.5-9 2.3-9 9.8-9 1.2-9 1.6-9
time 00 01 04 8:58:52 06 00 02 09 32 2:15 00 05 1:29 04 02 01 04 07 00 01 00 01 02 00 3:16 01 11 19:16 06 00 00
problem
44
redeco7 redeco8 rediff3 rose s9-1 sendra solotarev stewart1 stewart2 trinks visasoro wood wright nql30o nql60o nql90o nql120o nql180o qs30o qs60o qs90o qs120o qs180o qt30o qt60o qt90o qt120o qt180o q30o q60o dsNRL
m | ns ; nq ; nl ; nu
it.
primal obj
dual obj
err1
err3
err5
err6
time
35 | 8; ; ; 7 44 | 9; ; ; 8 9 | 4; ; ; 3 679 | 120; ; ; 2281 494 | 45; ; ; 360 65 | 21; ; ; 12 69 | 15; ; ; 32 714 | 55; ; ; 495 1819 | 91; ; ; 910 209 | 28; ; ; 141 44 | 9; ; ; 8 69 | 15; ; ; 32 20 | 6; ; ; 5 3680 | ; 2700; 3602; 14560 | ; 10800; 14402; 32640 | ; 24300; 32402; 57920 | ; 43200; 57602; 130080 | ; 97200; 129602; 1861 | ; 3844; 2; 7321 | ; 14884; 2; 16381 | ; 33124; 2; 29041 | ; 58564; 2; 65161 | ; 131044; 2; 3924 | ; 2883; 3846; 15044 | ; 11163; 14886; 33364 | ; 24843; 33126; 58884 | ; 43923; 58566; 131524 | ; 98283; ; 65523 7482 | ; 11163; 2; 29362 | ; 43923; 2; 406 | ; 15897; ;
8 8 9 31 21 11 14 35 32 31 11 20 9 35 33 36 36 39 15 17 20 21 22 43 52 54 53 38 32 23 36
-1.67438271-1 -1.43273636-1 4.04469621-10 -1.72122696 0 -4.27369565 0 -2.37687542 1 -5.88961333 0 -8.76585278 0 -1.27531388 1 -2.43523491-1 6.97297058-10 -6.64233343-2 -2.00000000 1 -9.46028502-1 -9.35052951-1 -9.31383164-1 -9.29550235-1 -9.27728621-1 -6.29531550 0 -6.38210348 0 -6.42377345 0 -6.45014299 0 -6.48350884 0 -3.43399895-1 -3.90343193-1 -4.05801683-1 -4.12995497-1 -4.19731365-1 -9.36405103-1 -8.73587717-7 -5.57436155-5
-1.67438274-1 -1.43273639-1 -1.21340922-9 -1.70726881 0 -4.27369565 0 -2.37687543 1 -5.88961337 0 -8.76585278 0 -1.27531386 1 -2.43523492-1 -4.26654223-9 -6.64233383-2 -2.00000002 1 -9.46028517-1 -9.35052975-1 -9.31383188-1 -9.29550250-1 -9.27728643-1 -6.29531557 0 -6.38210354 0 -6.42377320 0 -6.45014275 0 -6.48350889 0 -3.43399908-1 -3.90343204-1 -4.05801698-1 -4.12995510-1 -4.19960022-1 -9.36405121-1 -1.74652326-3 -5.57492818-5
1.5-14 9.2-15 1.0-15 1.0-6 5.3-11 2.4-10 2.3-12 1.3-10 1.0-7 3.3-9 1.9-15 1.0-9 5.9-13 7.0-12 3.9-10 7.0-11 7.1-10 4.4-10 1.0-9 1.8-9 1.2-8 9.4-9 9.3-10 2.2-11 4.4-11 9.8-11 1.5-10 8.3-10 2.8-10 6.7-6 4.4-12
0.5-16 0.7-16 0.0-16 3.4-4 5.8-10 3.4-12 1.3-9 3.4-9 8.1-10 1.3-11 0.0-16 3.3-10 2.1-16 2.6-10 7.4-11 4.2-11 2.0-11 2.0-11 2.4-15 6.2-14 6.7-15 8.9-15 1.3-14 9.0-11 3.8-11 3.1-11 2.0-11 3.5-6 2.2-15 8.5-11 3.6-14
2.0-9 2.4-9 1.6-9 -3.2-3 2.0-10 2.5-9 2.6-9 -9.1-11 -1.0-8 9.4-11 5.0-9 3.5-9 6.5-9 4.9-9 8.1-9 8.1-9 5.1-9 7.8-9 5.0-9 4.5-9 -1.8-8 -1.7-8 3.5-9 7.8-9 6.4-9 8.0-9 7.3-9 1.2-4 6.4-9 1.7-3 5.7-9
2.0-9 2.4-9 1.6-9 3.7-2 5.8-9 2.8-9 6.6-9 6.7-9 1.0-9 9.1-10 5.0-9 8.4-9 6.5-9 5.7-9 9.4-9 9.2-9 5.9-9 8.8-9 4.3-9 5.0-9 1.3-9 1.9-10 6.2-9 8.1-9 6.1-9 7.6-9 7.1-9 1.1-3 6.6-9 4.2-4 5.7-9
00 00 00 18 02 00 00 05 39 01 00 00 00 04 15 43 1:29 4:31 01 05 16 38 2:04 17 2:43 10:18 27:55 1:13:29 40 30:17 11:02
45
problem
m | ns ; nq ; nl ; nu
it.
primal obj
dual obj
err1
err3
err5
err6
firL1Linfa firL1Linfe firL1 firL2a firL2L1alp firL2L1eps firL2Linfa firL2Linfe firL2 firLinf BeH-2Sigma BH-1Sigma+ BH2-2A1-ST BH+-2Sigma CH+-1Sigma CH2-1A1-ST CH2-3B1-ST CH-2Pi-STO CH–3Sigma H2O-1A1-ST H2O+-2B1-S HF-1Sigma+ HF+-2Pi-ST LiH-1Sigma NH2-2B1-ST NH+-2Pi-ST NH–2Pi-ST NH-3SigmaOH–1Sigma OH-2Pi-STO OH+-3Sigma
3074 | ; 17532; ; 7088 | ; 13932; 1; 6223 | ; 17766; ; 1002 | ; 1003; ; 5868 | ; 9611; 1; 4124 | ; 11969; ; 203 | ; 9029; ; 6086 | ; 14711; ; 102 | ; 103; ; 402 | ; 11886; ; 948 | 1406; ; ; 948 | 1406; ; ; 1743 | 2166; ; ; 948 | 1406; ; ; 948 | 1406; ; ; 1743 | 2166; ; ; 1743 | 2166; ; ; 948 | 1406; ; ; 948 | 1406; ; ; 1743 | 2166; ; ; 1743 | 2166; ; ; 948 | 1406; ; ; 948 | 1406; ; ; 948 | 1406; ; ; 1743 | 2166; ; ; 948 | 1406; ; ; 948 | 1406; ; ; 948 | 1406; ; ; 948 | 1406; ; ; 948 | 1406; ; ; 948 | 1406; ; ;
26 30 22 7 18 18 28 16 7 24 31 30 30 30 29 29 30 29 30 28 30 27 27 31 30 29 29 29 28 28 29
-3.06731077-3 -2.71128527-3 -2.92573392-4 -7.14574800-4 -5.76340548-5 -8.44806167-4 -7.05910969-3 -1.48919889-3 -3.11866437-3 -1.00681685-2 1.66935641 1 2.72063377 1 3.04301171 1 2.69796662 1 4.06927879 1 4.48537628 1 4.50291330 1 4.10222179 1 4.09070914 1 8.49236908 1 8.42163768 1 1.04720454 2 1.03885668 2 8.96721196 0 6.29798021 1 5.78593622 1 5.80546397 1 5.83910025 1 7.91680600 1 7.94670773 1 7.88863800 1
-3.06731718-3 -2.71129475-3 -2.92582151-4 -7.14579339-4 -5.76372249-5 -8.44815323-4 -7.05911673-3 -1.48920536-3 -3.11866484-3 -1.00681770-2 1.66935639 1 2.72063375 1 3.04301166 1 2.69796657 1 4.06927873 1 4.48537626 1 4.50291327 1 4.10222176 1 4.09070909 1 8.49236900 1 8.42163759 1 1.04720452 2 1.03885666 2 8.96721180 0 6.29798015 1 5.78593619 1 5.80546388 1 5.83910016 1 7.91680587 1 7.94670763 1 7.88863788 1
3.7-11 8.2-9 1.5-11 0.8-15 1.6-12 9.5-12 1.1-11 1.2-10 7.5-16 1.4-9 3.7-12 2.3-11 3.0-9 3.9-12 3.6-11 1.1-9 1.1-9 6.5-11 1.9-11 9.9-12 9.9-11 4.2-12 2.6-11 3.0-11 1.5-10 3.1-11 9.1-12 4.4-11 2.2-12 3.2-11 1.5-11
2.5-14 1.4-14 3.1-14 0.8-16 1.3-14 2.2-14 1.6-14 1.6-14 1.1-16 2.5-14 5.9-16 2.4-16 3.8-16 2.8-16 6.9-16 2.6-16 1.0-15 4.7-16 4.9-16 2.9-16 6.7-16 4.9-16 5.2-16 7.5-16 0.9-15 7.3-16 2.3-16 3.6-16 4.3-16 4.1-16 0.8-15
6.4-9 9.4-9 8.8-9 4.5-9 3.2-9 9.1-9 6.9-9 6.5-9 4.7-10 8.3-9 7.0-9 3.9-9 7.5-9 9.6-9 7.4-9 2.7-9 2.8-9 3.7-9 6.5-9 4.7-9 5.5-9 7.6-9 8.5-9 8.4-9 4.6-9 3.0-9 7.4-9 8.2-9 8.0-9 6.5-9 7.4-9
6.4-9 9.4-9 8.8-9 4.5-9 3.2-9 9.1-9 6.9-9 6.5-9 4.7-10 8.2-9 7.0-9 3.9-9 7.5-9 9.6-9 7.4-9 2.8-9 2.8-9 3.7-9 6.5-9 4.7-9 5.5-9 7.6-9 8.5-9 8.4-9 4.6-9 3.0-9 7.4-9 8.2-9 8.0-9 6.5-9 7.4-9
time 2:26 2:05 7:47 22 1:09 2:13 1:21 3:51 00 5:23 2:11 5:53 24:18 2:09 2:06 23:36 24:15 5:39 5:52 22:41 24:16 5:15 5:17 2:10 24:17 5:41 2:09 2:08 5:32 5:28 2:04
problem
m | ns ; nq ; nl ; nu
it.
primal obj
H3O+-1-A1NH3-1-A1-S Li.2S.STO6 Be.1S.STO6 BeH+.1Sigm H3.2A1.DZ. FH2+.1A1.S NH2-.1A1.S CH3+.1E.ST NH3+.2A2.S CH3.2A2.ST CH4.1A1.ST Na.2S.STO6 NH4+.1A1.S
2964 | 3008; ; 154; 2964 | 3008; ; 154; 465 | 780; ; ; 35 465 | 780; ; ; 35 948 | 1312; ; ; 47 948 | 1312; ; ; 47 1743 | 2044; ; ; 61 1743 | 2044; ; ; 61 2964 | 3008; ; ; 77 2964 | 3008; ; ; 77 2964 | 3008; ; ; 77 4743 | 4236; ; ; 95 4743 | 4236; ; ; 95 4743 | 4236; ; ; 95
30 30 36 34 45 40 42 46 40 41 40 37 43 38
9.01065676 1 6.79248736 1 7.40023835 0 1.45560894 1 1.64575093 1 3.36464947 0 1.09990444 2 6.27062185 1 4.87507287 1 6.75058463 1 4.92214627 1 5.36627612 1 1.61077125 2 7.27767126 1
dual obj 9.01065664 1 6.79248731 1 7.40023833 0 1.45560861 1 1.64575041 1 3.36464790 0 1.09990363 2 6.27062092 1 4.87505865 1 6.75055336 1 4.92211215 1 5.36621129 1 1.61076921 2 7.27761528 1
err1
err3
2.2-11 2.9-11 1.2-8 7.8-8 1.4-7 2.6-7 2.1-7 1.5-7 8.0-7 3.7-7 2.4-7 1.4-6 3.9-7 1.6-6
1.0-15 7.5-16 2.3-10 1.4-9 1.4-9 1.1-9 2.1-9 9.0-10 6.6-9 1.1-8 1.9-8 1.8-8 6.4-9 1.4-8
err5
err6
time
6.9-9 3.4-9 1.4-9 1.1-7 1.5-7 2.0-7 3.6-7 7.3-8 1.4-6 2.3-6 3.4-6 6.0-6 6.3-7 3.8-6
6.9-9 3.4-9 5.3-9 1.3-7 1.7-7 2.5-7 5.4-7 9.2-8 2.3-6 3.2-6 4.9-6 7.6-6 7.8-7 4.8-6
1:36:21 1:36:10 1:08 1:04 7:44 6:53 34:00 37:18 2:08:23 2:11:36 2:08:28 6:47:01 7:52:40 6:58:57
46
