void simpleQPSolve(Matrix G, Vector vd, Matrix Astar, Vector vBstar, // in
Vector vXtmp, Vector vLambda) // out
{
Astar.setNLine(Astar.nLine()+1);
Matrix thisG, At=Astar.transpose();
Astar.setNLine(Astar.nLine()-1);
Vector minusvd=vd.clone();
minusvd.multiply(-1.0); vBstar.multiply(-1.0);
int m=Astar.nLine(), me=0, mmax=Astar.nLine()+1, n=vd.sz(), nmax=n,
mnn=m+n+n, iout=0, ifail, iprint=0, lwar=3*nmax*nmax/2 + 10*nmax+ 2*mmax+1,
liwar=n;
if (G==Matrix::emptyMatrix) {
thisG.setSize(n,n); thisG.diagonal(1.0); }
else thisG=G;
double *c=*((double**)thisG), *d=minusvd, *a=*((double**)At), *b=vBstar;
Vector vxl(n),vxu(n), temp(lwar);
VectorInt itemp(liwar);
vLambda.setSize(mnn);
double *xl=vxl, *xu=vxu, *x=vXtmp, *u=vLambda, *war=temp, eps1=1e-20;
int *iwar=itemp;
int dim=n; while (dim--) { xl[dim]=-INF; xu[dim]=INF; }
iwar[0]=0;
ql0001_(&m,&me,&mmax,&n,&nmax,&mnn,c,d,a,b,xl,xu,x,u,&iout,&ifail,
&iprint,war,&lwar,iwar,&liwar,&eps1);
vLambda.setSize(m);
}
void lcp_qp(LinearComplementarityProblem* problem, double *z, double *w, int *info , SolverOptions* options)
{
/* size of the LCP */
int n = problem->size;
int i, j;
int nmax;
int m, me, mmax, mnn;
double *Q, *A;
double *p, *b, *xl, *xu;
double *lambda;
int lwar, liwar, iout, un;
int *iwar;
double *war;
double tol = options->dparam[0];
/*/ m : total number of constraints.*/
m = 0;
/*/ me : number of equality constraints.*/
me = 0;
/*/ mmax : row dimension of a. mmax must be at least one and greater than m.*/
mmax = m + 1;
/*/n : number of variables.
//nmax : row dimension of C. nmax must be greater or equal to n.*/
nmax = n;
/*/mnn : must be equal to m + n + n. */
mnn = m + n + n;
for (i = 0; i < n; i++)
{
z[i] = 0.0;
w[i] = 0.0;
}
/*/ Creation of objective function matrix Q and the the constant vector of the objective function p
// Q= M;*/
double * vec = problem->M->matrix0;
Q = (double *)malloc(nmax * nmax * sizeof(double));
for (j = 0; j < n; j++)
{
for (i = 0; i < n; i++) Q[j * nmax + i] = vec[j * n + i];
}
p = (double *)malloc(nmax * sizeof(double));
for (i = 0; i < n; i++)
p[i] = problem->q[i] ;
/* / Creation of the data matrix of the linear constraints, A and the constant data of the linear constraints b*/
A = (double *)calloc(mmax * nmax, sizeof(double));
b = (double *)calloc(mmax, sizeof(double));
/* Creation of the the lower and upper bounds for the variables.*/
xu = (double *)malloc(n * sizeof(double));
for (i = 0; i < n; i++) xu[i] = 1e32 ;
xl = (double *)calloc(n, sizeof(double));
/* on return, lambda contains the lagrange multipliers.*/
lambda = (double *)malloc(mnn * sizeof(double));
MSAN_INIT_VAR(lambda, mnn);
/* / integer indicating the desired output unit number,*/
iout = 6;
/* / output control.*/
un = 1;
/* / real working array. */
lwar = 3 * nmax * nmax / 2 + 10 * nmax + 2 * mmax;
war = (double *)malloc(lwar * sizeof(double));
/* / integer working array. */
liwar = n ;
iwar = (int *)malloc(liwar * sizeof(int));
iwar[0] = 1;
/* / call ql0001_ */
ql0001_(&m, &me, &mmax, &n, &nmax, &mnn, Q, p, A, b, xl, xu,
z, lambda, &iout, info, &un, war, &lwar, iwar, &liwar, &tol);
/* / printf("tol = %10.4e\n",*tol);
//for (i=0;i<mnn;i++) printf("lambda[%i] = %g\n",i,lambda[i]);
// getting the multiplier due to the lower bounds*/
for (i = 0; i < n; i++) w[i] = lambda[m + i] ;
/*/ memory freeing*/
free(A);
free(p);
free(b);
free(xu);
free(xl);
free(lambda);
free(war);
free(iwar);
free(Q);
}