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); } } } }