/* -------------------------------------------------------------------
Main MEX function - interface to Matlab.
[vec_x,exitflag,t,access,Nabla] =
gsmo_mex(H,f,a,b,LB,UB,x0,Nabla0,tmax,tolKKT,verb);
-------------------------------------------------------------------- */
void mexFunction( int nlhs, mxArray *plhs[],int nrhs, const mxArray*prhs[] )
{
int verb;
uint32_t i;
uint32_t MaxIter;
double TolKKT;
double *vec_x; /* output arg -- solution*/
double *vec_x0;
double *diag_H; /* diagonal of matrix H */
double *f; /* vector f */
double *a;
double b;
double *LB;
double *UB;
double fval;
/*------------------------------------------------------------------- */
/* Take input arguments */
/*------------------------------------------------------------------- */
if( nrhs != 10) mexErrMsgTxt("Incorrect number of input arguments.");
mat_H = mxGetPr(prhs[0]);
nVar = mxGetM(prhs[0]);
f = mxGetPr(prhs[1]);
a = mxGetPr(prhs[2]);
b = mxGetScalar(prhs[3]);
LB = mxGetPr(prhs[4]);
UB = mxGetPr(prhs[5]);
vec_x0 = mxGetPr(prhs[6]);
MaxIter = mxIsInf( mxGetScalar(prhs[7])) ? INT_MAX : (long)mxGetScalar(prhs[7]);
TolKKT = mxGetScalar(prhs[8]);
verb = (int)(mxGetScalar(prhs[9]));
if( verb > 0 ) {
mexPrintf("Settings of QP solver\n");
mexPrintf("MaxIter : %d\n", MaxIter );
mexPrintf("TolKKT : %f\n", TolKKT );
mexPrintf("nVar : %d\n", nVar );
mexPrintf("verb : %d\n", verb );
}
plhs[0] = mxCreateDoubleMatrix(nVar,1,mxREAL);
vec_x = mxGetPr(plhs[0]);
memcpy( vec_x, vec_x0, sizeof(double)*nVar );
diag_H = mxCalloc(nVar, sizeof(double));
if( diag_H == NULL ) mexErrMsgTxt("Not enough memory.");
for(i = 0; i < nVar; i++ )
diag_H[i] = mat_H[nVar*i+i];
/*------------------------------------------------------------------- */
/* Call QP solver */
/*------------------------------------------------------------------- */
state = libqp_gsmo_solver( &get_col, diag_H, f, a, b, LB, UB, vec_x,
nVar, MaxIter, TolKKT, NULL );
/*------------------------------------------------------------------- */
/* Generate outputs */
/*------------------------------------------------------------------- */
plhs[1] = mxCreateDoubleScalar(state.QP);
plhs[2] = mxCreateDoubleScalar((double)state.exitflag);
plhs[3] = mxCreateDoubleScalar((double)state.nIter);
/*------------------------------------------------------------------- */
/* Clean up */
/*------------------------------------------------------------------- */
mxFree( diag_H );
}
SGVector<float64_t> CKernelMeanMatching::compute_weights()
{
int32_t i,j;
ASSERT(m_kernel)
ASSERT(m_training_indices.vlen)
ASSERT(m_test_indices.vlen)
int32_t n_tr = m_training_indices.vlen;
int32_t n_te = m_test_indices.vlen;
SGVector<float64_t> weights(n_tr);
weights.zero();
kmm_K = SG_MALLOC(float64_t, n_tr*n_tr);
kmm_K_ld = n_tr;
float64_t* diag_K = SG_MALLOC(float64_t, n_tr);
for (i=0; i<n_tr; i++)
{
float64_t d = m_kernel->kernel(m_training_indices[i], m_training_indices[i]);
diag_K[i] = d;
kmm_K[i*n_tr+i] = d;
for (j=i+1; j<n_tr; j++)
{
d = m_kernel->kernel(m_training_indices[i],m_training_indices[j]);
kmm_K[i*n_tr+j] = d;
kmm_K[j*n_tr+i] = d;
}
}
float64_t* kappa = SG_MALLOC(float64_t, n_tr);
for (i=0; i<n_tr; i++)
{
float64_t avg = 0.0;
for (j=0; j<n_te; j++)
avg+= m_kernel->kernel(m_training_indices[i],m_test_indices[j]);
avg *= float64_t(n_tr)/n_te;
kappa[i] = -avg;
}
float64_t* a = SG_MALLOC(float64_t, n_tr);
for (i=0; i<n_tr; i++) a[i] = 1.0;
float64_t* LB = SG_MALLOC(float64_t, n_tr);
float64_t* UB = SG_MALLOC(float64_t, n_tr);
float64_t B = 2.0;
for (i=0; i<n_tr; i++)
{
LB[i] = 0.0;
UB[i] = B;
}
for (i=0; i<n_tr; i++)
weights[i] = 1.0/float64_t(n_tr);
libqp_state_T result =
libqp_gsmo_solver(&kmm_get_col,diag_K,kappa,a,1.0,LB,UB,weights,n_tr,1000,1e-9,NULL);
SG_DEBUG("libqp exitflag=%d, %d iterations passed, primal objective=%f\n",
result.exitflag,result.nIter,result.QP);
SG_FREE(kappa);
SG_FREE(a);
SG_FREE(LB);
SG_FREE(UB);
SG_FREE(diag_K);
SG_FREE(kmm_K);
return weights;
}
