e04nq {NAGFWrappers}  R Documentation 
e04nq solves sparse linear programming or convex quadratic programming problems. The initialization function e04np must have been called before calling e04nq.
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))
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.

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] = 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[1] = 0.0, inda[1] = 1, loca[1] = 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:
 
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. 
R interface to the NAG Fortran routine E04NQF.
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 =0unless the function detects an error or a warning has been flagged (see the Errors section in Fortran library documentation). 
NAG
http://www.nag.co.uk/numeric/FL/nagdoc_fl23/pdf/E04/e04nqf.pdf
optlist<list() ifail<0 qphx=function(ncolh,x,nstate){ hx<as.matrix(mat.or.vec(ncolh,1)) hx[1]<2%*%x[1] hx[2]<2%*%x[2] hx[3]<2%*%(x[3]+x[4]) hx[4]<hx[3] hx[5]<2%*%x[5] hx[6]<2%*%(x[6]+x[7]) hx[7]<hx[6] list(HX=as.matrix(hx)) } start<'C' m<8 n<7 lenc<0 ncolh<7 iobj<8 objadd<0 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 e04nq(start,qphx,m,n,lenc,ncolh,iobj,objadd,prob,acol,inda,loca,bl,bu,c,names,helast,hs,x,ns,optlist)