void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
double *spm,*l,*v,*dim;
int m,m1,n,i,j,k, o;
int x,y,z,xdim,ydim,zdim;
double q;
if (nrhs != 3 || nlhs > 1) mexErrMsgTxt("Incorrect usage.");
for(k=0; k<nrhs; k++)
if (!mxIsNumeric(prhs[k]) || mxIsComplex(prhs[k]) ||
mxIsSparse(prhs[k]) || !mxIsDouble(prhs[k]))
mexErrMsgTxt("Arguments must be numeric, real, full and double.");
/* The values */
n = mxGetN(prhs[0])*mxGetM(prhs[0]);
v = mxGetPr(prhs[0]);
/* The co-ordinates */
if ((mxGetN(prhs[1]) != n) || (mxGetM(prhs[1]) != 3))
mexErrMsgTxt("Incompatible size for locations matrix.");
l = mxGetPr(prhs[1]);
/* Dimension information */
if (mxGetN(prhs[2])*mxGetM(prhs[2]) != 5)
mexErrMsgTxt("Incompatible size for dimensions vector.");
dim = mxGetPr(prhs[2]);
xdim = (int) (fabs(dim[0]) + 0.99);
ydim = (int) (fabs(dim[1]) + 0.99);
zdim = (int) (fabs(dim[2]) + 0.99);
m = (int) (dim[3]);
m1 = (int) (dim[4]);
plhs[0] = mxCreateDoubleMatrix(m,m1,mxREAL);
spm = mxGetPr(plhs[0]);
if (m == DY+DX && m1 == DZ+DX) /* MNI Space */
{
/* go though point list */
for (i = 0; i < n; i++)
{
x = (int)RINT(l[i*3 + 0]) + CX;
y = (int)RINT(l[i*3 + 1]) + CY;
z = (int)RINT(l[i*3 + 2]) + CZ;
if (2*CX-x-xdim/2>=0 && 2*CX-x+xdim/2<DX && y-ydim/2>=0 && y+ydim/2<DY) /* transverse */
{
q = v[i];
for (j = -ydim/2; j <= ydim/2; j++)
for (k = -xdim/2; k <= xdim/2; k++)
{
o = j + y + (k + 2*CX-x)*m;
if (spm[o]<q) spm[o] = q;
}
}
if (z-zdim/2>=0 && z+zdim/2<DZ && y-ydim/2>=0 && y+ydim/2<DY) /* sagittal */
{
q = v[i];
for (j = -ydim/2; j <= ydim/2; j++)
for (k = -zdim/2; k <= zdim/2; k++)
{
o = j + y + (DX + k + z)*m;
if (spm[o]<q) spm[o] = q;
}
}
if (x-xdim/2>=0 && x+xdim/2<DX && z-zdim/2>=0 && z+zdim/2<DZ) /* coronal */
{
q = v[i];
for (j = -xdim/2; j <= xdim/2; j++)
for (k = -zdim/2; k <= zdim/2; k++)
{
o = DY + j + x + (DX + k + z)*m;
if (spm[o]<q) spm[o] = q;
}
}
}
}
else if (m == 360 && m1 == 352) /* old code for the old MIP matrix */
{
for (i = 0; i < n; i++) {
x = (int) l[i*3 + 0];
y = (int) l[i*3 + 1];
z = (int) l[i*3 + 2];
/* transverse */
q = MAX(v[i], spm[(124 + y) + (104 - x)*m]);
for (j = 0; j < ydim; j++) {
for (k = 0; k < xdim; k++) {
spm[124 + j + y + (104 + k - x)*m] = q;
}
}
/* sagittal */
q = MAX(v[i], spm[(124 + y) + (240 + z)*m]);
for (j = 0; j < ydim; j++) {
for (k = 0; k < zdim; k++) {
spm[124 + j + y + (238 + k + z)*m] = q;
}
}
/* coronal */
q = MAX(v[i], spm[(276 + x) + (240 + z)*m]);
for (j = 0; j < xdim; j++) {
for (k = 0; k < zdim; k++) {
spm[276 + j + x + (238 + k + z)*m] = q;
}
}
}
}
else
mexErrMsgTxt("Wrong sized MIP matrix");
}
void mexFunction
(
int nargout,
mxArray *pargout [ ],
int nargin,
const mxArray *pargin [ ]
)
{
double dummy = 0 ;
double *Lx, *Lx2, *Lz, *Lz2 ;
Long *Li, *Lp, *Lnz2, *Li2, *Lp2, *ColCount ;
cholmod_sparse *A, Amatrix, *Lsparse, *S ;
cholmod_factor *L ;
cholmod_common Common, *cm ;
Long j, s, n, lnz, is_complex ;
/* ---------------------------------------------------------------------- */
/* start CHOLMOD and set parameters */
/* ---------------------------------------------------------------------- */
cm = &Common ;
cholmod_l_start (cm) ;
sputil_config (SPUMONI, cm) ;
/* ---------------------------------------------------------------------- */
/* check inputs */
/* ---------------------------------------------------------------------- */
if (nargout > 1 || nargin != 2)
{
mexErrMsgTxt ("usage: L = resymbol (L, A)\n") ;
}
n = mxGetN (pargin [0]) ;
if (!mxIsSparse (pargin [0]) || n != mxGetM (pargin [0]))
{
mexErrMsgTxt ("resymbol: L must be sparse and square") ;
}
if (n != mxGetM (pargin [1]) || n != mxGetN (pargin [1]))
{
mexErrMsgTxt ("resymbol: A and L must have same dimensions") ;
}
/* ---------------------------------------------------------------------- */
/* get the sparse matrix A */
/* ---------------------------------------------------------------------- */
A = sputil_get_sparse_pattern (pargin [1], &Amatrix, &dummy, cm) ;
S = (A == &Amatrix) ? NULL : A ;
A->stype = -1 ;
/* A = sputil_get_sparse (pargin [1], &Amatrix, &dummy, -1) ; */
/* ---------------------------------------------------------------------- */
/* construct a copy of the input sparse matrix L */
/* ---------------------------------------------------------------------- */
/* get the MATLAB L */
Lp = (Long *) mxGetJc (pargin [0]) ;
Li = (Long *) mxGetIr (pargin [0]) ;
Lx = mxGetPr (pargin [0]) ;
Lz = mxGetPi (pargin [0]) ;
is_complex = mxIsComplex (pargin [0]) ;
/* allocate the CHOLMOD symbolic L */
L = cholmod_l_allocate_factor (n, cm) ;
L->ordering = CHOLMOD_NATURAL ;
ColCount = L->ColCount ;
for (j = 0 ; j < n ; j++)
{
ColCount [j] = Lp [j+1] - Lp [j] ;
}
/* allocate space for a CHOLMOD LDL' packed factor */
/* (LL' and LDL' are treated identically) */
cholmod_l_change_factor (is_complex ? CHOLMOD_ZOMPLEX : CHOLMOD_REAL,
FALSE, FALSE, TRUE, TRUE, L, cm) ;
/* copy MATLAB L into CHOLMOD L */
Lp2 = L->p ;
Li2 = L->i ;
Lx2 = L->x ;
Lz2 = L->z ;
Lnz2 = L->nz ;
lnz = L->nzmax ;
for (j = 0 ; j <= n ; j++)
{
Lp2 [j] = Lp [j] ;
}
for (j = 0 ; j < n ; j++)
{
Lnz2 [j] = Lp [j+1] - Lp [j] ;
}
for (s = 0 ; s < lnz ; s++)
{
Li2 [s] = Li [s] ;
}
for (s = 0 ; s < lnz ; s++)
{
Lx2 [s] = Lx [s] ;
}
if (is_complex)
{
for (s = 0 ; s < lnz ; s++)
{
Lz2 [s] = Lz [s] ;
}
}
/* ---------------------------------------------------------------------- */
/* resymbolic factorization */
/* ---------------------------------------------------------------------- */
cholmod_l_resymbol (A, NULL, 0, TRUE, L, cm) ;
/* ---------------------------------------------------------------------- */
/* copy the results back to MATLAB */
/* ---------------------------------------------------------------------- */
Lsparse = cholmod_l_factor_to_sparse (L, cm) ;
/* return L as a sparse matrix */
pargout [0] = sputil_put_sparse (&Lsparse, cm) ;
/* ---------------------------------------------------------------------- */
/* free workspace and the CHOLMOD L, except for what is copied to MATLAB */
/* ---------------------------------------------------------------------- */
cholmod_l_free_factor (&L, cm) ;
cholmod_l_free_sparse (&S, cm) ;
cholmod_l_finish (cm) ;
cholmod_l_print_common (" ", cm) ;
/*
if (cm->malloc_count != 3 + mxIsComplex (pargout[0])) mexErrMsgTxt ("!") ;
*/
}
void mexFunction(int nlhs, mxArray *plhs[ ],
int nrhs, const mxArray *prhs[ ]) {
int i,j,pos;
int *ptr_int;
double *ptr_matlab;
#if MUMPS_ARITH == MUMPS_ARITH_z
double *ptri_matlab;
#endif
mwSize tmp_m,tmp_n;
/* C pointer for input parameters */
size_t inst_address;
mwSize n,m,ne, netrue ;
int job;
mwIndex *irn_in,*jcn_in;
/* variable for multiple and sparse rhs */
int posrhs;
mwSize nbrhs,ldrhs, nz_rhs;
mwIndex *irhs_ptr, *irhs_sparse;
double *rhs_sparse;
#if MUMPS_ARITH == MUMPS_ARITH_z
double *im_rhs_sparse;
#endif
DMUMPS_STRUC_C *dmumps_par;
int dosolve = 0;
int donullspace = 0;
int doanalysis = 0;
int dofactorize = 0;
EXTRACT_FROM_MATLAB_TOVAL(JOB,job);
doanalysis = (job == 1 || job == 4 || job == 6);
dofactorize = (job == 2 || job == 4 || job == 5 || job == 6);
dosolve = (job == 3 || job == 5 || job == 6);
if(job == -1){
DMUMPS_alloc(&dmumps_par);
EXTRACT_FROM_MATLAB_TOVAL(SYM,dmumps_par->sym);
dmumps_par->job = -1;
dmumps_par->par = 1;
dmumps_c(dmumps_par);
dmumps_par->nz = -1;
dmumps_par->nz_alloc = -1;
}else{
EXTRACT_FROM_MATLAB_TOVAL(INST,inst_address);
ptr_int = (int *) inst_address;
dmumps_par = (DMUMPS_STRUC_C *) ptr_int;
if(job == -2){
dmumps_par->job = -2;
dmumps_c(dmumps_par);
/* If colsca/rowsca were freed by MUMPS,
dmumps_par->colsca/rowsca are now null.
Application of MYFREE in call below thus ok */
DMUMPS_free(&dmumps_par);
}else{
/* check of input arguments */
n = mxGetN(A_IN);
m = mxGetM(A_IN);
if (!mxIsSparse(A_IN) || n != m )
mexErrMsgTxt("Input matrix must be a sparse square matrix");
jcn_in = mxGetJc(A_IN);
ne = jcn_in[n];
irn_in = mxGetIr(A_IN);
dmumps_par->n = (int)n;
if(dmumps_par->n != n)
mexErrMsgTxt("Input is too big; will not work...barfing out\n");
if(dmumps_par->sym != 0)
netrue = (n+ne)/2;
else
netrue = ne;
if(dmumps_par->nz_alloc < netrue || dmumps_par->nz_alloc >= 2*netrue){
MYFREE(dmumps_par->jcn);
MYFREE(dmumps_par->irn);
MYFREE(dmumps_par->a);
MYMALLOC((dmumps_par->jcn),(int)netrue,int);
MYMALLOC((dmumps_par->irn),(int)netrue,int);
MYMALLOC((dmumps_par->a),(int)netrue,double2);
dmumps_par->nz_alloc = (int)netrue;
if (dmumps_par->nz_alloc != netrue)
mexErrMsgTxt("Input is too big; will not work...barfing out\n");
}
if(dmumps_par->sym == 0){
/* if analysis already performed then we only need to read
numerical values
Note that we suppose that matlab did not change the internal
format of the matrix between the 2 calls */
if(doanalysis){
/* || dmumps_par->info[22] == 0 */
for(i=0;i<dmumps_par->n;i++){
for(j=jcn_in[i];j<jcn_in[i+1];j++){
(dmumps_par->jcn)[j] = i+1;
(dmumps_par->irn)[j] = ((int)irn_in[j])+1;
}
}
}
dmumps_par->nz = (int)ne;
if( dmumps_par->nz != ne)
mexErrMsgTxt("Input is too big; will not work...barfing out\n");
#if MUMPS_ARITH == MUMPS_ARITH_z
ptr_matlab = mxGetPr(A_IN);
for(i=0;i<dmumps_par->nz;i++){
((dmumps_par->a)[i]).r = ptr_matlab[i];
}
ptr_matlab = mxGetPi(A_IN);
if(ptr_matlab){
for(i=0;i<dmumps_par->nz;i++){
((dmumps_par->a)[i]).i = ptr_matlab[i];
}
}else{
for(i=0;i<dmumps_par->nz;i++){
((dmumps_par->a)[i]).i = 0.0;
}
}
#else
ptr_matlab = mxGetPr(A_IN);
for(i=0;i<dmumps_par->nz;i++){
(dmumps_par->a)[i] = ptr_matlab[i];
}
#endif
}else{
/* in the symmetric case we do not need to check doanalysis */
pos = 0;
ptr_matlab = mxGetPr(A_IN);
#if MUMPS_ARITH == MUMPS_ARITH_z
ptri_matlab = mxGetPi(A_IN);
#endif
for(i=0;i<dmumps_par->n;i++){
for(j=jcn_in[i];j<jcn_in[i+1];j++){
if(irn_in[j] >= i){
if(pos >= netrue)
mexErrMsgTxt("Input matrix must be symmetric");
(dmumps_par->jcn)[pos] = i+1;
(dmumps_par->irn)[pos] = (int)irn_in[j]+1;
#if MUMPS_ARITH == MUMPS_ARITH_z
((dmumps_par->a)[pos]).r = ptr_matlab[j];
if(ptri_matlab){
((dmumps_par->a)[pos]).i = ptri_matlab[j];
}else{
((dmumps_par->a)[pos]).i = 0.0;
}
#else
(dmumps_par->a)[pos] = ptr_matlab[j];
#endif
pos++;
}
}
}
dmumps_par->nz = pos;
}
EXTRACT_FROM_MATLAB_TOVAL(JOB,dmumps_par->job);
EXTRACT_FROM_MATLAB_TOARR(ICNTL_IN,dmumps_par->icntl,int,40);
EXTRACT_FROM_MATLAB_TOARR(CNTL_IN,dmumps_par->cntl,double,15);
EXTRACT_FROM_MATLAB_TOPTR(PERM_IN,(dmumps_par->perm_in),int,((int)n));
/* colsca and rowsca are treated differently: it may happen that
dmumps_par-> colsca is nonzero because it was set to a nonzero
value on output (COLSCA_OUT) from MUMPS. Unfortunately if scaling
was on output, one cannot currently provide scaling on input
afterwards without reinitializing the instance */
EXTRACT_SCALING_FROM_MATLAB_TOPTR(COLSCA_IN,(dmumps_par->colsca),(dmumps_par->colsca_from_mumps),((int)n)); /* type always double */
EXTRACT_SCALING_FROM_MATLAB_TOPTR(ROWSCA_IN,(dmumps_par->rowsca),(dmumps_par->rowsca_from_mumps),((int)n)); /* type always double */
EXTRACT_FROM_MATLAB_TOARR(KEEP_IN,dmumps_par->keep,int,500);
EXTRACT_FROM_MATLAB_TOARR(DKEEP_IN,dmumps_par->dkeep,double,30);
dmumps_par->size_schur = (int)mxGetN(VAR_SCHUR);
EXTRACT_FROM_MATLAB_TOPTR(VAR_SCHUR,(dmumps_par->listvar_schur),int,dmumps_par->size_schur);
if(!dmumps_par->listvar_schur) dmumps_par->size_schur = 0;
ptr_matlab = mxGetPr (RHS_IN);
/*
* To follow the "spirit" of the Matlab/Scilab interfaces, treat case of null
* space separately. In that case, we initialize lrhs and nrhs, automatically
* allocate the space needed, and do not rely on what is provided by the user
* in component RHS, that is not touched.
*
* Note that, at the moment, the user should not call the solution step combined
* with the factorization step when he/she sets icntl[25-1] to a non-zero value.
* Hence we suppose in the following that infog[28-1] is available and that we
* can use it.
*
* For users of scilab/matlab, it would still be nice to be able to set ICNTL(25)=-1,
* and use JOB=6. If we want to make such a feature available, we should
* call separately job=2 and job=3 even if job=5 or 6 and set nbrhs (and allocate
* space correctly) between job=2 and job=3 calls to MUMPS.
*
*/
if ( dmumps_par->icntl[25-1] == -1 && dmumps_par->infog[28-1] > 0 ) {
dmumps_par->nrhs=dmumps_par->infog[28-1];
donullspace = dosolve;
}
else if ( dmumps_par->icntl[25-1] > 0 && dmumps_par->icntl[25-1] <= dmumps_par->infog[28-1] ) {
dmumps_par->nrhs=1;
donullspace = dosolve;
}
else {
donullspace=0;
}
if (donullspace) {
nbrhs=dmumps_par->nrhs; ldrhs=n;
dmumps_par->lrhs=(int)n;
MYMALLOC((dmumps_par->rhs),((dmumps_par->n)*(dmumps_par->nrhs)),double2);
}
else if((!dosolve) || ptr_matlab[0] == -9999 ) { /* rhs not already provided, or not used */
/* Case where dosolve is true and ptr_matlab[0]=-9999, this could cause problems:
* 1/ RHS was not initialized while it should have been
* 2/ RHS was explicitely initialized to -9999 but is not allocated of the right size
*/
EXTRACT_CMPLX_FROM_MATLAB_TOPTR(RHS_IN,(dmumps_par->rhs),double,1);
}else{
/* ************************************************************
PROCEDURE mexFunction - Entry for Matlab
************************************************************ */
void mexFunction(const int nlhs, mxArray *plhs[],
const int nrhs, const mxArray *prhs[])
{
const mxArray *MY_FIELD;
char *ordered;
int m,n,nden,dznnz, i,j, permnnz, pnnz;
const double *beta, *betajcPr, *orderedPr, *pivpermPr, *p;
int *betajc, *pivperm;
double *y, *fwork;
jcir dz;
/* ------------------------------------------------------------
Check for proper number of arguments
------------------------------------------------------------ */
mxAssert(nrhs >= NPARIN, "bwdpr1 requires more input arguments.");
mxAssert(nlhs <= NPAROUT, "bwdpr1 generates less output arguments.");
/* ------------------------------------------------------------
Get input b
------------------------------------------------------------ */
mxAssert(!mxIsSparse(B_IN), "b should be full");
m = mxGetM(B_IN);
n = mxGetN(B_IN);
/* ------------------------------------------------------------
Create output y as a copy of b
------------------------------------------------------------ */
Y_OUT = mxDuplicateArray(B_IN); /* Y_OUT = B_IN */
y = mxGetPr(Y_OUT);
/* ------------------------------------------------------------
Disassemble dense-update structure Lden (p,xsuper,beta,betajc,rowperm)
NOTE: if there are no dense columns, then simply let y = b, and return.
------------------------------------------------------------ */
mxAssert(mxIsStruct(LDEN_IN), "Parameter `Lden' should be a structure.");
MY_FIELD = mxGetField(LDEN_IN,0,"betajc"); /* betajc */
mxAssert( MY_FIELD != NULL, "Missing field Lden.betajc.");
nden = mxGetM(MY_FIELD) * mxGetN(MY_FIELD) - 1;
/* If no dense columns: get out immediately ! */
if(nden == 0)
return;
else{
betajcPr = mxGetPr(MY_FIELD);
MY_FIELD = mxGetField(LDEN_IN,0,"p"); /* p */
mxAssert( MY_FIELD != NULL, "Missing field Lden.p.");
p = mxGetPr(MY_FIELD);
pnnz = mxGetM(MY_FIELD) * mxGetN(MY_FIELD);
MY_FIELD = mxGetField(LDEN_IN,0,"dopiv"); /* dopiv */
mxAssert( MY_FIELD != NULL, "Missing field Lden.dopiv.");
mxAssert(mxGetM(MY_FIELD) * mxGetN(MY_FIELD) == nden, "Size mismatch Lden.dopiv.");
orderedPr = mxGetPr(MY_FIELD);
MY_FIELD = mxGetField(LDEN_IN,0,"pivperm"); /* pivperm */
mxAssert( MY_FIELD != NULL, "Missing field Lden.pivperm.");
pivpermPr = mxGetPr(MY_FIELD);
permnnz = mxGetM(MY_FIELD) * mxGetN(MY_FIELD);
MY_FIELD = mxGetField(LDEN_IN,0,"beta"); /* beta */
mxAssert( MY_FIELD != NULL, "Missing field Lden.beta.");
beta = mxGetPr(MY_FIELD);
MY_FIELD = mxGetField(LDEN_IN,0,"dz"); /* dz */
mxAssert( MY_FIELD != NULL, "Missing field Lden.dz.");
mxAssert(mxGetM(MY_FIELD) == m && mxGetN(MY_FIELD) == nden, "Lden.dz size mismatch.");
mxAssert(mxIsSparse(MY_FIELD), "Lden.dz must be sparse.");
dz.jc = mxGetJc(MY_FIELD);
dz.ir = mxGetIr(MY_FIELD); /* (rowperm) */
dznnz = dz.jc[nden];
mxAssert(dznnz <= m, "Lden.dz size mismatch.");
/* ------------------------------------------------------------
Allocate working arrays int: betajc(nden+1), pivperm(permnnz),
char: ordered(nden)
double: fwork(dznnz)
------------------------------------------------------------ */
betajc = (int *) mxCalloc(nden + 1,sizeof(int));
pivperm = (int *) mxCalloc(MAX(permnnz,1),sizeof(int));
ordered = (char *) mxCalloc(nden,sizeof(char)); /* nden > 0 */
fwork = (double *) mxCalloc(MAX(dznnz,1), sizeof(double));
/* ------------------------------------------------------------
Convert betajcPr, ordered, pivperm to int
------------------------------------------------------------ */
for(i = 0; i <= nden; i++){
j = betajcPr[i];
betajc[i] = --j;
}
for(i = 0; i < nden; i++){
ordered[i] = orderedPr[i];
}
for(i = 0; i < permnnz; i++){
pivperm[i] = pivpermPr[i];
}
MY_FIELD = mxGetField(LDEN_IN,0,"beta");
mxAssert(mxGetM(MY_FIELD) * mxGetN(MY_FIELD) == betajc[nden], "Size mismatch Lden.beta.");
/* ------------------------------------------------------------
The actual job is done here: y(perm,:) = PROD_L'\b(perm,:).
------------------------------------------------------------ */
for(j = 0; j < n; j++, y += m){
for(i = 0; i < dznnz; i++) /* fwork = y(dzir) */
fwork[i] = y[dz.ir[i]];
bwprodform(fwork, dz.jc, pivperm, p, beta, betajc, ordered, nden,
pnnz, permnnz);
for(i = 0; i < dznnz; i++) /* y(dzir) = fwork */
y[dz.ir[i]] = fwork[i];
}
/* ------------------------------------------------------------
Release working arrays
------------------------------------------------------------ */
mxFree(fwork);
mxFree(ordered);
mxFree(pivperm);
mxFree(betajc);
} /* if dense columns */
}
/* Function: mdlCheckParameters =============================================
* Abstract:
* Validate our parameters to verify they are okay.
*/
static void mdlCheckParameters(SimStruct *S)
{
int_T i;
static char_T msg[100];
/* for RTW we do not need these variables */
#ifdef MATLAB_MEX_FILE
const char *fname;
mxArray *fval;
int_T nfields;
#endif
/* Check 1st parameter: number of states */
{
if ( !mxIsDouble(ssGetSFcnParam(S,0)) ||
mxIsEmpty(ssGetSFcnParam(S,0)) ||
mxGetNumberOfElements(ssGetSFcnParam(S,0))!=1 ||
mxGetScalar(ssGetSFcnParam(S,0))<=0 ||
mxIsNaN(*mxGetPr(ssGetSFcnParam(S,0))) ||
mxIsInf(*mxGetPr(ssGetSFcnParam(S,0))) ||
mxIsSparse(ssGetSFcnParam(S,0)) ) {
ssSetErrorStatus(S,"lcp_sfun: Number of states must be of type double, not empty, scalar and finite.");
return;
}
}
/* Check 2nd parameter: sample time */
{
if ( !mxIsDouble(ssGetSFcnParam(S,1)) ||
mxIsEmpty(ssGetSFcnParam(S,1)) ||
mxGetNumberOfElements(ssGetSFcnParam(S,1))!=1 ||
mxGetScalar(ssGetSFcnParam(S,1))<=0 ||
mxIsNaN(*mxGetPr(ssGetSFcnParam(S,1))) ||
mxIsInf(*mxGetPr(ssGetSFcnParam(S,1))) ||
mxIsSparse(ssGetSFcnParam(S,1)) ) {
ssSetErrorStatus(S,"lcp_sfun: Sample time must be of type double, not empty, scalar and finite.");
return;
}
}
#ifdef MATLAB_MEX_FILE
/* Check 3rd parameter: options */
if (ssGetSFcnParamsCount(S)==3)
{
if (!mxIsStruct(ssGetSFcnParam(S,2))) {
ssSetErrorStatus(S, "lcp_sfun: Options must be in STRUCT format.");
return;
}
else if (mxGetNumberOfElements(ssGetSFcnParam(S,2))>1) {
ssSetErrorStatus(S,"lcp_sfun: Only one option structure is allowed.");
return;
}
/* checking each option individually */
nfields = mxGetNumberOfFields(ssGetSFcnParam(S,2));
for (i=0; i<nfields; i++) {
fname = mxGetFieldNameByNumber(ssGetSFcnParam(S,2), i);
fval = mxGetField(ssGetSFcnParam(S,2), 0, fname);
/* check for proper field names */
if (!( (strcmp(fname, "zerotol")==0) || (strcmp(fname, "maxpiv")==0) ||
(strcmp(fname, "lextol")==0) || (strcmp(fname, "nstepf")==0) ||
(strcmp(fname, "clock")==0) || (strcmp(fname, "verbose")==0) ||
(strcmp(fname, "routine")==0) || (strcmp(fname, "timelimit")==0) ||
(strcmp(fname, "normalize")==0) || (strcmp(fname, "normalizethres")==0) )) {
strcpy(msg,"");
strcat(msg, "lcp_sfun: The field '");
strcat(msg, fname);
strcat(msg, "' is not allowed in the options structure.");
ssSetErrorStatus(S, msg);
return;
}
/* some options must be nonnegative */
if (strcmp(fname,"zerotol")==0 || strcmp(fname,"maxpiv")==0 ||
strcmp(fname,"timelimit")==0 || strcmp(fname,"lextol")==0 ||
(strcmp(fname,"nstepf")==0) || (strcmp(fname, "normalizethres")==0) ) {
if (!mxIsDouble(fval) || mxIsEmpty(fval) || (mxGetM(fval)*mxGetN(fval))!=1 ||
(mxGetScalar(fval)<=0) ) {
strcpy(msg,"");
strcat(msg, "lcp_sfun: Option value '");
strcat(msg, fname);
strcat(msg, "' must be of type double, nonempty, scalar, and nonnegative.");
ssSetErrorStatus(S, msg);
return;
}
}
/* some can be zeros */
if (strcmp(fname,"clock")==0 || strcmp(fname,"verbose")==0 ||
strcmp(fname,"routine")==0 || strcmp(fname,"normalize")==0) {
if (!mxIsDouble(fval) || mxIsEmpty(fval) || (mxGetM(fval)*mxGetN(fval))!=1 ) {
strcpy(msg,"");
strcat(msg, "lcp_sfun: Option value '");
strcat(msg, fname);
strcat(msg, "' must be of type double, nonempty, scalar, and integer valued.");
ssSetErrorStatus(S, msg);
return;
}
}
/* No NaN values allowed */
if ( mxIsNaN(*mxGetPr(fval)) ) {
ssSetErrorStatus(S, "lcp_sfun: No 'NaN' are allowed in the options structure.");
return;
}
/* Inf value allowed only for timelimit */
if ( strcmp(fname,"timelimit")!=0 && mxIsInf(*mxGetPr(fval)) ) {
ssSetErrorStatus(S, "lcp_sfun: No 'Inf' terms allowed except for 'timelimit' option.");
return;
}
}
}
#endif
}
void mexFunction
(
/* === Parameters ======================================================= */
int nlhs, /* number of left-hand sides */
mxArray *plhs [], /* left-hand side matrices */
int nrhs, /* number of right--hand sides */
const mxArray *prhs [] /* right-hand side matrices */
)
{
Zmat A;
DAMGlevelmat *PRE;
DILUPACKparam *param;
integer n;
const char **fnames;
const mwSize *dims;
mxClassID *classIDflags;
mxArray *A_input , *b_input, *x0_input, *options_input, *PRE_input,
*options_output, *x_output, *tmp, *fout;
char *pdata, *input_buf, *output_buf;
mwSize mrows, ncols, buflen, ndim,nnz;
int ifield, status, nfields, ierr,i,j,k,l,m;
size_t sizebuf;
double dbuf, *A_valuesR, *A_valuesI, *convert, *sr, *pr, *pi;
doublecomplex *sol, *rhs;
mwIndex *irs, *jcs,
*A_ja, /* row indices of input matrix A */
*A_ia; /* column pointers of input matrix A */
if (nrhs != 5)
mexErrMsgTxt("five input arguments required.");
else if (nlhs !=2)
mexErrMsgTxt("Too many output arguments.");
else if (!mxIsStruct(prhs[2]))
mexErrMsgTxt("Third input must be a structure.");
else if (!mxIsNumeric(prhs[0]))
mexErrMsgTxt("First input must be a matrix.");
/* The first input must be a square matrix.*/
A_input = (mxArray *) prhs [0] ;
/* get size of input matrix A */
mrows = mxGetM (A_input) ;
ncols = mxGetN (A_input) ;
nnz = mxGetNzmax(A_input);
if (mrows!=ncols) {
mexErrMsgTxt("First input must be a square matrix.");
}
if (!mxIsSparse (A_input))
{
mexErrMsgTxt ("ILUPACK: input matrix must be in sparse format.") ;
}
/* copy input matrix to sparse row format */
A.nc=A.nr=mrows;
A.ia=(integer *) MAlloc((size_t)(A.nc+1)*sizeof(integer),"ZGNLDGNLilupacksolver");
A.ja=(integer *) MAlloc((size_t)nnz *sizeof(integer),"ZGNLDGNLilupacksolver");
A. a=(doublecomplex *) MAlloc((size_t)nnz *sizeof(doublecomplex), "ZGNLDGNLilupacksolver");
A_ja = (mwIndex *) mxGetIr (A_input) ;
A_ia = (mwIndex *) mxGetJc (A_input) ;
A_valuesR = (double *) mxGetPr(A_input);
if (mxIsComplex(A_input))
A_valuesI = (double *) mxGetPi(A_input);
/* -------------------------------------------------------------------- */
/* .. Convert matrix from 0-based C-notation to Fortran 1-based */
/* notation. */
/* -------------------------------------------------------------------- */
/*
for (i = 0 ; i < ncols ; i++)
for (j = A_ia[i] ; j < A_ia[i+1] ; j++)
printf("i=%d j=%d A.real=%e\n", i+1, A_ja[j]+1, A_valuesR[j]);
*/
for (i=0; i<=A.nr; i++)
A.ia[i]=0;
/* remember that MATLAB uses storage by columns and NOT by rows! */
for (i=0; i<A.nr; i++) {
for (j=A_ia[i]; j<A_ia[i+1]; j++) {
k=A_ja[j];
A.ia[k+1]++;
}
}
/* now we know how many entries are located in every row */
/* switch to pointer structure */
for (i=0; i<A.nr; i++)
A.ia[i+1]+=A.ia[i];
if (mxIsComplex(A_input)) {
for (i=0; i<ncols; i++) {
for (j=A_ia[i]; j<A_ia[i+1]; j++) {
/* row index l in C-notation */
l=A_ja[j];
/* where does row l currently start */
k=A.ia[l];
/* column index will be i in FORTRAN notation */
A.ja[k]=i+1;
A.a [k].r =A_valuesR[j];
A.a [k++].i=A_valuesI[j];
A.ia[l]=k;
}
}
}
else {
for (i=0; i<ncols; i++) {
for (j=A_ia[i]; j<A_ia[i+1]; j++) {
/* row index l in C-notation */
l=A_ja[j];
/* where does row l currently start */
k=A.ia[l];
/* column index will be i in FORTRAN notation */
A.ja[k]=i+1;
A.a [k].r =A_valuesR[j];
A.a [k++].i=0;
A.ia[l]=k;
}
}
}
/* switch to FORTRAN style */
for (i=A.nr; i>0; i--)
A.ia[i]=A.ia[i-1]+1;
A.ia[0]=1;
/*
for (i = 0 ; i < A.nr ; i++)
for (j = A.ia[i]-1 ; j < A.ia[i+1]-1 ; j++)
printf("i=%d j=%d A.real=%e A.imag=%e\n", i+1, A.ja[j], A.a[j].r, A.a[j].i);
*/
/* import pointer to the preconditioner */
PRE_input = (mxArray*) prhs [1] ;
/* get number of levels of input preconditioner structure `PREC' */
/* nlev=mxGetN(PRE_input); */
nfields = mxGetNumberOfFields(PRE_input);
/* allocate memory for storing pointers */
fnames = mxCalloc((size_t)nfields, (size_t)sizeof(*fnames));
for (ifield = 0; ifield < nfields; ifield++) {
fnames[ifield] = mxGetFieldNameByNumber(PRE_input,ifield);
/* check whether `PREC.ptr' exists */
if (!strcmp("ptr",fnames[ifield])) {
/* field `ptr' */
tmp = mxGetFieldByNumber(PRE_input,0,ifield);
pdata = mxGetData(tmp);
memcpy(&PRE, pdata, (size_t)sizeof(size_t));
}
else if (!strcmp("param",fnames[ifield])) {
/* field `param' */
tmp = mxGetFieldByNumber(PRE_input,0,ifield);
pdata = mxGetData(tmp);
memcpy(¶m, pdata, (size_t)sizeof(size_t));
}
}
mxFree(fnames);
/* rescale input matrix */
/* obsolete
for (i=0; i <A.nr; i++) {
for (j=A.ia[i]-1; j<A.ia[i+1]-1; j++) {
A.a[j].r*=PRE->rowscal[i]*PRE->colscal[A.ja[j]-1];
A.a[j].i*=PRE->rowscal[i]*PRE->colscal[A.ja[j]-1];
}
}
*/
/* Get third input argument `options' */
options_input=(mxArray*)prhs[2];
nfields = mxGetNumberOfFields(options_input);
/* Allocate memory for storing classIDflags */
classIDflags = (mxClassID *) mxCalloc((size_t)nfields+1, (size_t)sizeof(mxClassID));
/* allocate memory for storing pointers */
fnames = mxCalloc((size_t)nfields+1, (size_t)sizeof(*fnames));
/* Get field name pointers */
j=-1;
for (ifield = 0; ifield < nfields; ifield++) {
fnames[ifield] = mxGetFieldNameByNumber(options_input,ifield);
/* check whether `options.niter' already exists */
if (!strcmp("niter",fnames[ifield]))
j=ifield;
}
if (j==-1)
fnames[nfields]="niter";
/* mexPrintf("search for niter completed\n"); fflush(stdout); */
/* import data */
for (ifield = 0; ifield < nfields; ifield++) {
/* mexPrintf("%2d\n",ifield+1); fflush(stdout); */
tmp = mxGetFieldByNumber(options_input,0,ifield);
classIDflags[ifield] = mxGetClassID(tmp);
ndim = mxGetNumberOfDimensions(tmp);
dims = mxGetDimensions(tmp);
/* Create string/numeric array */
if (classIDflags[ifield] == mxCHAR_CLASS) {
/* Get the length of the input string. */
buflen = (mxGetM(tmp) * mxGetN(tmp)) + 1;
/* Allocate memory for input and output strings. */
input_buf = (char *) mxCalloc((size_t)buflen, (size_t)sizeof(char));
/* Copy the string data from tmp into a C string
input_buf. */
status = mxGetString(tmp, input_buf, buflen);
if (!strcmp("amg",fnames[ifield])) {
if (strcmp(param->amg,input_buf)) {
param->amg=(char *)MAlloc((size_t)buflen*sizeof(char),"ilupacksolver");
strcpy(param->amg,input_buf);
}
}
else if (!strcmp("presmoother",fnames[ifield])) {
if (strcmp(param->presmoother,input_buf)) {
param->presmoother=(char *)MAlloc((size_t)buflen*sizeof(char),
"ilupacksolver");
strcpy(param->presmoother,input_buf);
}
}
else if (!strcmp("postsmoother",fnames[ifield])) {
if (strcmp(param->postsmoother,input_buf)) {
param->postsmoother=(char *)MAlloc((size_t)buflen*sizeof(char),
"ilupacksolver");
strcpy(param->postsmoother,input_buf);
}
}
else if (!strcmp("typecoarse",fnames[ifield])) {
if (strcmp(param->typecoarse,input_buf)) {
param->typecoarse=(char *)MAlloc((size_t)buflen*sizeof(char),
"ilupacksolver");
strcpy(param->typecoarse,input_buf);
}
}
else if (!strcmp("typetv",fnames[ifield])) {
if (strcmp(param->typetv,input_buf)) {
param->typetv=(char *)MAlloc((size_t)buflen*sizeof(char),
"ilupacksolver");
strcpy(param->typetv,input_buf);
}
}
else if (!strcmp("FCpart",fnames[ifield])) {
if (strcmp(param->FCpart,input_buf)) {
param->FCpart=(char *)MAlloc((size_t)buflen*sizeof(char),
"ilupacksolver");
strcpy(param->FCpart,input_buf);
}
}
else if (!strcmp("solver",fnames[ifield])) {
if (strcmp(param->solver,input_buf)) {
param->solver=(char *)MAlloc((size_t)buflen*sizeof(char),
"ilupacksolver");
strcpy(param->solver,input_buf);
}
}
else if (!strcmp("ordering",fnames[ifield])) {
if (strcmp(param->ordering,input_buf)) {
param->ordering=(char *)MAlloc((size_t)buflen*sizeof(char),
"ilupacksolver");
strcpy(param->ordering,input_buf);
}
}
else {
/* mexPrintf("%s ignored\n",fnames[ifield]);fflush(stdout); */
}
}
else {
if (!strcmp("elbow",fnames[ifield])) {
param->elbow=*mxGetPr(tmp);
}
else if (!strcmp("lfilS",fnames[ifield])) {
param->lfilS=*mxGetPr(tmp);
}
else if (!strcmp("lfil",fnames[ifield])) {
param->lfil=*mxGetPr(tmp);
}
else if (!strcmp("maxit",fnames[ifield])) {
param->maxit=*mxGetPr(tmp);
}
else if (!strcmp("droptolS",fnames[ifield])) {
param->droptolS=*mxGetPr(tmp);
}
else if (!strcmp("droptol",fnames[ifield])) {
param->droptol=*mxGetPr(tmp);
}
else if (!strcmp("condest",fnames[ifield])) {
param->condest=*mxGetPr(tmp);
}
else if (!strcmp("restol",fnames[ifield])) {
param->restol=*mxGetPr(tmp);
}
else if (!strcmp("npresmoothing",fnames[ifield])) {
param->npresmoothing=*mxGetPr(tmp);
}
else if (!strcmp("npostmoothing",fnames[ifield])) {
param->npostsmoothing=*mxGetPr(tmp);
}
else if (!strcmp("ncoarse",fnames[ifield])) {
param->ncoarse=*mxGetPr(tmp);
}
else if (!strcmp("matching",fnames[ifield])) {
param->matching=*mxGetPr(tmp);
}
else if (!strcmp("nrestart",fnames[ifield])) {
param->nrestart=*mxGetPr(tmp);
}
else if (!strcmp("damping",fnames[ifield])) {
param->damping=*mxGetPr(tmp);
}
else if (!strcmp("mixedprecision",fnames[ifield])) {
param->mixedprecision=*mxGetPr(tmp);
}
else {
/* mexPrintf("%s ignored\n",fnames[ifield]);fflush(stdout); */
}
}
}
/* copy right hand side `b' */
b_input = (mxArray *) prhs [3];
/* get size of input matrix A */
rhs=(doublecomplex*) MAlloc((size_t)A.nr*sizeof(doublecomplex),"ZGNLilupacksolver:rhs");
pr=mxGetPr(b_input);
if (!mxIsComplex(b_input)) {
for (i=0; i<A.nr; i++) {
rhs[i].r=pr[i];
rhs[i].i=0;
}
}
else {
pi=mxGetPi(b_input);
for (i=0; i<A.nr; i++) {
rhs[i].r=pr[i];
rhs[i].i=pi[i];
}
}
/* copy initial solution `x0' */
x0_input = (mxArray *) prhs [4] ;
/* numerical solution */
sol=(doublecomplex *)MAlloc((size_t)A.nr*sizeof(doublecomplex),"ZGNLDGNLilupacksolver:sol");
pr=mxGetPr(x0_input);
if (!mxIsComplex(x0_input)) {
for (i=0; i<A.nr; i++) {
sol[i].r=pr[i];
sol[i].i=0;
}
}
else {
pi=mxGetPi(x0_input);
for (i=0; i<A.nr; i++) {
sol[i].r=pr[i];
sol[i].i=pi[i];
}
}
/* set bit 2, transpose */
param->ipar[4]|=4;
/* set bit 3, conjugate */
param->ipar[4]|=0;
ierr=ZGNLDGNLAMGsolver(&A, PRE, param, rhs, sol);
/* Create a struct matrices for output */
nlhs=2;
if (j==-1)
plhs[1] = mxCreateStructMatrix((mwSize)1, (mwSize)1, (mwSize)nfields+1, fnames);
else
plhs[1] = mxCreateStructMatrix((mwSize)1, (mwSize)1, (mwSize)nfields, fnames);
if (plhs[1]==NULL)
mexErrMsgTxt("Could not create structure mxArray\n");
options_output=plhs[1];
/* export data */
for (ifield = 0; ifield<nfields; ifield++) {
tmp = mxGetFieldByNumber(options_input,0,ifield);
classIDflags[ifield] = mxGetClassID(tmp);
ndim = mxGetNumberOfDimensions(tmp);
dims = mxGetDimensions(tmp);
/* Create string/numeric array */
if (classIDflags[ifield] == mxCHAR_CLASS) {
if (!strcmp("amg",fnames[ifield])) {
output_buf = (char *) mxCalloc((size_t)strlen(param->amg)+1, (size_t)sizeof(char));
strcpy(output_buf,param->amg);
fout = mxCreateString(output_buf);
}
else if (!strcmp("presmoother",fnames[ifield])) {
output_buf = (char *) mxCalloc((size_t)strlen(param->presmoother)+1, (size_t)sizeof(char));
strcpy(output_buf,param->presmoother);
fout = mxCreateString(output_buf);
}
else if (!strcmp("postsmoother",fnames[ifield])) {
output_buf = (char *) mxCalloc((size_t)strlen(param->postsmoother)+1, (size_t)sizeof(char));
strcpy(output_buf,param->postsmoother);
fout = mxCreateString(output_buf);
}
else if (!strcmp("typecoarse",fnames[ifield])) {
output_buf = (char *) mxCalloc((size_t)strlen(param->typecoarse)+1, (size_t)sizeof(char));
strcpy(output_buf,param->typecoarse);
fout = mxCreateString(output_buf);
}
else if (!strcmp("typetv",fnames[ifield])) {
output_buf = (char *) mxCalloc((size_t)strlen(param->typetv)+1, (size_t)sizeof(char));
strcpy(output_buf,param->typetv);
fout = mxCreateString(output_buf);
}
else if (!strcmp("FCpart",fnames[ifield])) {
output_buf = (char *) mxCalloc((size_t)strlen(param->FCpart)+1, (size_t)sizeof(char));
strcpy(output_buf,param->FCpart);
fout = mxCreateString(output_buf);
}
else if (!strcmp("solver",fnames[ifield])) {
output_buf = (char *) mxCalloc((size_t)strlen(param->solver)+1, (size_t)sizeof(char));
strcpy(output_buf, param->solver);
fout = mxCreateString(output_buf);
}
else if (!strcmp("ordering",fnames[ifield])) {
output_buf = (char *) mxCalloc((size_t)strlen(param->ordering)+1, (size_t)sizeof(char));
strcpy(output_buf, param->ordering);
fout = mxCreateString(output_buf);
}
else {
/* Get the length of the input string. */
buflen = (mxGetM(tmp) * mxGetN(tmp)) + 1;
/* Allocate memory for input and output strings. */
input_buf = (char *) mxCalloc((size_t)buflen, (size_t)sizeof(char));
output_buf = (char *) mxCalloc((size_t)buflen, (size_t)sizeof(char));
/* Copy the string data from tmp into a C string
input_buf. */
status = mxGetString(tmp, input_buf, buflen);
sizebuf = (size_t)buflen*sizeof(char);
memcpy(output_buf, input_buf, sizebuf);
fout = mxCreateString(output_buf);
}
}
else {
fout = mxCreateNumericArray(ndim, dims,
classIDflags[ifield], mxREAL);
pdata = mxGetData(fout);
sizebuf = mxGetElementSize(tmp);
if (!strcmp("elbow",fnames[ifield])) {
dbuf=param->elbow;
memcpy(pdata, &dbuf, sizebuf);
}
else if (!strcmp("lfilS",fnames[ifield])) {
dbuf=param->lfilS;
memcpy(pdata, &dbuf, sizebuf);
}
else if (!strcmp("lfil",fnames[ifield])) {
dbuf=param->lfil;
memcpy(pdata, &dbuf, sizebuf);
}
else if (!strcmp("maxit",fnames[ifield])) {
dbuf=param->maxit;
memcpy(pdata, &dbuf, sizebuf);
}
else if (!strcmp("droptolS",fnames[ifield])) {
dbuf=param->droptolS;
memcpy(pdata, &dbuf, sizebuf);
}
else if (!strcmp("droptol",fnames[ifield])) {
dbuf=param->droptol;
memcpy(pdata, &dbuf, sizebuf);
}
else if (!strcmp("condest",fnames[ifield])) {
dbuf=param->condest;
memcpy(pdata, &dbuf, sizebuf);
}
else if (!strcmp("restol",fnames[ifield])) {
dbuf=param->restol;
memcpy(pdata, &dbuf, sizebuf);
}
else if (!strcmp("npresmoothing",fnames[ifield])) {
dbuf=param->npresmoothing;
memcpy(pdata, &dbuf, sizebuf);
}
else if (!strcmp("npostmoothing",fnames[ifield])) {
dbuf=param->npostsmoothing;
memcpy(pdata, &dbuf, sizebuf);
}
else if (!strcmp("ncoarse",fnames[ifield])) {
dbuf=param->ncoarse;
memcpy(pdata, &dbuf, sizebuf);
}
else if (!strcmp("matching",fnames[ifield])) {
dbuf=param->matching;
memcpy(pdata, &dbuf, sizebuf);
}
else if (!strcmp("nrestart",fnames[ifield])) {
dbuf=param->nrestart;
memcpy(pdata, &dbuf, sizebuf);
}
else if (!strcmp("damping",fnames[ifield])) {
dbuf=param->damping;
memcpy(pdata, &dbuf, sizebuf);
}
else if (!strcmp("mixedprecision",fnames[ifield])) {
dbuf=param->mixedprecision;
memcpy(pdata, &dbuf, sizebuf);
}
else {
memcpy(pdata, mxGetData(tmp), sizebuf);
}
}
/* Set each field in output structure */
mxSetFieldByNumber(options_output, (mwIndex)0, ifield, fout);
}
/* store number of iteration steps */
if (j==-1)
ifield=nfields;
else
ifield=j;
fout=mxCreateDoubleMatrix((mwSize)1,(mwSize)1, mxREAL);
pr=mxGetPr(fout);
*pr=param->ipar[26];
/* set each field in output structure */
mxSetFieldByNumber(options_output, (mwIndex)0, ifield, fout);
mxFree(fnames);
mxFree(classIDflags);
plhs[0] = mxCreateDoubleMatrix((mwSize)A.nr, (mwSize)1, mxCOMPLEX);
x_output=plhs[0];
pr=mxGetPr(x_output);
pi=mxGetPi(x_output);
for (i=0; i<A.nr; i++) {
pr[i]=sol[i].r;
pi[i]=sol[i].i;
}
/* release right hand side */
free(rhs);
/* release solution */
free(sol);
/* release input matrix */
free(A.ia);
free(A.ja);
free(A.a);
switch (ierr) {
case 0: /* perfect! */
break;
case -1: /* too many iteration steps */
mexPrintf("!!! ILUPACK Warning !!!\n");
mexPrintf("number of iteration steps exceeded its limit.\nEither increase `options.maxit'\n or recompute ILUPACK preconditioner using a smaller `options.droptol'");
break;
case -2: /* weird, should not occur */
mexErrMsgTxt("not enough workspace provided.");
plhs[0]=NULL;
break;
case -3: /* breakdown */
mexErrMsgTxt("iterative solver breaks down.\nMost likely you need to recompute ILUPACK preconditioner using a smaller `options.droptol'");
plhs[0]=NULL;
break;
default: /* zero pivot encountered at step number ierr */
mexPrintf("iterative solver exited with error code %d",ierr);
mexErrMsgTxt(".");
plhs[0]=NULL;
break;
} /* end switch */
return;
}
/* ************************************************************
PROCEDURE mexFunction - Entry for Matlab
************************************************************ */
void mexFunction(const int nlhs, mxArray *plhs[],
const int nrhs, const mxArray *prhs[])
{
mxArray *LDEN_FIELD;
int i,inz, j,m,n,nperm, firstQ, lastQ, nnzdz;
const int *LADjc, *LADir, *dzJc, *dzIr;
int *invdz,*firstpiv,*perm, *dznewJc;
double *permPr, *firstPr;
const char *LdenFieldnames[] = {"LAD","perm","dz","first"};
/* ------------------------------------------------------------
Check for proper number of arguments
------------------------------------------------------------ */
mxAssert(nrhs >= NPARIN, "finsymbden requires more input arguments");
mxAssert(nlhs <= NPAROUT, "finsymbden produces less output arguments");
/* ------------------------------------------------------------
Get inputs LAD,perm,dz,firstq
n = total number of dense columns/blocks, i.e. #cols in LAD
m = number of constraints
nperm = n - number of removed lorentz trace columns.
------------------------------------------------------------ */
mxAssert(mxIsSparse(LAD_IN), "LAD must be sparse"); /* LAD */
m = mxGetM(LAD_IN);
n = mxGetN(LAD_IN);
LADjc = mxGetJc(LAD_IN);
LADir = mxGetIr(LAD_IN);
permPr = mxGetPr(PERM_IN); /* perm */
nperm = mxGetM(PERM_IN) * mxGetN(PERM_IN);
dzJc = mxGetJc(DZ_IN); /* dz */
dzIr = mxGetIr(DZ_IN);
mxAssert(mxGetM(DZ_IN) == m && mxGetN(DZ_IN) == nperm, "dz size mismatch");
/* ------------------------------------------------------------
INPUT firstQ == dense.l+1, points to 1st entry in dense.cols
dealing with Lorentz-trace entries. Let lastQ point just beyond
Lorentz trace/block entries, i.e. add n-nperm.
------------------------------------------------------------ */
firstQ = mxGetScalar(FIRSTQ_IN); /*firstq, F-double to C-int.*/
--firstQ;
lastQ = firstQ + n - nperm;
/* ------------------------------------------------------------
Allocate integer working arrays:
invdz(m), firstpiv(n), perm(n)
------------------------------------------------------------ */
invdz = (int *) mxCalloc(MAX(1,m), sizeof(int));
firstpiv = (int *) mxCalloc(MAX(1,n), sizeof(int));
perm = (int *) mxCalloc(MAX(1,n), sizeof(int));
/* ------------------------------------------------------------
Allocate OUTPUT int array dznewJc(n+1)
------------------------------------------------------------ */
dznewJc = (int *) mxCalloc(n+1, sizeof(int));
/* ------------------------------------------------------------
Let invdz(dzIr) = 1:nnz(dz). Note that nnz(dz)<m is the number
subscripts that are actually in use.
------------------------------------------------------------ */
nnzdz = dzJc[nperm];
for(i = dzJc[0]; i < nnzdz; i++)
invdz[dzIr[i]] = i; /* dz is m x nperm */
/* ------------------------------------------------------------
Create new perm and dz-column pointers, to include lorentz trace cols.
These cols are attached to Lorentz-blocks cols, whose subscripts
range in firstQ:lastQ-1.
------------------------------------------------------------ */
inz = 0;
for(i = 0; i < nperm; i++){
j = permPr[i];
perm[inz] = --j;
dznewJc[inz++] = dzJc[i];
if(j >= firstQ && j < lastQ){
/* ------------------------------------------------------------
Attach Lorentz trace col. These cols are at nperm:n-1.
------------------------------------------------------------ */
perm[inz] = nperm + j - firstQ; /* insert associated trace column */
mxAssert(perm[inz] < n,"");
dznewJc[inz++] = dzJc[i+1]; /* no extra subscripts->start at end */
}
}
mxAssert(inz == n,"");
dznewJc[n] = dzJc[nperm];
/* ------------------------------------------------------------
Compute firstpiv
------------------------------------------------------------ */
getfirstpiv(firstpiv, invdz, dznewJc, LADjc,LADir, n);
/* ------------------------------------------------------------
Outputs Lden.(LAD, perm, dz, first)
------------------------------------------------------------ */
LDEN_OUT = mxCreateStructMatrix(1, 1, NLDEN_FIELDS, LdenFieldnames);
LDEN_FIELD = mxDuplicateArray(LAD_IN); /* LAD */
mxSetField(LDEN_OUT,0,"LAD",LDEN_FIELD);
LDEN_FIELD = mxCreateDoubleMatrix(n, 1, mxREAL); /* perm */
mxSetField(LDEN_OUT,0,"perm",LDEN_FIELD);
permPr = mxGetPr(LDEN_FIELD);
for(i = 0; i < n; i++)
permPr[i] = perm[i] + 1.0; /* C-int to F-double */
LDEN_FIELD = mxDuplicateArray(DZ_IN); /* dz */
/* NOTE: here we replace jc by dznewJc */
mxFree(mxGetJc(LDEN_FIELD));
mxSetJc(LDEN_FIELD, dznewJc);
mxSetN(LDEN_FIELD, n);
mxSetField(LDEN_OUT,0,"dz",LDEN_FIELD);
LDEN_FIELD = mxCreateDoubleMatrix(n, 1, mxREAL); /* first */
mxSetField(LDEN_OUT,0,"first",LDEN_FIELD);
firstPr = mxGetPr(LDEN_FIELD);
for(i = 0; i < n; i++)
firstPr[i] = firstpiv[i] + 1.0; /* C-int to F-double */
/* ------------------------------------------------------------
Release working arrays
------------------------------------------------------------ */
mxFree(perm);
mxFree(firstpiv);
mxFree(invdz);
}
inline void callFunction(mxArray* plhs[], const mxArray*prhs[]) {
if (!mexCheckType<T>(prhs[0]))
mexErrMsgTxt("type of argument 1 is not consistent");
if (mxIsSparse(prhs[0]))
mexErrMsgTxt("argument 1 should be full");
if (!mexCheckType<T>(prhs[1]))
mexErrMsgTxt("type of argument 2 is not consistent");
if (mxIsSparse(prhs[1])) mexErrMsgTxt("argument 2 should be full");
if (mxIsSparse(prhs[2])) mexErrMsgTxt("argument 3 should be full");
if (!mexCheckType<int>(prhs[2]))
mexErrMsgTxt("type of argument 3 is not consistent");
if (!mxIsStruct(prhs[3]))
mexErrMsgTxt("argument 4 should be struct");
T* prX=reinterpret_cast<T*>(mxGetPr(prhs[0]));
const mwSize* dims=mxGetDimensions(prhs[0]);
INTM n=static_cast<INTM>(dims[0]);
INTM M=static_cast<INTM>(dims[1]);
T * prD = reinterpret_cast<T*>(mxGetPr(prhs[1]));
const mwSize* dimsD=mxGetDimensions(prhs[1]);
INTM nD=static_cast<INTM>(dimsD[0]);
if (nD != n) mexErrMsgTxt("wrong size for argument 2");
INTM K=static_cast<INTM>(dimsD[1]);
const mwSize* dimsList = mxGetDimensions(prhs[2]);
int Ng = static_cast<int>(dimsList[0]*dimsList[1]);
int* list_groups=reinterpret_cast<int*>(mxGetPr(prhs[2]));
int L= getScalarStruct<int>(prhs[3],"L");
T eps= getScalarStructDef<T>(prhs[3],"eps",0);
int numThreads = getScalarStructDef<int>(prhs[3],"numThreads",-1);
Matrix<T> D(prD,n,K);
Matrix<T>* X = new Matrix<T>[Ng];
if (list_groups[0] != 0)
mexErrMsgTxt("First group index should be zero");
for (int i = 0; i<Ng-1; ++i) {
if (list_groups[i] >= M)
mexErrMsgTxt("Size of groups is not consistent");
if (list_groups[i] >= list_groups[i+1])
mexErrMsgTxt("Group indices should be a strictly non-decreasing sequence");
X[i].setData(prX+list_groups[i]*n,n,list_groups[i+1]-list_groups[i]);
}
X[Ng-1].setData(prX+list_groups[Ng-1]*n,n,M-list_groups[Ng-1]);
SpMatrix<T>* spAlpha = new SpMatrix<T>[Ng];
somp(X,D,spAlpha,Ng,L,eps,numThreads);
INTM nzmax=0;
for (INTM i = 0; i<Ng; ++i) {
nzmax += spAlpha[i].nzmax();
}
plhs[0]=mxCreateSparse(K,M,nzmax,mxREAL);
double* Pr = mxGetPr(plhs[0]);
mwSize* Ir = mxGetIr(plhs[0]);
mwSize* Jc = mxGetJc(plhs[0]);
INTM count=0;
INTM countcol=0;
INTM offset=0;
for (INTM i = 0; i<Ng; ++i) {
const T* v = spAlpha[i].v();
const INTM* r = spAlpha[i].r();
const INTM* pB = spAlpha[i].pB();
INTM nn = spAlpha[i].n();
nzmax = spAlpha[i].nzmax();
if (nn != 0) {
for (INTM j = 0; j<pB[nn]; ++j) {
Pr[count]=static_cast<double>(v[j]);
Ir[count++]=static_cast<mwSize>(r[j]);
}
for (INTM j = 0; j<=nn; ++j)
Jc[countcol++]=static_cast<mwSize>(offset+pB[j]);
--countcol;
offset = Jc[countcol];
}
}
delete[](X);
delete[](spAlpha);
}
/*
* The mex function runs a max-flow min-cut problem.
*/
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
int i;
int mrows, ncols;
int n,nz;
/* sparse matrix */
mwIndex *ia, *ja;
/* output data */
double *a, *ci;
mwIndex *int_a;
if (nrhs != 1)
{
mexErrMsgTxt("1 inputs required.");
}
/* The first input must be a sparse matrix. */
mrows = mxGetM(prhs[0]);
ncols = mxGetN(prhs[0]);
if (mrows != ncols ||
!mxIsSparse(prhs[0]) ||
!mxIsDouble(prhs[0]) ||
mxIsComplex(prhs[0]))
{
mexErrMsgTxt("Input must be a noncomplex square sparse matrix.");
}
n = mrows;
/* Get the sparse matrix */
/* recall that we've transposed the matrix */
ja = mxGetIr(prhs[0]);
ia = mxGetJc(prhs[0]);
nz = ia[n];
plhs[0] = mxCreateDoubleMatrix(n,1,mxREAL);
a = mxGetPr(plhs[0]);
ci = NULL;
if (nlhs > 1)
{
plhs[1] = mxCreateDoubleMatrix(nz,1,mxREAL);
ci = mxGetPr(plhs[1]);
}
int_a = (mwIndex*)a;
for (i=0; i<n; i++)
{
int_a[i] = MWINDEX_MAX;
}
biconnected_components(n, ja, ia,
(mwIndex*)a, (mwIndex*)ci);
expand_index_to_double_zero_special((mwIndex*)a, a, n, 1.0, MWINDEX_MAX);
if (nlhs > 1)
{
expand_index_to_double((mwIndex*)ci, ci, nz, 1.0);
}
}
inline void callFunction(mxArray* plhs[], const mxArray*prhs[],
const long nlhs,const long nrhs) {
if (!mexCheckType<T>(prhs[0]))
mexErrMsgTxt("type of argument 1 is not consistent");
if (!mxIsStruct(prhs[1]))
mexErrMsgTxt("argument 2 should be struct");
if (nrhs == 3)
if (!mxIsStruct(prhs[2]))
mexErrMsgTxt("argument 3 should be struct");
Data<T> *X;
const mwSize* dimsX=mxGetDimensions(prhs[0]);
long n=static_cast<long>(dimsX[0]);
long M=static_cast<long>(dimsX[1]);
if (mxIsSparse(prhs[0])) {
double * X_v=static_cast<double*>(mxGetPr(prhs[0]));
mwSize* X_r=mxGetIr(prhs[0]);
mwSize* X_pB=mxGetJc(prhs[0]);
mwSize* X_pE=X_pB+1;
long* X_r2, *X_pB2, *X_pE2;
T* X_v2;
createCopySparse<T>(X_v2,X_r2,X_pB2,X_pE2,
X_v,X_r,X_pB,X_pE,M);
X = new SpMatrix<T>(X_v2,X_r2,X_pB2,X_pE2,n,M,X_pB2[M]);
} else {
T* prX = reinterpret_cast<T*>(mxGetPr(prhs[0]));
X= new Matrix<T>(prX,n,M);
}
long NUM_THREADS = getScalarStructDef<long>(prhs[1],"numThreads",-1);
#ifdef _OPENMP
NUM_THREADS = NUM_THREADS == -1 ? omp_get_num_procs() : NUM_THREADS;
#else
NUM_THREADS=1;
#endif
long batch_size = getScalarStructDef<long>(prhs[1],"batchsize",
256*(NUM_THREADS+1));
mxArray* pr_D = mxGetField(prhs[1],0,"D");
Trainer<T>* trainer;
if (!pr_D) {
long K = getScalarStruct<long>(prhs[1],"K");
trainer = new Trainer<T>(K,batch_size,NUM_THREADS);
} else {
T* prD = reinterpret_cast<T*>(mxGetPr(pr_D));
const mwSize* dimsD=mxGetDimensions(pr_D);
long nD=static_cast<long>(dimsD[0]);
long K=static_cast<long>(dimsD[1]);
if (n != nD) mexErrMsgTxt("sizes of D are not consistent");
Matrix<T> D1(prD,n,K);
if (nrhs == 3) {
mxArray* pr_A = mxGetField(prhs[2],0,"A");
if (!pr_A) mexErrMsgTxt("field A is not provided");
T* prA = reinterpret_cast<T*>(mxGetPr(pr_A));
const mwSize* dimsA=mxGetDimensions(pr_A);
long xA=static_cast<long>(dimsA[0]);
long yA=static_cast<long>(dimsA[1]);
if (xA != K || yA != K) mexErrMsgTxt("Size of A is not consistent");
Matrix<T> A(prA,K,K);
mxArray* pr_B = mxGetField(prhs[2],0,"B");
if (!pr_B) mexErrMsgTxt("field B is not provided");
T* prB = reinterpret_cast<T*>(mxGetPr(pr_B));
const mwSize* dimsB=mxGetDimensions(pr_B);
long xB=static_cast<long>(dimsB[0]);
long yB=static_cast<long>(dimsB[1]);
if (xB != n || yB != K) mexErrMsgTxt("Size of B is not consistent");
Matrix<T> B(prB,n,K);
long iter = getScalarStruct<long>(prhs[2],"iter");
trainer = new Trainer<T>(A,B,D1,iter,batch_size,NUM_THREADS);
} else {
trainer = new Trainer<T>(D1,batch_size,NUM_THREADS);
}
}
ParamDictLearn<T> param;
param.lambda = getScalarStruct<T>(prhs[1],"lambda");
param.lambda2 = getScalarStructDef<T>(prhs[1],"lambda2",10e-10);
param.iter=getScalarStruct<long>(prhs[1],"iter");
param.t0 = getScalarStructDef<T>(prhs[1],"t0",1e-5);
param.mode =(constraint_type)getScalarStructDef<long>(prhs[1],"mode",PENALTY);
param.posAlpha = getScalarStructDef<bool>(prhs[1],"posAlpha",false);
param.posD = getScalarStructDef<bool>(prhs[1],"posD",false);
param.expand= getScalarStructDef<bool>(prhs[1],"expand",false);
param.modeD=(constraint_type_D)getScalarStructDef<long>(prhs[1],"modeD",L2);
param.whiten = getScalarStructDef<bool>(prhs[1],"whiten",false);
param.clean = getScalarStructDef<bool>(prhs[1],"clean",true);
param.verbose = getScalarStructDef<bool>(prhs[1],"verbose",true);
param.gamma1 = getScalarStructDef<T>(prhs[1],"gamma1",0);
param.gamma2 = getScalarStructDef<T>(prhs[1],"gamma2",0);
param.rho = getScalarStructDef<T>(prhs[1],"rho",T(1.0));
param.stochastic =
getScalarStructDef<bool>(prhs[1],"stochastic_deprecated",
false);
param.modeParam = static_cast<mode_compute>(getScalarStructDef<long>(prhs[1],"modeParam",0));
param.batch = getScalarStructDef<bool>(prhs[1],"batch",false);
param.iter_updateD = getScalarStructDef<T>(prhs[1],"iter_updateD",param.batch ? 5 : 1);
param.log = getScalarStructDef<bool>(prhs[1],"log_deprecated",
false);
if (param.log) {
mxArray *stringData = mxGetField(prhs[1],0,
"logName_deprecated");
if (!stringData)
mexErrMsgTxt("Missing field logName_deprecated");
long stringLength = mxGetN(stringData)+1;
param.logName= new char[stringLength];
mxGetString(stringData,param.logName,stringLength);
}
trainer->train(*X,param);
if (param.log)
mxFree(param.logName);
Matrix<T> D;
trainer->getD(D);
long K = D.n();
plhs[0] = createMatrix<T>(n,K);
T* prD2 = reinterpret_cast<T*>(mxGetPr(plhs[0]));
Matrix<T> D2(prD2,n,K);
D2.copy(D);
if (nlhs == 2) {
mwSize dims[1] = {1};
long nfields=3;
const char *names[] = {"A", "B", "iter"};
plhs[1]=mxCreateStructArray(1, dims,nfields, names);
mxArray* prA = createMatrix<T>(K,K);
T* pr_A= reinterpret_cast<T*>(mxGetPr(prA));
Matrix<T> A(pr_A,K,K);
trainer->getA(A);
mxSetField(plhs[1],0,"A",prA);
mxArray* prB = createMatrix<T>(n,K);
T* pr_B= reinterpret_cast<T*>(mxGetPr(prB));
Matrix<T> B(pr_B,n,K);
trainer->getB(B);
mxSetField(plhs[1],0,"B",prB);
mxArray* priter = createScalar<T>();
*mxGetPr(priter) = static_cast<T>(trainer->getIter());
mxSetField(plhs[1],0,"iter",priter);
}
delete(trainer);
delete(X);
}
void mexFunction(
int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[]
)
{
int display=0, i=0;
long *lpenv=NULL ;
CPXENVptr env = NULL;
int status ;
double value ;
char param_name[128] ;
int param_code=-1, dblfound=0, strfound=0 ;
if (nrhs > 7 || nrhs < 1) {
mexErrMsgTxt("Usage: [how] "
"= lp_set_param(lpenv, param_name, value, display)");
return;
}
switch (nrhs) {
case 4:
if (mxGetM(prhs[3]) != 0 || mxGetN(prhs[3]) != 0) {
if (!mxIsNumeric(prhs[3]) || mxIsComplex(prhs[3])
|| mxIsSparse(prhs[3])
|| !(mxGetM(prhs[3])==1 && mxGetN(prhs[3])==1)) {
mexErrMsgTxt("4th argument (display) must be "
"an integer scalar.");
return;
}
display = *mxGetPr(prhs[3]);
}
case 3:
if (mxGetM(prhs[2]) != 0 || mxGetN(prhs[2]) != 0) {
if (!mxIsNumeric(prhs[2]) || mxIsComplex(prhs[2])
|| mxIsSparse(prhs[2])
|| !(mxGetM(prhs[2])==1 && mxGetN(prhs[2])==1)) {
mexErrMsgTxt("3rd argument (value) must be "
"an integer scalar.");
return;
}
value = *mxGetPr(prhs[2]);
}
case 2:
if (mxGetM(prhs[1]) != 0 || mxGetN(prhs[1]) != 0) {
if (mxIsNumeric(prhs[1]) || mxIsComplex(prhs[1])
|| mxIsSparse(prhs[1]) || !mxIsChar(prhs[1])
|| !(mxGetM(prhs[1])==1) && mxGetN(prhs[1])>=1) {
mexErrMsgTxt("2nd argument (param) must be "
"a string.");
return;
}
mxGetString(prhs[1], param_name, 128);
}
case 1:
if (mxGetM(prhs[0]) != 0 || mxGetN(prhs[0]) != 0) {
if (!mxIsNumeric(prhs[0]) || mxIsComplex(prhs[0])
|| mxIsSparse(prhs[0])
|| !mxIsDouble(prhs[0])
|| mxGetN(prhs[0])!=1 ) {
mexErrMsgTxt("1st argument (lpenv) must be "
"a column vector.");
return;
}
if (1 != mxGetM(prhs[0])) {
mexErrMsgTxt("Dimension error (arg 1).");
return;
}
lpenv = (long*) mxGetPr(prhs[0]);
}
}
if (nlhs > 1 || nlhs < 1) {
mexErrMsgTxt("Usage: [how] "
"= lp_set_param(lpenv,param_name,value,disp)");
return;
}
if (display>2) fprintf(STD_OUT, "argument processing finished\n") ;
/* Initialize the CPLEX environment */
env = (CPXENVptr) lpenv[0] ;
for (i=0; i<NUM_PARAMS; i++)
if (strcmp(param_info[i].name, param_name)==0)
param_code=param_info[i].code ;
if (display>3)
fprintf(STD_OUT, "(param=%s(%i), value=%f) \n", param_name, param_code, value) ;
if (param_code==-1)
mxErrMsgTxt("illegal parameter name") ;
for (i=0; i<NUM_DBLPARAMS; i++)
if (param_code==dblParams[i])
dblfound=1 ;
for (i=0; i<NUM_STRPARAMS; i++)
if (param_code==strParams[i])
strfound=1 ;
if (dblfound==1) {
if (display>2)
fprintf(STD_OUT, "calling CPXsetdblparam\n") ;
status = CPXsetdblparam(env, param_code, value);
if ( status ) {
fprintf (STD_OUT, "CPXsetdblparam failed.\n");
goto TERMINATE;
}
} else if (strfound==1)
{
fprintf(STD_OUT, "sorry not implemented\n") ;
} else {
if (display>2)
fprintf(STD_OUT, "calling CPXsetintparam\n") ;
status = CPXsetintparam(env, param_code, (int)value);
if ( status ) {
fprintf (STD_OUT, "CPXsetintparam failed.\n");
goto TERMINATE;
}
} ;
TERMINATE:
if (status) {
char errmsg[1024];
CPXgeterrorstring (env, status, errmsg);
fprintf (STD_OUT, "%s", errmsg);
if (nlhs >= 1)
plhs[0] = mxCreateString(errmsg) ;
} else
if (nlhs >= 1)
plhs[0] = mxCreateString("OK") ;
;
return ;
}
void predict(mxArray *plhs[], const mxArray *prhs[], struct svm_model *model, const int predict_probability)
{
int label_vector_row_num, label_vector_col_num;
int feature_number, testing_instance_number;
int instance_index;
double *ptr_instance, *ptr_label, *ptr_predict_label;
double *ptr_prob_estimates, *ptr_dec_values, *ptr;
struct svm_node *x;
mxArray *pplhs[1]; // transposed instance sparse matrix
int correct = 0;
int total = 0;
double error = 0;
double sump = 0, sumt = 0, sumpp = 0, sumtt = 0, sumpt = 0;
int svm_type=svm_get_svm_type(model);
int nr_class=svm_get_nr_class(model);
double *prob_estimates=NULL;
// prhs[1] = testing instance matrix
feature_number = (int)mxGetN(prhs[1]);
testing_instance_number = (int)mxGetM(prhs[1]);
label_vector_row_num = (int)mxGetM(prhs[0]);
label_vector_col_num = (int)mxGetN(prhs[0]);
if(label_vector_row_num!=testing_instance_number)
{
mexPrintf("Length of label vector does not match # of instances.\n");
fake_answer(plhs);
return;
}
if(label_vector_col_num!=1)
{
mexPrintf("label (1st argument) should be a vector (# of column is 1).\n");
fake_answer(plhs);
return;
}
ptr_instance = mxGetPr(prhs[1]);
ptr_label = mxGetPr(prhs[0]);
// transpose instance matrix
if(mxIsSparse(prhs[1]))
{
if(model->param.kernel_type == PRECOMPUTED)
{
// precomputed kernel requires dense matrix, so we make one
mxArray *rhs[1], *lhs[1];
rhs[0] = mxDuplicateArray(prhs[1]);
if(mexCallMATLAB(1, lhs, 1, rhs, "full"))
{
mexPrintf("Error: cannot full testing instance matrix\n");
fake_answer(plhs);
return;
}
ptr_instance = mxGetPr(lhs[0]);
mxDestroyArray(rhs[0]);
}
else
{
mxArray *pprhs[1];
pprhs[0] = mxDuplicateArray(prhs[1]);
if(mexCallMATLAB(1, pplhs, 1, pprhs, "transpose"))
{
mexPrintf("Error: cannot transpose testing instance matrix\n");
fake_answer(plhs);
return;
}
}
}
if(predict_probability)
{
if(svm_type==NU_SVR || svm_type==EPSILON_SVR)
mexPrintf("Prob. model for test data: target value = predicted value + z,\nz: Laplace distribution e^(-|z|/sigma)/(2sigma),sigma=%g\n",svm_get_svr_probability(model));
else
prob_estimates = (double *) malloc(nr_class*sizeof(double));
}
plhs[0] = mxCreateDoubleMatrix(testing_instance_number, 1, mxREAL);
if(predict_probability)
{
// prob estimates are in plhs[2]
if(svm_type==C_SVC || svm_type==NU_SVC)
plhs[2] = mxCreateDoubleMatrix(testing_instance_number, nr_class, mxREAL);
else
plhs[2] = mxCreateDoubleMatrix(0, 0, mxREAL);
}
else
{
// decision values are in plhs[2]
if(svm_type == ONE_CLASS ||
svm_type == EPSILON_SVR ||
svm_type == NU_SVR ||
nr_class == 1) // if only one class in training data, decision values are still returned.
plhs[2] = mxCreateDoubleMatrix(testing_instance_number, 1, mxREAL);
else
plhs[2] = mxCreateDoubleMatrix(testing_instance_number, nr_class*(nr_class-1)/2, mxREAL);
}
ptr_predict_label = mxGetPr(plhs[0]);
ptr_prob_estimates = mxGetPr(plhs[2]);
ptr_dec_values = mxGetPr(plhs[2]);
x = (struct svm_node*)malloc((feature_number+1)*sizeof(struct svm_node) );
for(instance_index=0;instance_index<testing_instance_number;instance_index++)
{
int i;
double target_label, predict_label;
target_label = ptr_label[instance_index];
if(mxIsSparse(prhs[1]) && model->param.kernel_type != PRECOMPUTED) // prhs[1]^T is still sparse
read_sparse_instance(pplhs[0], instance_index, x);
else
{
for(i=0;i<feature_number;i++)
{
x[i].index = i+1;
x[i].value = ptr_instance[testing_instance_number*i+instance_index];
}
x[feature_number].index = -1;
}
if(predict_probability)
{
if(svm_type==C_SVC || svm_type==NU_SVC)
{
predict_label = svm_predict_probability(model, x, prob_estimates);
ptr_predict_label[instance_index] = predict_label;
for(i=0;i<nr_class;i++)
ptr_prob_estimates[instance_index + i * testing_instance_number] = prob_estimates[i];
} else {
predict_label = svm_predict(model,x);
ptr_predict_label[instance_index] = predict_label;
}
}
else
{
if(svm_type == ONE_CLASS ||
svm_type == EPSILON_SVR ||
svm_type == NU_SVR)
{
double res;
predict_label = svm_predict_values(model, x, &res);
ptr_dec_values[instance_index] = res;
}
else
{
double *dec_values = (double *) malloc(sizeof(double) * nr_class*(nr_class-1)/2);
predict_label = svm_predict_values(model, x, dec_values);
if(nr_class == 1)
ptr_dec_values[instance_index] = 1;
else
for(i=0;i<(nr_class*(nr_class-1))/2;i++)
ptr_dec_values[instance_index + i * testing_instance_number] = dec_values[i];
free(dec_values);
}
ptr_predict_label[instance_index] = predict_label;
}
if(predict_label == target_label)
++correct;
error += (predict_label-target_label)*(predict_label-target_label);
sump += predict_label;
sumt += target_label;
sumpp += predict_label*predict_label;
sumtt += target_label*target_label;
sumpt += predict_label*target_label;
++total;
}
/*
if(svm_type==NU_SVR || svm_type==EPSILON_SVR)
{
mexPrintf("Mean squared error = %g (regression)\n",error/total);
mexPrintf("Squared correlation coefficient = %g (regression)\n",
((total*sumpt-sump*sumt)*(total*sumpt-sump*sumt))/
((total*sumpp-sump*sump)*(total*sumtt-sumt*sumt))
);
}
else
mexPrintf("Accuracy = %g%% (%d/%d) (classification)\n",
(double)correct/total*100,correct,total);
*/
// return accuracy, mean squared error, squared correlation coefficient
plhs[1] = mxCreateDoubleMatrix(3, 1, mxREAL);
ptr = mxGetPr(plhs[1]);
ptr[0] = (double)correct/total*100;
ptr[1] = error/total;
ptr[2] = ((total*sumpt-sump*sumt)*(total*sumpt-sump*sumt))/
((total*sumpp-sump*sump)*(total*sumtt-sumt*sumt));
free(x);
if(prob_estimates != NULL)
free(prob_estimates);
}
void mexFunction
(
int nargout,
mxArray *pargout [ ],
int nargin,
const mxArray *pargin [ ]
)
{
Long i, m, n, *Ap, *Ai, *P, nc, result, spumoni, full, *C, Clen ;
double *Pout, *InfoOut, Control [CAMD_CONTROL], Info [CAMD_INFO],
*ControlIn, *Cin ;
mxArray *A ;
/* --------------------------------------------------------------------- */
/* get control parameters */
/* --------------------------------------------------------------------- */
camd_malloc = mxMalloc ;
camd_free = mxFree ;
camd_calloc = mxCalloc ;
camd_realloc = mxRealloc ;
camd_printf = mexPrintf ;
spumoni = 0 ;
if (nargin == 0)
{
/* get the default control parameters, and return */
pargout [0] = mxCreateDoubleMatrix (CAMD_CONTROL, 1, mxREAL) ;
camd_l_defaults (mxGetPr (pargout [0])) ;
if (nargout == 0)
{
camd_l_control (mxGetPr (pargout [0])) ;
}
return ;
}
camd_l_defaults (Control) ;
if (nargin > 1)
{
ControlIn = mxGetPr (pargin [1]) ;
nc = mxGetM (pargin [1]) * mxGetN (pargin [1]) ;
Control [CAMD_DENSE]
= (nc > 0) ? ControlIn [CAMD_DENSE] : CAMD_DEFAULT_DENSE ;
Control [CAMD_AGGRESSIVE]
= (nc > 1) ? ControlIn [CAMD_AGGRESSIVE] : CAMD_DEFAULT_AGGRESSIVE ;
spumoni = (nc > 2) ? (ControlIn [2] != 0) : 0 ;
}
if (spumoni > 0)
{
camd_l_control (Control) ;
}
/* --------------------------------------------------------------------- */
/* get inputs */
/* --------------------------------------------------------------------- */
if (nargout > 2 || nargin > 3)
{
mexErrMsgTxt ("Usage: p = camd (A)\n"
"or [p, Info] = camd (A, Control, C)") ;
}
Clen = 0 ;
C = NULL ;
if (nargin > 2)
{
Cin = mxGetPr (pargin [2]) ;
Clen = mxGetNumberOfElements (pargin [2]) ;
if (Clen != 0)
{
C = (Long *) mxCalloc (Clen, sizeof (Long)) ;
for (i = 0 ; i < Clen ; i++)
{
/* convert c from 1-based to 0-based */
C [i] = (Long) Cin [i] - 1 ;
}
}
}
A = (mxArray *) pargin [0] ;
n = mxGetN (A) ;
m = mxGetM (A) ;
if (spumoni > 0)
{
mexPrintf (" input matrix A is %d-by-%d\n", m, n) ;
}
if (mxGetNumberOfDimensions (A) != 2)
{
mexErrMsgTxt ("camd: A must be 2-dimensional") ;
}
if (m != n)
{
mexErrMsgTxt ("camd: A must be square") ;
}
/* --------------------------------------------------------------------- */
/* allocate workspace for output permutation */
/* --------------------------------------------------------------------- */
P = mxMalloc ((n+1) * sizeof (Long)) ;
/* --------------------------------------------------------------------- */
/* if A is full, convert to a sparse matrix */
/* --------------------------------------------------------------------- */
full = !mxIsSparse (A) ;
if (full)
{
if (spumoni > 0)
{
mexPrintf (
" input matrix A is full (sparse copy of A will be created)\n");
}
mexCallMATLAB (1, &A, 1, (mxArray **) pargin, "sparse") ;
}
Ap = (Long *) mxGetJc (A) ;
Ai = (Long *) mxGetIr (A) ;
if (spumoni > 0)
{
mexPrintf (" input matrix A has %d nonzero entries\n", Ap [n]) ;
}
/* --------------------------------------------------------------------- */
/* order the matrix */
/* --------------------------------------------------------------------- */
result = camd_l_order (n, Ap, Ai, P, Control, Info, C) ;
/* --------------------------------------------------------------------- */
/* if A is full, free the sparse copy of A */
/* --------------------------------------------------------------------- */
if (full)
{
mxDestroyArray (A) ;
}
/* --------------------------------------------------------------------- */
/* print results (including return value) */
/* --------------------------------------------------------------------- */
if (spumoni > 0)
{
camd_l_info (Info) ;
}
/* --------------------------------------------------------------------- */
/* check error conditions */
/* --------------------------------------------------------------------- */
if (result == CAMD_OUT_OF_MEMORY)
{
mexErrMsgTxt ("camd: out of memory") ;
}
else if (result == CAMD_INVALID)
{
mexErrMsgTxt ("camd: input matrix A is corrupted") ;
}
/* --------------------------------------------------------------------- */
/* copy the outputs to MATLAB */
/* --------------------------------------------------------------------- */
/* output permutation, P */
pargout [0] = mxCreateDoubleMatrix (1, n, mxREAL) ;
Pout = mxGetPr (pargout [0]) ;
for (i = 0 ; i < n ; i++)
{
Pout [i] = P [i] + 1 ; /* change to 1-based indexing for MATLAB */
}
mxFree (P) ;
if (nargin > 2) mxFree (C) ;
/* Info */
if (nargout > 1)
{
pargout [1] = mxCreateDoubleMatrix (CAMD_INFO, 1, mxREAL) ;
InfoOut = mxGetPr (pargout [1]) ;
for (i = 0 ; i < CAMD_INFO ; i++)
{
InfoOut [i] = Info [i] ;
}
}
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
int i, j;
mxArray *xm, *cell, *xm_cell;
double *src;
double *dest;
double *dest_cell;
int valid_vars;
int steps;
int this_var_errors;
int warned_diags;
int prepare_for_c = 0;
int extra_solves;
const char *status_names[] = {"optval", "gap", "steps", "converged"};
mwSize dims1x1of1[1] = {1};
mwSize dims[1];
const char *var_names[] = {"u_0", "u_1", "u_2", "u_3", "u_4", "u_5", "u_6", "u_7", "u_8", "u_9", "x_1", "x_2", "x_3", "x_4", "x_5", "x_6", "x_7", "x_8", "x_9", "x_10", "u", "x"};
const int num_var_names = 22;
/* Avoid compiler warnings of unused variables by using a dummy assignment. */
warned_diags = j = 0;
extra_solves = 0;
set_defaults();
/* Check we got the right number of arguments. */
if (nrhs == 0)
mexErrMsgTxt("Not enough arguments: You need to specify at least the parameters.\n");
if (nrhs > 1) {
/* Assume that the second argument is the settings. */
if (mxGetField(prhs[1], 0, "eps") != NULL)
settings.eps = *mxGetPr(mxGetField(prhs[1], 0, "eps"));
if (mxGetField(prhs[1], 0, "max_iters") != NULL)
settings.max_iters = *mxGetPr(mxGetField(prhs[1], 0, "max_iters"));
if (mxGetField(prhs[1], 0, "refine_steps") != NULL)
settings.refine_steps = *mxGetPr(mxGetField(prhs[1], 0, "refine_steps"));
if (mxGetField(prhs[1], 0, "verbose") != NULL)
settings.verbose = *mxGetPr(mxGetField(prhs[1], 0, "verbose"));
if (mxGetField(prhs[1], 0, "better_start") != NULL)
settings.better_start = *mxGetPr(mxGetField(prhs[1], 0, "better_start"));
if (mxGetField(prhs[1], 0, "verbose_refinement") != NULL)
settings.verbose_refinement = *mxGetPr(mxGetField(prhs[1], 0,
"verbose_refinement"));
if (mxGetField(prhs[1], 0, "debug") != NULL)
settings.debug = *mxGetPr(mxGetField(prhs[1], 0, "debug"));
if (mxGetField(prhs[1], 0, "kkt_reg") != NULL)
settings.kkt_reg = *mxGetPr(mxGetField(prhs[1], 0, "kkt_reg"));
if (mxGetField(prhs[1], 0, "s_init") != NULL)
settings.s_init = *mxGetPr(mxGetField(prhs[1], 0, "s_init"));
if (mxGetField(prhs[1], 0, "z_init") != NULL)
settings.z_init = *mxGetPr(mxGetField(prhs[1], 0, "z_init"));
if (mxGetField(prhs[1], 0, "resid_tol") != NULL)
settings.resid_tol = *mxGetPr(mxGetField(prhs[1], 0, "resid_tol"));
if (mxGetField(prhs[1], 0, "extra_solves") != NULL)
extra_solves = *mxGetPr(mxGetField(prhs[1], 0, "extra_solves"));
else
extra_solves = 0;
if (mxGetField(prhs[1], 0, "prepare_for_c") != NULL)
prepare_for_c = *mxGetPr(mxGetField(prhs[1], 0, "prepare_for_c"));
}
valid_vars = 0;
this_var_errors = 0;
xm = mxGetField(prhs[0], 0, "A");
if (xm == NULL) {
printf("could not find params.A.\n");
} else {
if (!((mxGetM(xm) == 3) && (mxGetN(xm) == 3))) {
printf("A must be size (3,3), not (%d,%d).\n", mxGetM(xm), mxGetN(xm));
this_var_errors++;
}
if (mxIsComplex(xm)) {
printf("parameter A must be real.\n");
this_var_errors++;
}
if (!mxIsClass(xm, "double")) {
printf("parameter A must be a full matrix of doubles.\n");
this_var_errors++;
}
if (mxIsSparse(xm)) {
printf("parameter A must be a full matrix.\n");
this_var_errors++;
}
if (this_var_errors == 0) {
dest = params.A;
src = mxGetPr(xm);
for (i = 0; i < 9; i++)
*dest++ = *src++;
valid_vars++;
}
}
this_var_errors = 0;
xm = mxGetField(prhs[0], 0, "B");
if (xm == NULL) {
printf("could not find params.B.\n");
} else {
if (!((mxGetM(xm) == 3) && (mxGetN(xm) == 1))) {
printf("B must be size (3,1), not (%d,%d).\n", mxGetM(xm), mxGetN(xm));
this_var_errors++;
}
if (mxIsComplex(xm)) {
printf("parameter B must be real.\n");
this_var_errors++;
}
if (!mxIsClass(xm, "double")) {
printf("parameter B must be a full matrix of doubles.\n");
this_var_errors++;
}
if (mxIsSparse(xm)) {
printf("parameter B must be a full matrix.\n");
this_var_errors++;
}
if (this_var_errors == 0) {
dest = params.B;
src = mxGetPr(xm);
for (i = 0; i < 3; i++)
*dest++ = *src++;
valid_vars++;
}
}
this_var_errors = 0;
xm = mxGetField(prhs[0], 0, "Ff");
if (xm == NULL) {
printf("could not find params.Ff.\n");
} else {
if (!((mxGetM(xm) == 2) && (mxGetN(xm) == 3))) {
printf("Ff must be size (2,3), not (%d,%d).\n", mxGetM(xm), mxGetN(xm));
this_var_errors++;
}
if (mxIsComplex(xm)) {
printf("parameter Ff must be real.\n");
this_var_errors++;
}
if (!mxIsClass(xm, "double")) {
printf("parameter Ff must be a full matrix of doubles.\n");
this_var_errors++;
}
if (mxIsSparse(xm)) {
printf("parameter Ff must be a full matrix.\n");
this_var_errors++;
}
if (this_var_errors == 0) {
dest = params.Ff;
src = mxGetPr(xm);
for (i = 0; i < 6; i++)
*dest++ = *src++;
valid_vars++;
}
}
this_var_errors = 0;
xm = mxGetField(prhs[0], 0, "Fu");
if (xm == NULL) {
printf("could not find params.Fu.\n");
} else {
if (!((mxGetM(xm) == 4) && (mxGetN(xm) == 1))) {
printf("Fu must be size (4,1), not (%d,%d).\n", mxGetM(xm), mxGetN(xm));
this_var_errors++;
}
if (mxIsComplex(xm)) {
printf("parameter Fu must be real.\n");
this_var_errors++;
}
if (!mxIsClass(xm, "double")) {
printf("parameter Fu must be a full matrix of doubles.\n");
this_var_errors++;
}
if (mxIsSparse(xm)) {
printf("parameter Fu must be a full matrix.\n");
this_var_errors++;
}
if (this_var_errors == 0) {
dest = params.Fu;
src = mxGetPr(xm);
for (i = 0; i < 4; i++)
*dest++ = *src++;
valid_vars++;
}
}
this_var_errors = 0;
xm = mxGetField(prhs[0], 0, "Fus");
if (xm == NULL) {
printf("could not find params.Fus.\n");
} else {
if (!((mxGetM(xm) == 2) && (mxGetN(xm) == 1))) {
printf("Fus must be size (2,1), not (%d,%d).\n", mxGetM(xm), mxGetN(xm));
this_var_errors++;
}
if (mxIsComplex(xm)) {
printf("parameter Fus must be real.\n");
this_var_errors++;
}
if (!mxIsClass(xm, "double")) {
printf("parameter Fus must be a full matrix of doubles.\n");
this_var_errors++;
}
if (mxIsSparse(xm)) {
printf("parameter Fus must be a full matrix.\n");
this_var_errors++;
}
if (this_var_errors == 0) {
dest = params.Fus;
src = mxGetPr(xm);
for (i = 0; i < 2; i++)
*dest++ = *src++;
valid_vars++;
}
}
this_var_errors = 0;
xm = mxGetField(prhs[0], 0, "Fx");
if (xm == NULL) {
printf("could not find params.Fx.\n");
} else {
if (!((mxGetM(xm) == 4) && (mxGetN(xm) == 3))) {
printf("Fx must be size (4,3), not (%d,%d).\n", mxGetM(xm), mxGetN(xm));
this_var_errors++;
}
if (mxIsComplex(xm)) {
printf("parameter Fx must be real.\n");
this_var_errors++;
}
if (!mxIsClass(xm, "double")) {
printf("parameter Fx must be a full matrix of doubles.\n");
this_var_errors++;
}
if (mxIsSparse(xm)) {
printf("parameter Fx must be a full matrix.\n");
this_var_errors++;
}
if (this_var_errors == 0) {
dest = params.Fx;
src = mxGetPr(xm);
for (i = 0; i < 12; i++)
*dest++ = *src++;
valid_vars++;
}
}
this_var_errors = 0;
xm = mxGetField(prhs[0], 0, "Fxs");
if (xm == NULL) {
printf("could not find params.Fxs.\n");
} else {
if (!((mxGetM(xm) == 2) && (mxGetN(xm) == 3))) {
printf("Fxs must be size (2,3), not (%d,%d).\n", mxGetM(xm), mxGetN(xm));
this_var_errors++;
}
if (mxIsComplex(xm)) {
printf("parameter Fxs must be real.\n");
this_var_errors++;
}
if (!mxIsClass(xm, "double")) {
printf("parameter Fxs must be a full matrix of doubles.\n");
this_var_errors++;
}
if (mxIsSparse(xm)) {
printf("parameter Fxs must be a full matrix.\n");
this_var_errors++;
}
if (this_var_errors == 0) {
dest = params.Fxs;
src = mxGetPr(xm);
for (i = 0; i < 6; i++)
*dest++ = *src++;
valid_vars++;
}
}
this_var_errors = 0;
xm = mxGetField(prhs[0], 0, "Q");
if (xm == NULL) {
printf("could not find params.Q.\n");
} else {
if (!((mxGetM(xm) == 3) && (mxGetN(xm) == 3))) {
printf("Q must be size (3,3), not (%d,%d).\n", mxGetM(xm), mxGetN(xm));
this_var_errors++;
}
if (mxIsComplex(xm)) {
printf("parameter Q must be real.\n");
this_var_errors++;
}
if (!mxIsClass(xm, "double")) {
printf("parameter Q must be a full matrix of doubles.\n");
this_var_errors++;
}
if (mxIsSparse(xm)) {
printf("parameter Q must be a full matrix.\n");
this_var_errors++;
}
if (this_var_errors == 0) {
dest = params.Q;
src = mxGetPr(xm);
for (i = 0; i < 9; i++)
*dest++ = *src++;
valid_vars++;
}
}
this_var_errors = 0;
xm = mxGetField(prhs[0], 0, "Q_final");
if (xm == NULL) {
printf("could not find params.Q_final.\n");
} else {
if (!((mxGetM(xm) == 3) && (mxGetN(xm) == 3))) {
printf("Q_final must be size (3,3), not (%d,%d).\n", mxGetM(xm), mxGetN(xm));
this_var_errors++;
}
if (mxIsComplex(xm)) {
printf("parameter Q_final must be real.\n");
this_var_errors++;
}
if (!mxIsClass(xm, "double")) {
printf("parameter Q_final must be a full matrix of doubles.\n");
this_var_errors++;
}
if (mxIsSparse(xm)) {
printf("parameter Q_final must be a full matrix.\n");
this_var_errors++;
}
if (this_var_errors == 0) {
dest = params.Q_final;
src = mxGetPr(xm);
for (i = 0; i < 9; i++)
*dest++ = *src++;
valid_vars++;
}
}
this_var_errors = 0;
xm = mxGetField(prhs[0], 0, "R");
if (xm == NULL) {
printf("could not find params.R.\n");
} else {
if (!((mxGetM(xm) == 1) && (mxGetN(xm) == 1))) {
printf("R must be size (1,1), not (%d,%d).\n", mxGetM(xm), mxGetN(xm));
this_var_errors++;
}
if (mxIsComplex(xm)) {
printf("parameter R must be real.\n");
this_var_errors++;
}
if (!mxIsClass(xm, "double")) {
printf("parameter R must be a full matrix of doubles.\n");
this_var_errors++;
}
if (mxIsSparse(xm)) {
printf("parameter R must be a full matrix.\n");
this_var_errors++;
}
if (this_var_errors == 0) {
dest = params.R;
src = mxGetPr(xm);
for (i = 0; i < 1; i++)
*dest++ = *src++;
valid_vars++;
}
}
this_var_errors = 0;
xm = mxGetField(prhs[0], 0, "d");
if (xm == NULL) {
printf("could not find params.d.\n");
} else {
if (!((mxGetM(xm) == 3) && (mxGetN(xm) == 1))) {
printf("d must be size (3,1), not (%d,%d).\n", mxGetM(xm), mxGetN(xm));
this_var_errors++;
}
if (mxIsComplex(xm)) {
printf("parameter d must be real.\n");
this_var_errors++;
}
if (!mxIsClass(xm, "double")) {
printf("parameter d must be a full matrix of doubles.\n");
this_var_errors++;
}
if (mxIsSparse(xm)) {
printf("parameter d must be a full matrix.\n");
this_var_errors++;
}
if (this_var_errors == 0) {
dest = params.d;
src = mxGetPr(xm);
for (i = 0; i < 3; i++)
*dest++ = *src++;
valid_vars++;
}
}
this_var_errors = 0;
xm = mxGetField(prhs[0], 0, "f");
if (xm == NULL) {
printf("could not find params.f.\n");
} else {
if (!((mxGetM(xm) == 4) && (mxGetN(xm) == 1))) {
printf("f must be size (4,1), not (%d,%d).\n", mxGetM(xm), mxGetN(xm));
this_var_errors++;
}
if (mxIsComplex(xm)) {
printf("parameter f must be real.\n");
this_var_errors++;
}
if (!mxIsClass(xm, "double")) {
printf("parameter f must be a full matrix of doubles.\n");
this_var_errors++;
}
if (mxIsSparse(xm)) {
printf("parameter f must be a full matrix.\n");
this_var_errors++;
}
if (this_var_errors == 0) {
dest = params.f;
src = mxGetPr(xm);
for (i = 0; i < 4; i++)
*dest++ = *src++;
valid_vars++;
}
}
this_var_errors = 0;
xm = mxGetField(prhs[0], 0, "ff");
if (xm == NULL) {
printf("could not find params.ff.\n");
} else {
if (!((mxGetM(xm) == 2) && (mxGetN(xm) == 1))) {
printf("ff must be size (2,1), not (%d,%d).\n", mxGetM(xm), mxGetN(xm));
this_var_errors++;
}
if (mxIsComplex(xm)) {
printf("parameter ff must be real.\n");
this_var_errors++;
}
if (!mxIsClass(xm, "double")) {
printf("parameter ff must be a full matrix of doubles.\n");
this_var_errors++;
}
if (mxIsSparse(xm)) {
printf("parameter ff must be a full matrix.\n");
this_var_errors++;
}
if (this_var_errors == 0) {
dest = params.ff;
src = mxGetPr(xm);
for (i = 0; i < 2; i++)
*dest++ = *src++;
valid_vars++;
}
}
this_var_errors = 0;
xm = mxGetField(prhs[0], 0, "fs");
if (xm == NULL) {
printf("could not find params.fs.\n");
} else {
if (!((mxGetM(xm) == 2) && (mxGetN(xm) == 1))) {
printf("fs must be size (2,1), not (%d,%d).\n", mxGetM(xm), mxGetN(xm));
this_var_errors++;
}
if (mxIsComplex(xm)) {
printf("parameter fs must be real.\n");
this_var_errors++;
}
if (!mxIsClass(xm, "double")) {
printf("parameter fs must be a full matrix of doubles.\n");
this_var_errors++;
}
if (mxIsSparse(xm)) {
printf("parameter fs must be a full matrix.\n");
this_var_errors++;
}
if (this_var_errors == 0) {
dest = params.fs;
src = mxGetPr(xm);
for (i = 0; i < 2; i++)
*dest++ = *src++;
valid_vars++;
}
}
this_var_errors = 0;
xm = mxGetField(prhs[0], 0, "x_0");
if (xm == NULL) {
printf("could not find params.x_0.\n");
} else {
if (!((mxGetM(xm) == 3) && (mxGetN(xm) == 1))) {
printf("x_0 must be size (3,1), not (%d,%d).\n", mxGetM(xm), mxGetN(xm));
this_var_errors++;
}
if (mxIsComplex(xm)) {
printf("parameter x_0 must be real.\n");
this_var_errors++;
}
if (!mxIsClass(xm, "double")) {
printf("parameter x_0 must be a full matrix of doubles.\n");
this_var_errors++;
}
if (mxIsSparse(xm)) {
printf("parameter x_0 must be a full matrix.\n");
this_var_errors++;
}
if (this_var_errors == 0) {
dest = params.x_0;
src = mxGetPr(xm);
for (i = 0; i < 3; i++)
*dest++ = *src++;
valid_vars++;
}
}
this_var_errors = 0;
xm = mxGetField(prhs[0], 0, "xt");
if (xm == NULL) {
printf("could not find params.xt.\n");
} else {
if (!((mxGetM(xm) == 3) && (mxGetN(xm) == 1))) {
printf("xt must be size (3,1), not (%d,%d).\n", mxGetM(xm), mxGetN(xm));
this_var_errors++;
}
if (mxIsComplex(xm)) {
printf("parameter xt must be real.\n");
this_var_errors++;
}
if (!mxIsClass(xm, "double")) {
printf("parameter xt must be a full matrix of doubles.\n");
this_var_errors++;
}
if (mxIsSparse(xm)) {
printf("parameter xt must be a full matrix.\n");
this_var_errors++;
}
if (this_var_errors == 0) {
dest = params.xt;
src = mxGetPr(xm);
for (i = 0; i < 3; i++)
*dest++ = *src++;
valid_vars++;
}
}
if (valid_vars != 16) {
printf("Error: %d parameters are invalid.\n", 16 - valid_vars);
mexErrMsgTxt("invalid parameters found.");
}
if (prepare_for_c) {
printf("settings.prepare_for_c == 1. thus, outputting for C.\n");
for (i = 0; i < 3; i++)
printf(" params.x_0[%d] = %.6g;\n", i, params.x_0[i]);
for (i = 0; i < 3; i++)
printf(" params.xt[%d] = %.6g;\n", i, params.xt[i]);
for (i = 0; i < 9; i++)
printf(" params.Q[%d] = %.6g;\n", i, params.Q[i]);
for (i = 0; i < 1; i++)
printf(" params.R[%d] = %.6g;\n", i, params.R[i]);
for (i = 0; i < 6; i++)
printf(" params.Fxs[%d] = %.6g;\n", i, params.Fxs[i]);
for (i = 0; i < 2; i++)
printf(" params.Fus[%d] = %.6g;\n", i, params.Fus[i]);
for (i = 0; i < 2; i++)
printf(" params.fs[%d] = %.6g;\n", i, params.fs[i]);
for (i = 0; i < 9; i++)
printf(" params.Q_final[%d] = %.6g;\n", i, params.Q_final[i]);
for (i = 0; i < 9; i++)
printf(" params.A[%d] = %.6g;\n", i, params.A[i]);
for (i = 0; i < 3; i++)
printf(" params.B[%d] = %.6g;\n", i, params.B[i]);
for (i = 0; i < 3; i++)
printf(" params.d[%d] = %.6g;\n", i, params.d[i]);
for (i = 0; i < 12; i++)
printf(" params.Fx[%d] = %.6g;\n", i, params.Fx[i]);
for (i = 0; i < 4; i++)
printf(" params.Fu[%d] = %.6g;\n", i, params.Fu[i]);
for (i = 0; i < 4; i++)
printf(" params.f[%d] = %.6g;\n", i, params.f[i]);
for (i = 0; i < 6; i++)
printf(" params.Ff[%d] = %.6g;\n", i, params.Ff[i]);
for (i = 0; i < 2; i++)
printf(" params.ff[%d] = %.6g;\n", i, params.ff[i]);
}
/* Perform the actual solve in here. */
steps = solve();
/* For profiling purposes, allow extra silent solves if desired. */
settings.verbose = 0;
for (i = 0; i < extra_solves; i++)
solve();
/* Update the status variables. */
plhs[1] = mxCreateStructArray(1, dims1x1of1, 4, status_names);
xm = mxCreateDoubleMatrix(1, 1, mxREAL);
mxSetField(plhs[1], 0, "optval", xm);
*mxGetPr(xm) = work.optval;
xm = mxCreateDoubleMatrix(1, 1, mxREAL);
mxSetField(plhs[1], 0, "gap", xm);
*mxGetPr(xm) = work.gap;
xm = mxCreateDoubleMatrix(1, 1, mxREAL);
mxSetField(plhs[1], 0, "steps", xm);
*mxGetPr(xm) = steps;
xm = mxCreateDoubleMatrix(1, 1, mxREAL);
mxSetField(plhs[1], 0, "converged", xm);
*mxGetPr(xm) = work.converged;
/* Extract variable values. */
plhs[0] = mxCreateStructArray(1, dims1x1of1, num_var_names, var_names);
/* Create cell arrays for indexed variables. */
dims[0] = 9;
cell = mxCreateCellArray(1, dims);
mxSetField(plhs[0], 0, "u", cell);
dims[0] = 10;
cell = mxCreateCellArray(1, dims);
mxSetField(plhs[0], 0, "x", cell);
xm = mxCreateDoubleMatrix(1, 1, mxREAL);
mxSetField(plhs[0], 0, "u_0", xm);
dest = mxGetPr(xm);
src = vars.u_0;
for (i = 0; i < 1; i++) {
*dest++ = *src++;
}
xm = mxCreateDoubleMatrix(1, 1, mxREAL);
mxSetField(plhs[0], 0, "u_1", xm);
xm_cell = mxCreateDoubleMatrix(1, 1, mxREAL);
cell = mxGetField(plhs[0], 0, "u");
mxSetCell(cell, 0, xm_cell);
dest = mxGetPr(xm);
dest_cell = mxGetPr(xm_cell);
src = vars.u_1;
for (i = 0; i < 1; i++) {
*dest++ = *src;
*dest_cell++ = *src++;
}
xm = mxCreateDoubleMatrix(1, 1, mxREAL);
mxSetField(plhs[0], 0, "u_2", xm);
xm_cell = mxCreateDoubleMatrix(1, 1, mxREAL);
cell = mxGetField(plhs[0], 0, "u");
mxSetCell(cell, 1, xm_cell);
dest = mxGetPr(xm);
dest_cell = mxGetPr(xm_cell);
src = vars.u_2;
for (i = 0; i < 1; i++) {
*dest++ = *src;
*dest_cell++ = *src++;
}
xm = mxCreateDoubleMatrix(1, 1, mxREAL);
mxSetField(plhs[0], 0, "u_3", xm);
xm_cell = mxCreateDoubleMatrix(1, 1, mxREAL);
cell = mxGetField(plhs[0], 0, "u");
mxSetCell(cell, 2, xm_cell);
dest = mxGetPr(xm);
dest_cell = mxGetPr(xm_cell);
src = vars.u_3;
for (i = 0; i < 1; i++) {
*dest++ = *src;
*dest_cell++ = *src++;
}
xm = mxCreateDoubleMatrix(1, 1, mxREAL);
mxSetField(plhs[0], 0, "u_4", xm);
xm_cell = mxCreateDoubleMatrix(1, 1, mxREAL);
cell = mxGetField(plhs[0], 0, "u");
mxSetCell(cell, 3, xm_cell);
dest = mxGetPr(xm);
dest_cell = mxGetPr(xm_cell);
src = vars.u_4;
for (i = 0; i < 1; i++) {
*dest++ = *src;
*dest_cell++ = *src++;
}
xm = mxCreateDoubleMatrix(1, 1, mxREAL);
mxSetField(plhs[0], 0, "u_5", xm);
xm_cell = mxCreateDoubleMatrix(1, 1, mxREAL);
cell = mxGetField(plhs[0], 0, "u");
mxSetCell(cell, 4, xm_cell);
dest = mxGetPr(xm);
dest_cell = mxGetPr(xm_cell);
src = vars.u_5;
for (i = 0; i < 1; i++) {
*dest++ = *src;
*dest_cell++ = *src++;
}
xm = mxCreateDoubleMatrix(1, 1, mxREAL);
mxSetField(plhs[0], 0, "u_6", xm);
xm_cell = mxCreateDoubleMatrix(1, 1, mxREAL);
cell = mxGetField(plhs[0], 0, "u");
mxSetCell(cell, 5, xm_cell);
dest = mxGetPr(xm);
dest_cell = mxGetPr(xm_cell);
src = vars.u_6;
for (i = 0; i < 1; i++) {
*dest++ = *src;
*dest_cell++ = *src++;
}
xm = mxCreateDoubleMatrix(1, 1, mxREAL);
mxSetField(plhs[0], 0, "u_7", xm);
xm_cell = mxCreateDoubleMatrix(1, 1, mxREAL);
cell = mxGetField(plhs[0], 0, "u");
mxSetCell(cell, 6, xm_cell);
dest = mxGetPr(xm);
dest_cell = mxGetPr(xm_cell);
src = vars.u_7;
for (i = 0; i < 1; i++) {
*dest++ = *src;
*dest_cell++ = *src++;
}
xm = mxCreateDoubleMatrix(1, 1, mxREAL);
mxSetField(plhs[0], 0, "u_8", xm);
xm_cell = mxCreateDoubleMatrix(1, 1, mxREAL);
cell = mxGetField(plhs[0], 0, "u");
mxSetCell(cell, 7, xm_cell);
dest = mxGetPr(xm);
dest_cell = mxGetPr(xm_cell);
src = vars.u_8;
for (i = 0; i < 1; i++) {
*dest++ = *src;
*dest_cell++ = *src++;
}
xm = mxCreateDoubleMatrix(1, 1, mxREAL);
mxSetField(plhs[0], 0, "u_9", xm);
xm_cell = mxCreateDoubleMatrix(1, 1, mxREAL);
cell = mxGetField(plhs[0], 0, "u");
mxSetCell(cell, 8, xm_cell);
dest = mxGetPr(xm);
dest_cell = mxGetPr(xm_cell);
src = vars.u_9;
for (i = 0; i < 1; i++) {
*dest++ = *src;
*dest_cell++ = *src++;
}
xm = mxCreateDoubleMatrix(3, 1, mxREAL);
mxSetField(plhs[0], 0, "x_1", xm);
xm_cell = mxCreateDoubleMatrix(3, 1, mxREAL);
cell = mxGetField(plhs[0], 0, "x");
mxSetCell(cell, 0, xm_cell);
dest = mxGetPr(xm);
dest_cell = mxGetPr(xm_cell);
src = vars.x_1;
for (i = 0; i < 3; i++) {
*dest++ = *src;
*dest_cell++ = *src++;
}
xm = mxCreateDoubleMatrix(3, 1, mxREAL);
mxSetField(plhs[0], 0, "x_2", xm);
xm_cell = mxCreateDoubleMatrix(3, 1, mxREAL);
cell = mxGetField(plhs[0], 0, "x");
mxSetCell(cell, 1, xm_cell);
dest = mxGetPr(xm);
dest_cell = mxGetPr(xm_cell);
src = vars.x_2;
for (i = 0; i < 3; i++) {
*dest++ = *src;
*dest_cell++ = *src++;
}
xm = mxCreateDoubleMatrix(3, 1, mxREAL);
mxSetField(plhs[0], 0, "x_3", xm);
xm_cell = mxCreateDoubleMatrix(3, 1, mxREAL);
cell = mxGetField(plhs[0], 0, "x");
mxSetCell(cell, 2, xm_cell);
dest = mxGetPr(xm);
dest_cell = mxGetPr(xm_cell);
src = vars.x_3;
for (i = 0; i < 3; i++) {
*dest++ = *src;
*dest_cell++ = *src++;
}
xm = mxCreateDoubleMatrix(3, 1, mxREAL);
mxSetField(plhs[0], 0, "x_4", xm);
xm_cell = mxCreateDoubleMatrix(3, 1, mxREAL);
cell = mxGetField(plhs[0], 0, "x");
mxSetCell(cell, 3, xm_cell);
dest = mxGetPr(xm);
dest_cell = mxGetPr(xm_cell);
src = vars.x_4;
for (i = 0; i < 3; i++) {
*dest++ = *src;
*dest_cell++ = *src++;
}
xm = mxCreateDoubleMatrix(3, 1, mxREAL);
mxSetField(plhs[0], 0, "x_5", xm);
xm_cell = mxCreateDoubleMatrix(3, 1, mxREAL);
cell = mxGetField(plhs[0], 0, "x");
mxSetCell(cell, 4, xm_cell);
dest = mxGetPr(xm);
dest_cell = mxGetPr(xm_cell);
src = vars.x_5;
for (i = 0; i < 3; i++) {
*dest++ = *src;
*dest_cell++ = *src++;
}
xm = mxCreateDoubleMatrix(3, 1, mxREAL);
mxSetField(plhs[0], 0, "x_6", xm);
xm_cell = mxCreateDoubleMatrix(3, 1, mxREAL);
cell = mxGetField(plhs[0], 0, "x");
mxSetCell(cell, 5, xm_cell);
dest = mxGetPr(xm);
dest_cell = mxGetPr(xm_cell);
src = vars.x_6;
for (i = 0; i < 3; i++) {
*dest++ = *src;
*dest_cell++ = *src++;
}
xm = mxCreateDoubleMatrix(3, 1, mxREAL);
mxSetField(plhs[0], 0, "x_7", xm);
xm_cell = mxCreateDoubleMatrix(3, 1, mxREAL);
cell = mxGetField(plhs[0], 0, "x");
mxSetCell(cell, 6, xm_cell);
dest = mxGetPr(xm);
dest_cell = mxGetPr(xm_cell);
src = vars.x_7;
for (i = 0; i < 3; i++) {
*dest++ = *src;
*dest_cell++ = *src++;
}
xm = mxCreateDoubleMatrix(3, 1, mxREAL);
mxSetField(plhs[0], 0, "x_8", xm);
xm_cell = mxCreateDoubleMatrix(3, 1, mxREAL);
cell = mxGetField(plhs[0], 0, "x");
mxSetCell(cell, 7, xm_cell);
dest = mxGetPr(xm);
dest_cell = mxGetPr(xm_cell);
src = vars.x_8;
for (i = 0; i < 3; i++) {
*dest++ = *src;
*dest_cell++ = *src++;
}
xm = mxCreateDoubleMatrix(3, 1, mxREAL);
mxSetField(plhs[0], 0, "x_9", xm);
xm_cell = mxCreateDoubleMatrix(3, 1, mxREAL);
cell = mxGetField(plhs[0], 0, "x");
mxSetCell(cell, 8, xm_cell);
dest = mxGetPr(xm);
dest_cell = mxGetPr(xm_cell);
src = vars.x_9;
for (i = 0; i < 3; i++) {
*dest++ = *src;
*dest_cell++ = *src++;
}
xm = mxCreateDoubleMatrix(3, 1, mxREAL);
mxSetField(plhs[0], 0, "x_10", xm);
xm_cell = mxCreateDoubleMatrix(3, 1, mxREAL);
cell = mxGetField(plhs[0], 0, "x");
mxSetCell(cell, 9, xm_cell);
dest = mxGetPr(xm);
dest_cell = mxGetPr(xm_cell);
src = vars.x_10;
for (i = 0; i < 3; i++) {
*dest++ = *src;
*dest_cell++ = *src++;
}
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
/* Declare variable */
int i,m,n,nzmax,newnnz,col,processed,passed;
int starting_row_index, current_row_index, stopping_row_index;
double *in_pr,*in_pi,*out_pr,*out_pi;
int *in_ir,*in_jc,*out_ir,*out_jc;
double thres;
/* Check for proper number of input and output arguments */
if ((nlhs != 1) || (nrhs != 2)){
mexErrMsgTxt("usage: SPMX = SPARSIFY(MX, THRES).");
}
/* if matrix is complex threshold the norm of the numbers */
if (mxIsComplex(prhs[0])){
/* Check data type of input argument */
if (mxIsSparse(prhs[0])){
/* read input */
in_pr = mxGetPr(prhs[0]);
in_pi = mxGetPi(prhs[0]);
in_ir = mxGetIr(prhs[0]);
in_jc = mxGetJc(prhs[0]);
nzmax = mxGetNzmax(prhs[0]);
m = mxGetM(prhs[0]);
n = mxGetN(prhs[0]);
thres = mxGetScalar(prhs[1]);
/* Count new nonzeros */
newnnz=0;
for(i=0; i<nzmax; i++){
if (sqrt(in_pr[i]*in_pr[i] + in_pi[i]*in_pi[i])>thres) {newnnz++;}
}
if (newnnz>0){
/* create output */
plhs[0] = mxCreateSparse(m,n,newnnz,mxCOMPLEX);
if (plhs[0]==NULL)
mexErrMsgTxt("Could not allocate enough memory!\n");
out_pr = mxGetPr(plhs[0]);
out_pi = mxGetPr(plhs[0]);
out_ir = mxGetIr(plhs[0]);
out_jc = mxGetJc(plhs[0]);
passed = 0;
out_jc[0] = 0;
for (col=0; col<n; col++){
starting_row_index = in_jc[col];
stopping_row_index = in_jc[col+1];
out_jc[col+1] = out_jc[col];
if (starting_row_index == stopping_row_index)
continue;
else {
for (current_row_index = starting_row_index;
current_row_index < stopping_row_index;
current_row_index++) {
if (sqrt(in_pr[current_row_index]*in_pr[current_row_index] +
in_pi[current_row_index]*in_pi[current_row_index] ) > thres){
out_pr[passed]=in_pr[current_row_index];
out_pi[passed]=in_pi[current_row_index];
out_ir[passed]=in_ir[current_row_index];
out_jc[col+1] = out_jc[col+1]+1;
passed++;
}
}
}
}
}
else{
plhs[0] = mxCreateSparse(m,n,0,mxCOMPLEX);
}
}
else{ /* for full matrices */
/* read input */
in_pr = mxGetPr(prhs[0]);
in_pi = mxGetPr(prhs[0]);
m = mxGetM(prhs[0]);
n = mxGetN(prhs[0]);
thres = mxGetScalar(prhs[1]);
/* Count new nonzeros */
newnnz=0;
for(i=0; i<m*n; i++){
if (sqrt(in_pr[i]*in_pr[i] + in_pi[i]*in_pi[i])>thres) {newnnz++;}
}
if (newnnz>0){
/* create output */
plhs[0] = mxCreateSparse(m,n,newnnz,mxCOMPLEX);
if (plhs[0]==NULL)
mexErrMsgTxt("Could not allocate enough memory!\n");
out_pr = mxGetPr(plhs[0]);
out_pi = mxGetPi(plhs[0]);
out_ir = mxGetIr(plhs[0]);
out_jc = mxGetJc(plhs[0]);
passed = 0;
out_jc[0] = 0;
for (col=0; col<n; col++){
out_jc[col+1] = out_jc[col];
for (current_row_index=0; current_row_index<m; current_row_index++){
if (sqrt(in_pr[current_row_index+m*col]*in_pr[current_row_index+m*col] +
in_pi[current_row_index+m*col]*in_pi[current_row_index+m*col]) > thres){
out_pr[passed]=in_pr[current_row_index+m*col];
out_ir[passed]=current_row_index;
out_jc[col+1] = out_jc[col+1]+1;
passed++;
}
}
}
}
else{
plhs[0] = mxCreateSparse(m,n,0,mxCOMPLEX);
}
}
}
else {
/* Check data type of input argument */
if (mxIsSparse(prhs[0])){
/* read input */
in_pr = mxGetPr(prhs[0]);
in_ir = mxGetIr(prhs[0]);
in_jc = mxGetJc(prhs[0]);
nzmax = mxGetNzmax(prhs[0]);
n = mxGetN(prhs[0]);
m = mxGetM(prhs[0]);
thres = mxGetScalar(prhs[1]);
/* Count new nonzeros */
newnnz=0;
for(i=0; i<nzmax; i++){
if ((fabs(in_pr[i]))>thres) {newnnz++;}
}
if (newnnz>0){
/* create output */
plhs[0] = mxCreateSparse(m,n,newnnz,mxREAL);
if (plhs[0]==NULL)
mexErrMsgTxt("Could not allocate enough memory!\n");
out_pr = mxGetPr(plhs[0]);
out_ir = mxGetIr(plhs[0]);
out_jc = mxGetJc(plhs[0]);
passed = 0;
out_jc[0] = 0;
for (col=0; col<n; col++){
starting_row_index = in_jc[col];
stopping_row_index = in_jc[col+1];
out_jc[col+1] = out_jc[col];
if (starting_row_index == stopping_row_index)
continue;
else {
for (current_row_index = starting_row_index;
current_row_index < stopping_row_index;
current_row_index++) {
if (fabs(in_pr[current_row_index])>thres){
out_pr[passed]=in_pr[current_row_index];
out_ir[passed]=in_ir[current_row_index];
out_jc[col+1] = out_jc[col+1]+1;
passed++;
}
}
}
}
}
else{
plhs[0] = mxCreateSparse(m,n,0,mxREAL);
}
}
else{ /* for full matrices */
/* read input */
in_pr = mxGetPr(prhs[0]);
n = mxGetN(prhs[0]);
m = mxGetM(prhs[0]);
thres = mxGetScalar(prhs[1]);
/* Count new nonzeros */
newnnz=0;
for(i=0; i<m*n; i++){
if ((fabs(in_pr[i]))>thres) {newnnz++;}
}
if (newnnz>0){
/* create output */
plhs[0] = mxCreateSparse(m,n,newnnz,mxREAL);
if (plhs[0]==NULL)
mexErrMsgTxt("Could not allocate enough memory!\n");
out_pr = mxGetPr(plhs[0]);
out_ir = mxGetIr(plhs[0]);
out_jc = mxGetJc(plhs[0]);
passed = 0;
out_jc[0] = 0;
for (col=0; col<n; col++){
out_jc[col+1] = out_jc[col];
for (current_row_index=0; current_row_index<m; current_row_index++){
if (fabs(in_pr[current_row_index+m*col])>thres){
out_pr[passed]=in_pr[current_row_index+m*col];
out_ir[passed]=current_row_index;
out_jc[col+1] = out_jc[col+1]+1;
passed++;
}
}
}
}
else{
plhs[0] = mxCreateSparse(m,n,0,mxREAL);
}
}
}
}
