e04nq {NAGFWrappers} R Documentation

## e04nq: LP or QP problem (suitable for sparse problems)

### Description

e04nq solves sparse linear programming or convex quadratic programming problems. The initialization function e04np must have been called before calling e04nq.

### Usage

```e04nq(start, qphx, m, n, lenc, ncolh, iobj, objadd, prob, acol, inda, loca, bl, bu, c, names, helast, hs, x, ns, optlist,
ne = nrow(acol),
nname = nrow(names))
```

### Arguments

 `start` string Indicates how a starting basis (and certain other items) will be obtained. start='C': Requests that an internal Crash procedure be used to choose an initial basis, unless a Basis file is provided via optional arguments oldbasisfile, insertfile or loadfile. start='B': Is the same as start='C' but is more meaningful when a Basis file is given. start='W': Means that a basis is already defined in hs and a start point is already defined in x (probably from an earlier call). `qphx` function For QP problems, you must supply a version of qphx to compute the matrix product Hx for a given vector x. If H has rows and columns of zeros, it is most efficient to order x so that the nonlinear variables appear first. For example, if x = (yz)^T and only y enters the objective quadratically then Hx = ( H_1 0 0 0 ) ( y z ) = ( H_1y 0 ) . In this case, ncolh should be the dimension of y, and qphx should compute H_1y. For FP and LP problems, qphx will never be called by e04nq and hence qphx may be the dummy function e04nsh. ```(HX) = qphx(ncolh,x,nstate) ``` `m` integer m, the number of general linear constraints (or slacks). This is the number of rows in the linear constraint matrix A, including the free row (if any; see iobj). Note that A must have at least one row. If your problem has no constraints, or only upper or lower bounds on the variables, then you must include a dummy row with sufficiently wide upper and lower bounds (see also acol, inda and loca). `n` integer n, the number of variables (excluding slacks). This is the number of columns in the linear constraint matrix A. `lenc` integer The number of elements in the constant objective vector c. `ncolh` integer n_H, the number of leading nonzero columns of the Hessian matrix H. For FP and LP problems, ncolh must be set to zero. `iobj` integer If iobj > 0, row iobj of A is a free row containing the nonzero elements of the vector c appearing in the linear objective term c^Tx. `objadd` double The constant q, to be added to the objective for printing purposes. Typically objadd = 0.0E0. `prob` string The name for the problem. It is used in the printed solution and in some functions that output Basis files. A blank name may be used. `acol` double array The nonzero elements of A, ordered by increasing column index. Note that all elements must be assigned a value in the calling program. `inda` integer array inda[i] must contain the row index of the nonzero element stored in acol[i] for i=1 . . . ne. Thus a pair of values (acol[i]inda[i]) contains a matrix element and its corresponding row index. `loca` integer array loca[j] must contain the index in acol and inda of the start of the jth column for j=1 . . . n. Thus for j = 1 : n, the entries of column j are held in acol[k:l] and their corresponding row indices are in inda[k:l], where k = loca[j] and l = loca[j+1] - 1. To specify the jth column as empty, set loca[j] = loca[j+1]. Note that the first and last elements of loca must be loca = 1 and loca[n+1] = ne + 1. If your problem has no constraints, or just bounds on the variables, you may include a dummy ‘free’ row with a single (zero) element by setting ne = 1, acol = 0.0, inda = 1, loca = 1, and loca[j] = 2, for j = 2 : n + 1. This row is made ‘free’ by setting its bounds to be bl[n+1] = - bigbnd and bu[n+1] = bigbnd, where bigbnd is the value of the optional argument infiniteboundsize. `bl` double array l, the lower bounds for all the variables and general constraints, in the following order. The first n elements of bl must contain the bounds on the variables x, and the next m elements the bounds for the general linear constraints Ax (which, equivalently, are the bounds for the slacks, s) and the free row (if any). To fix the jth variable, set bl[j] = bu[j] = β, say, where abs(β) < bigbnd. To specify a nonexistent lower bound (i.e., l_j = - infinity), set bl[j] <= - bigbnd. Here, bigbnd is the value of the optional argument infiniteboundsize. To specify the jth constraint as an equality, set bl[n+j] = bu[n+j] = β, say, where abs(β) < bigbnd. Note that the lower bound corresponding to the free row must be set to - infinity and stored in bl[n+iobj]. `bu` double array u, the upper bounds for all the variables and general constraints, in the following order. The first n elements of bu must contain the bounds on the variables x, and the next m elements the bounds for the general linear constraints Ax (which, equivalently, are the bounds for the slacks, s) and the free row (if any). To specify a nonexistent upper bound (i.e., u_j = + infinity), set bu[j] >= bigbnd. Note that the upper bound corresponding to the free row must be set to + infinity and stored in bu[n+iobj]. `c` double array Contains the explicit objective vector c (if any). If the problem is of type FP, or if lenc = 0, then c is not referenced. (In that case, c may be dimensioned eqn1, or it could be any convenient array.)

double array

Contains the explicit objective vector c (if any). If the problem is of type FP, or if lenc = 0, then c is not referenced. (In that case, c may be dimensioned eqn1, or it could be any convenient array.)

`names`

string array

The optional column and row names, respectively.

`helast`

integer array

Defines which variables are to be treated as being elastic in elastic mode. The allowed values of helast are: helast need not be assigned if optional argument elasticmode=0.

`hs`

integer array

If start='C', 'B', and a Basis file of some sort is to be input (see the description of the optional arguments oldbasisfile, insertfile or loadfile), then hs and x need not be set at all.

`x`

double array

The initial values of the variables x, and, if start='W', the slacks s, i.e., (xs). (See the description for argument hs.)

`ns`

integer

n_S

, the number of superbasics. For QP problems, ns need not be specified if start='C', but must retain its value from a previous call when start='W'. For FP and LP problems, ns need not be initialized.

`optlist`

options list

Optional parameters may be listed, as shown in the following table:

 Name Type Default `Check Frequency` integer Default = 60 `Crash Option` integer Default = 3 `Crash Tolerance` double Default = 0.1 `Defaults` `Dump File` integer Default = 0 `Load File` integer Default = 0 `Elastic Mode` integer Default = 1 `Elastic Objective` integer Default = 1 `Elastic Weight` double Default = 1.0 `Expand Frequency` integer Default = 10000 `Factorization Frequency` integer Default = 100(LP) or 50(QP) `Feasibility Tolerance` double Default = max10^ - 6sqrt(ε) `Infinite Bound Size` double Default = 10^20 `Iterations Limit` integer Default = max1000010maxmn `LU Density Tolerance` double Default = 0.6 `LU Singularity Tolerance` double Default = ε^(2)/(3) `LU Factor Tolerance` double Default = 100.0 `LU Update Tolerance` double Default = 10.0 `LU Partial Pivoting` Default `LU Complete Pivoting` `LU Rook Pivoting` `Minimize` Default `Maximize` `Feasible Point` `New Basis File` integer Default = 0 `Backup Basis File` integer Default = 0 `Save Frequency` integer Default = 100 `Nolist` Default `List` `Old Basis File` integer Default = 0 `Optimality Tolerance` double Default = max10^ - 6sqrt(ε) `Partial Price` integer Default = 10(LP) or 1(QP) `Pivot Tolerance` double Default = ε^(2)/(3) `Print File` integer Default = 0 `Print Frequency` integer Default = 100 `Print Level` integer Default = 1 `Punch File` integer Default = 0 `Insert File` integer Default = 0 `QPSolver Cholesky` Default `QPSolver CG` `QPSolver QN` `Reduced Hessian Dimension` integer Default = 1(LP) or min(2000n_H + 1n)(QP) `Scale Option` integer Default = 2 `Scale Tolerance` double Default = 0.9 `Scale Print` `Solution File` integer Default = 0 `Summary File` integer Default = 0 `Summary Frequency` integer Default = 100 `Superbasics Limit` integer Default = 1(LP) or minn_H + 1n(QP) `Suppress Parameters` `System Information No` Default `System Information Yes` `Timing Level` integer Default = 0 `Unbounded Step Size` double Default = infbnd
`ne`

integer: default = nrow(acol)

The number of nonzero elements in A.

`nname`

integer: default = nrow(names)

The number of column (i.e., variable) and row names supplied in the array names.

nname = 1

: There are no names. Default names will be used in the printed output.

nname = n + m

: All names must be supplied.

### Details

R interface to the NAG Fortran routine E04NQF.

### Value

 `HS` integer array The final states of the variables and slacks (xs). The significance of each possible value of hs[j] is as follows: `X` double array The final values of the variables and slacks (xs). `PI` double array Contains the dual variables π (a set of Lagrange multipliers (shadow prices) for the general constraints). `RC` double array Contains the reduced costs, g - ( A -I ) ^Tπ. The vector g is the gradient of the objective if x is feasible, otherwise it is the gradient of the Phase 1 objective. In the former case, g(i) = 0, for i = n + 1 : m, hence rc(n + 1 : m) = π. `NS` integer The final number of superbasics. This will be zero for FP and LP problems. `NINF` integer The number of infeasibilities. `SINF` double The sum of the scaled infeasibilities. This will be zero if ninf = 0, and is most meaningful when scaleoption=0. `OBJ` double The value of the objective function. `IFAIL` integer ifail =0 unless the function detects an error or a warning has been flagged (see the Errors section in Fortran library documentation).

NAG

### Examples

```
optlist<-list()

ifail<-0
qphx=function(ncolh,x,nstate){

hx<-as.matrix(mat.or.vec(ncolh,1))
hx<-2%*%x
hx<-2%*%x
hx<-2%*%(x+x)
hx<-hx
hx<-2%*%x
hx<-2%*%(x+x)
hx<-hx
list(HX=as.matrix(hx))
}

start<-'C'

m<-8

n<-7

lenc<-0

ncolh<-7

iobj<-8

prob<-''

acol<-matrix(c(0.02,0.02,0.03,1,0.7,0.02,0.15,-200,0.06,0.75,0.03,0.04,0.05,0.04,1,-2000,0.02,1,0.01,0.08,0.08,0.8,-2000,1,0.12,0.02,0.02,0.75,0.04,-2000,0.01,0.8,0.02,1,0.02,0.06,0.02,-2000,1,0.01,0.01,0.97,0.01,400,0.97,0.03,1,400),nrow=48,ncol=1,byrow=TRUE)

inda<-matrix(c(7,5,3,1,6,4,2,8,7,6,5,4,3,2,1,8,2,1,4,3,7,6,8,1,7,3,4,6,2,8,5,6,7,1,2,3,4,8,1,2,3,6,7,8,7,2,1,8),nrow=48,ncol=1,byrow=TRUE)

loca<-matrix(c(1,9,17,24,31,39,45,49),nrow=8,ncol=1,byrow=TRUE)

bl<-matrix(c(0,0,400,100,0,0,0,2000,-9.999999999999999e+24,-9.999999999999999e+24,-9.999999999999999e+24,-9.999999999999999e+24,1500,250,-9.999999999999999e+24),nrow=15,ncol=1,byrow=TRUE)

bu<-matrix(c(200,2500,800,700,1500,9.999999999999999e+24,9.999999999999999e+24,2000,60,100,40,30,9.999999999999999e+24,300,9.999999999999999e+24),nrow=15,ncol=1,byrow=TRUE)

c<-matrix(c(0),nrow=1,ncol=1,byrow=TRUE)

names<-matrix(c('...X1...','...X2...','...X3...','...X4...','...X5...','...X6...','...X7...','..ROW1..','..ROW2..','..ROW3..','..ROW4..','..ROW5..','..ROW6..','..ROW7..','..COST..'),nrow=15,byrow=TRUE)

helast<-matrix(c(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0),nrow=15,ncol=1,byrow=TRUE)

hs<-matrix(c(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0),nrow=15,ncol=1,byrow=TRUE)

x<-matrix(c(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0),nrow=15,ncol=1,byrow=TRUE)

ns<-0