void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { int n, p ; double *a, *l; double *adiag, *ldiag; int *acol_ptr, *arow_ind ; int *lcol_ptr, *lrow_ind ; /* Working arrays */ double *w1, *w2 ; int *iw ; /* Local variables */ int i, nnz ; double alpha ; /* Right hand side */ n = (int) mxGetScalar(prhs[0]); a = mxGetPr(prhs[1]); arow_ind = mxGetIr(prhs[1]); acol_ptr = mxGetJc(prhs[1]); adiag = mxGetPr(prhs[2]) ; p = (int) mxGetScalar(prhs[3]) ; nnz = acol_ptr[n] ; /* Left-hand side */ if (plhs[0] != NULL) mxDestroyArray(plhs[0]) ; plhs[0] = mxCreateSparse(n, n, nnz+n*p, mxREAL) ; l = mxGetPr(plhs[0]); lrow_ind = mxGetIr(plhs[0]); lcol_ptr = mxGetJc(plhs[0]); if (plhs[1] != NULL) mxDestroyArray(plhs[1]) ; plhs[1] = mxCreateDoubleMatrix(n, 1, mxREAL) ; ldiag = mxGetPr(plhs[1]) ; /* Allocate working arrays */ if (( (w1=(double *)calloc(n, sizeof(double)))==(double *)NULL ) || ( (w2=(double *)calloc(n, sizeof(double)))==(double *)NULL ) || ( (iw=(int *)calloc(3*n, sizeof(int)))==(int *)NULL )) { printf("Not enough memory\n") ; } /* Change a's i j into fortran index */ for (i = 0; i < nnz; i++) arow_ind[i] = arow_ind[i] + 1 ; for (i = 0; i <= n; i++) acol_ptr[i] = acol_ptr[i] + 1 ; /* Call icf fortran subroutine */ alpha = 0.0 ; dicfs_(&n, &nnz, a, adiag, acol_ptr, arow_ind, l, ldiag, lcol_ptr, lrow_ind, &p, &alpha, iw, w1, w2) ; /* Change a's i j into C index */ for (i = 0; i < nnz; i++) arow_ind[i] = arow_ind[i] - 1 ; for (i = 0; i < lcol_ptr[n]; i++) lrow_ind[i] = lrow_ind[i] - 1 ; for (i = 0; i <= n; i++) { acol_ptr[i] = acol_ptr[i] - 1 ; lcol_ptr[i] = lcol_ptr[i] - 1 ; } /* Free memory */ free(w1) ; free(w2) ; free(iw) ; } /* mexFunction */
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { /* counters */ mwIndex c, r, nv, oc, or, vc, tc; mwSize m, n; double iv; /* pointers */ mwIndex *io, *jo; const double *v, *i, *j; double *vo; /* input check */ if ((nrhs != 1) && (nrhs != 2) && (nrhs != 5)) mexErrMsgTxt("Requires 1, 2, or 5 input arguments."); if ((mxGetClassID(*prhs) != mxDOUBLE_CLASS) || mxIsSparse(*prhs)) mexErrMsgTxt("First input argument must be of type full double."); nv = mxGetNumberOfElements(*prhs); if ((nrhs == 2) && ((!mxIsSparse(prhs[1])) || (mxGetClassID(prhs[1]) != mxDOUBLE_CLASS) || (mxGetNzmax(prhs[1]) < nv))) mexErrMsgTxt("For two-argument call, second input argument must be of type sparse double with at least V values."); else if ((nrhs == 5) && ((mxGetClassID(prhs[1]) != mxDOUBLE_CLASS) || (mxIsSparse(prhs[1])) || (mxGetNumberOfElements(prhs[1]) != 1) || (mxGetClassID(prhs[2]) != mxDOUBLE_CLASS) || (mxIsSparse(prhs[2])) || (mxGetNumberOfElements(prhs[2]) != 1) || (mxGetClassID(prhs[3]) != mxDOUBLE_CLASS) || (mxIsSparse(prhs[3])) || (mxGetNumberOfElements(prhs[3]) != nv) || (mxGetClassID(prhs[4]) != mxDOUBLE_CLASS) || (mxIsSparse(prhs[4])) || (mxGetNumberOfElements(prhs[4]) != nv))) mexErrMsgTxt("For five-argument call, arguments must be Vx1 v, 1x1 m, 1x1 n, Vx1 i, and Vx1 j."); /* get data */ v = (const double *) mxGetData(*prhs); /* one argument only */ if (nrhs == 1) { /* create output */ *plhs = mxCreateSparse(nv, nv, nv, mxREAL); if (*plhs == NULL) mexErrMsgTxt("Error creating sparse double matrix."); vo = (double *) mxGetData(*plhs); if (vo == NULL) mexErrMsgTxt("Error retrieving double data pointer."); io = (mwIndex *) mxGetIr(*plhs); if (io == NULL) mexErrMsgTxt("Error retrieving Ir index pointer."); jo = (mwIndex *) mxGetJc(*plhs); if (jo == NULL) mexErrMsgTxt("Error retrieving Jc index pointer."); /* loop */ for (vc = 0; vc < nv; ++vc) { *vo++ = *v++; *io++ = vc; *jo++ = vc; } *jo = vc; /* two arguments, overwrite existing sparse */ } else if (nrhs == 2) { /* copy pointer */ *plhs = (mxArray *) ((void *) prhs[1]); /* get data pointer */ vo = (double *) mxGetData(*plhs); /* loop */ for (vc = nv; vc > 0; --vc) *vo++ = *v++; /* five arguments, create new sparse from complex data */ } else { /* get size */ i = (const double *) mxGetData(prhs[1]); m = (int) *i; i = (const double *) mxGetData(prhs[2]); n = (int) *i; i = (const double *) mxGetData(prhs[3]); j = (const double *) mxGetData(prhs[4]); /* create sparse matrix */ *plhs = mxCreateSparse(m, n, nv, mxREAL); if (*plhs == NULL) mexErrMsgTxt("Error creating sparse double matrix."); vo = (double *) mxGetData(*plhs); if (vo == NULL) mexErrMsgTxt("Error retrieving double data pointer."); io = (mwIndex *) mxGetIr(*plhs); if (io == NULL) mexErrMsgTxt("Error retrieving Ir index pointer."); jo = (mwIndex *) mxGetJc(*plhs); if (jo == NULL) mexErrMsgTxt("Error retrieving Jc index pointer."); /* loop */ for (vc = nv, or = 0, oc = 0, tc = 0; vc > 0; --vc) { /* get target index */ r = (mwIndex) *i++; c = (mwIndex) *j++; iv = *v++; /* only allow if valid */ if ((c < oc) || ((c == oc) && (r <= or)) || (r < 1) || (r > m) || (c < 1) || (c > n)) continue; /* update column ? */ while (c > oc) { *jo++ = tc; ++oc; } /* write into arrays */ *io++ = (r - 1); *vo++ = iv; /* keep track of written values */ or = r; ++tc; } /* extend column */ while (oc <= n) { *jo++ = tc; ++oc; } } }
void mexFunction ( int nlhs, mxArray *plhs [], int nrhs, const mxArray *prhs [] ) { /* Compressed column form of L, x and b */ mwIndex *Lp, *Ap, *Ai, *Up, *pp, *pi ; Int *Li, *Ui; mwIndex *Lp1, *Li1, *Up1, *Ui1 ; double *Lx, *Ax, *Ux, *px ; double *Lx1, *Ux1 ; double *t1, *t2 ; mwIndex anrow ; mwIndex ancol ; mwIndex lnnz ; mwIndex unnz ; mwIndex i ; mwIndex j ; mwIndex app_xnnz ; mwIndex memsize ; mwIndex result ; mwIndex *ws; /* workspace */ double *X ; /* space to scatter x */ mwIndex *pinv ; /* column permutation inverse */ if ( nlhs != 3 || nrhs < 3 ) { //mexErrMsgTxt (" Incorrect number of arguments to sproductmex \n") ; } Ap = mxGetJc(prhs[0]) ; Ai = mxGetIr(prhs[0]) ; Ax = mxGetPr(prhs[0]) ; anrow = mxGetM (prhs[0]) ; ancol = mxGetN (prhs[0]) ; t1 = mxGetPr (prhs[1]) ; t2 = mxGetPr (prhs[2]) ; lnnz = (mwIndex)*t1 ; unnz = (mwIndex)*t2 ; /*printf("lnnz=%d unnz=%d\n", lnnz, unnz);*/ BaskerClassicNS::BaskerClassic <mwIndex, double> mybasker; mybasker.factor(anrow, ancol, lnnz, Ap, Ai, Ax); mybasker.returnL(&anrow, &lnnz, &Lp, &Li, &Lx); mybasker.returnU(&anrow, &unnz, &Up, &Ui, &Ux); mybasker.returnP(&pp); plhs[0] = mxCreateSparse (anrow, ancol, lnnz+1, mxREAL) ; Lp1 = mxGetJc (plhs[0]) ; Li1 = mxGetIr (plhs[0]) ; Lx1 = mxGetPr (plhs[0]) ; plhs[1] = mxCreateSparse (anrow, ancol, unnz, mxREAL) ; Up1 = mxGetJc (plhs[1]) ; Ui1 = mxGetIr (plhs[1]) ; Ux1 = mxGetPr (plhs[1]) ; mwIndex *pp1, *pp2; double *ppx; plhs[2] = mxCreateSparse (ancol, ancol, ancol, mxREAL); pp1 = mxGetJc (plhs[2]); pp2 = mxGetIr (plhs[2]); ppx = mxGetPr (plhs[2]); Lp1[0] = Lp[0]; for ( i = 0 ; i < ancol ; i++) { Lp1[i+1] = Lp[i+1]; for ( j = Lp[i] ; j < Lp[i+1] ; j++ ) { Li1[j] = Li[j]; Lx1[j] = Lx[j]; } } Up1[0] = Up[0]; for ( i = 0 ; i < ancol ; i++) { Up1[i+1] = Up[i+1]; for ( j = Up[i] ; j < Up[i+1] ; j++ ) { Ui1[j] = Ui[j]; Ux1[j] = Ux[j]; } } //mexPrintf("Perm \n"); for ( i = 0; i < ancol; i++) { //mexPrintf("%d ", pp[i]); pp1[i] = i; //pp2[i] = i; pp2[pp[i]] = i ; ppx[i] = 1; } pp1[ancol] = ancol; mxFree (pp) ; mxFree (Lp) ; mxFree (Li) ; mxFree (Lx) ; mxFree (Up) ; mxFree (Ui) ; mxFree (Ux) ; }
const char *model_to_matlab_structure(mxArray *plhs[], int num_of_feature, struct svm_model *model) { int i, j, n; double *ptr; mxArray *return_model, **rhs; int out_id = 0; rhs = (mxArray **)mxMalloc(sizeof(mxArray *)*NUM_OF_RETURN_FIELD); // Parameters rhs[out_id] = mxCreateDoubleMatrix(5, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); ptr[0] = model->param.svm_type; ptr[1] = model->param.kernel_type; ptr[2] = model->param.degree; ptr[3] = model->param.gamma; ptr[4] = model->param.coef0; out_id++; // nr_class rhs[out_id] = mxCreateDoubleMatrix(1, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); ptr[0] = model->nr_class; out_id++; // total SV rhs[out_id] = mxCreateDoubleMatrix(1, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); ptr[0] = model->l; out_id++; // rho n = model->nr_class*(model->nr_class-1)/2; rhs[out_id] = mxCreateDoubleMatrix(n, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); for(i = 0; i < n; i++) ptr[i] = model->rho[i]; out_id++; // Label if(model->label) { rhs[out_id] = mxCreateDoubleMatrix(model->nr_class, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); for(i = 0; i < model->nr_class; i++) ptr[i] = model->label[i]; } else rhs[out_id] = mxCreateDoubleMatrix(0, 0, mxREAL); out_id++; // probA, probB if(model->probA != NULL && model->probB != NULL) { rhs[out_id] = mxCreateDoubleMatrix(n, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); for(i = 0; i < n; i++) ptr[i] = model->probA[i]; rhs[out_id+1] = mxCreateDoubleMatrix(n, 1, mxREAL); ptr = mxGetPr(rhs[out_id+1]); for(i = 0; i < n; i++) ptr[i] = model->probB[i]; } else { rhs[out_id] = mxCreateDoubleMatrix(0, 0, mxREAL); rhs[out_id+1] = mxCreateDoubleMatrix(0, 0, mxREAL); } out_id+=2; // nSV if(model->nSV) { rhs[out_id] = mxCreateDoubleMatrix(model->nr_class, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); for(i = 0; i < model->nr_class; i++) ptr[i] = model->nSV[i]; } else rhs[out_id] = mxCreateDoubleMatrix(0, 0, mxREAL); out_id++; // sv_coef rhs[out_id] = mxCreateDoubleMatrix(model->l, model->nr_class-1, mxREAL); ptr = mxGetPr(rhs[out_id]); for(i = 0; i < model->nr_class-1; i++) for(j = 0; j < model->l; j++) ptr[(i*(model->l))+j] = model->sv_coef[i][j]; out_id++; // SVs { int ir_index, nonzero_element; mwIndex *ir, *jc; mxArray *pprhs[1], *pplhs[1]; if(model->param.kernel_type == PRECOMPUTED) { nonzero_element = model->l; num_of_feature = 1; } else { nonzero_element = 0; for(i = 0; i < model->l; i++) { j = 0; while(model->SV[i][j].index != -1) { nonzero_element++; j++; } } } // SV in column, easier accessing rhs[out_id] = mxCreateSparse(num_of_feature, model->l, nonzero_element, mxREAL); ir = mxGetIr(rhs[out_id]); jc = mxGetJc(rhs[out_id]); ptr = mxGetPr(rhs[out_id]); ir_index = jc[0] = 0; for(i = 0;i < model->l; i++) { if(model->param.kernel_type == PRECOMPUTED) { // make a (1 x model->l) matrix ir[ir_index] = 0; ptr[ir_index] = model->SV[i][0].value; ir_index++; jc[i+1] = jc[i] + 1; } else { int x_index = 0; while (model->SV[i][x_index].index != -1) { ir[ir_index] = model->SV[i][x_index].index - 1; ptr[ir_index] = model->SV[i][x_index].value; ir_index++, x_index++; } jc[i+1] = jc[i] + x_index; } } // transpose back to SV in row pprhs[0] = rhs[out_id]; if(mexCallMATLAB(1, pplhs, 1, pprhs, "transpose")) return "cannot transpose SV matrix"; rhs[out_id] = pplhs[0]; out_id++; } /* Create a struct matrix contains NUM_OF_RETURN_FIELD fields */ return_model = mxCreateStructMatrix(1, 1, NUM_OF_RETURN_FIELD, field_names); /* Fill struct matrix with input arguments */ for(i = 0; i < NUM_OF_RETURN_FIELD; i++) mxSetField(return_model,0,field_names[i],mxDuplicateArray(rhs[i])); /* return */ plhs[0] = return_model; mxFree(rhs); return NULL; }
void mexFunction( int nargout, mxArray *out[], int nargin, const mxArray *in[] ) { /* declare variables */ int nr, nc, np, total; int i, j, k, ix, iy, jx, jy, ii, jj, iip1, jjp1, iip2, jjp2, step; double sigma, di, dj, a, z, maxori, phase1, phase2, slope; // int *ir, *jc; mwIndex*ir,*jc; unsigned int *pi, *pj; double *emag, *ephase, *w; /* check argument */ if (nargin<4) { mexErrMsgTxt("Four input arguments required"); } if (nargout>1) { mexErrMsgTxt("Too many output arguments"); } /* get edgel information */ nr = mxGetM(in[0]); nc = mxGetN(in[0]); if ( nr*nc ==0 || nr != mxGetM(in[1]) || nc != mxGetN(in[1]) ) { mexErrMsgTxt("Edge magnitude and phase shall be of the same image size"); } emag = mxGetPr(in[0]); ephase = mxGetPr(in[1]); np = nr * nc; /* get new index pair */ if (!mxIsUint32(in[2]) | !mxIsUint32(in[3])) { mexErrMsgTxt("Index pair shall be of type UINT32"); } if (mxGetM(in[3]) * mxGetN(in[3]) != np + 1) { mexErrMsgTxt("Wrong index representation"); } pi = (unsigned int*)mxGetData(in[2]); /* pointer to w_i */ pj = (unsigned int*)mxGetData(in[3]); /* pointer to w_j */ /* create output */ out[0] = mxCreateSparse(np,np,pj[np],mxREAL); if (out[0]==NULL) { mexErrMsgTxt("Not enough memory for the output matrix"); } w = mxGetPr(out[0]); ir = mxGetIr(out[0]); /* */ jc = mxGetJc(out[0]); /* find my sigma */ if (nargin<5) { sigma = 0; for (k=0; k<np; k++) { if (emag[k]>sigma) { sigma = emag[k]; } } sigma = sigma / 6; printf("sigma = %6.5f",sigma); } else { sigma = mxGetScalar(in[4]); } a = 0.5 / (sigma * sigma); /* computation */ total = 0; for (j=0; j<np; j++) { jc[j] = total; jx = j / nr; /* col */ jy = j % nr; /* row */ for (k=pj[j]; k<pj[j+1]; k++) { i = pi[k]; if (i==j) { maxori = 1; } else { ix = i / nr; iy = i % nr; /* scan */ di = (double) (iy - jy); dj = (double) (ix - jx); maxori = 0.; phase1 = ephase[j]; /* sample in i direction */ if (abs(di) >= abs(dj)) { slope = dj / di; step = (iy>=jy) ? 1 : -1; iip1 = jy; jjp1 = jx; for (ii=0;ii<abs(di);ii++){ iip2 = iip1 + step; jjp2 = (int)(0.5 + slope*(iip2-jy) + jx); phase2 = ephase[iip2+jjp2*nr]; if (phase1 != phase2) { z = (emag[iip1+jjp1*nr] + emag[iip2+jjp2*nr]); if (z > maxori){ maxori = z; } } iip1 = iip2; jjp1 = jjp2; phase1 = phase2; } /* sample in j direction */ } else { slope = di / dj; step = (ix>=jx) ? 1: -1; jjp1 = jx; iip1 = jy; for (jj=0;jj<abs(dj);jj++){ jjp2 = jjp1 + step; iip2 = (int)(0.5+ slope*(jjp2-jx) + jy); phase2 = ephase[iip2+jjp2*nr]; if (phase1 != phase2){ z = (emag[iip1+jjp1*nr] + emag[iip2+jjp2*nr]); if (z > maxori){ maxori = z; } } iip1 = iip2; jjp1 = jjp2; phase1 = phase2; } } maxori = 0.5 * maxori; //maxori = exp(-maxori * maxori * a); //segmentation maxori = 1-exp(-maxori * maxori * a); //symmetry } ir[total] = i; if (maxori>0.2) w[total] = maxori; else w[total]=0.2; //symmetry //w[total] = maxori; //segmentation total = total + 1; } /* i */ } /* j */ jc[np] = total; }
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; char *fname, rhstyp[4], title[81], key[9], type[4]; int i,j,k,l, mynrhs, status; integer nrhsix, m, *rhsptr=NULL, *rhsind=NULL, ierr, nr,nc,nz, tmp,tmp0,tmp2,tmp3,ncolumns; size_t mrows, ncols, sizebuf; mwSize nnz, buflen; mwIndex *irs, *jcs; double *pr, *pi, *sr, *si; doublecomplex *sol, *rhs=NULL, *rhsval=NULL; mxArray *fout, *f_input; FILE *fp; if (nrhs!=1) mexErrMsgTxt("Only one input argument required."); else if (nlhs!=3) mexErrMsgTxt("Three output arguments are required."); else if (mxGetClassID(prhs[0])!=mxCHAR_CLASS) mexErrMsgTxt("Input must be a string."); /* get filename */ f_input = (mxArray *) prhs[0]; mrows = mxGetM (f_input) ; ncols = mxGetN (f_input) ; /* Get the length of the input string. */ buflen = (mrows*ncols) + 1; /* Allocate memory for input and output strings. */ fname = (char *) mxCalloc((size_t)buflen, (size_t)sizeof(char)); /* Copy the string data from tmp into a C string pdata */ status = mxGetString(f_input, fname, buflen); ncolumns = 0; tmp0 = 0; if ((fp=fopen(fname,"r"))==NULL) { mexPrintf(" file %s",fname); mexErrMsgTxt(" not found"); return; } fclose(fp); rhstyp[0]=' '; rhstyp[1]=' '; rhstyp[2]=' '; A.nc=0; Zreadmtc(&tmp0,&tmp0,&tmp0,fname,A.a,A.ja,A.ia, rhs,&ncolumns,rhstyp,&nr,&nc,&nz,title,key,type, &nrhsix,rhsptr,rhsind,rhsval,&ierr,strlen(fname),2,72,8,3); ncols=ncolumns; /* if a right hand side is given, then use these */ if (ierr) { mexPrintf(" ierr = %d\n",ierr); mexErrMsgTxt(" error in reading the matrix, stop.\n"); switch(ierr) { case 1: mexErrMsgTxt("too many columns\n"); break; case 2: mexErrMsgTxt("too many nonzeros\n"); break; case 3: mexErrMsgTxt("too many columns and nonzeros\n"); break; case 4: mexErrMsgTxt("right hand side has incompatible type\n"); break; case 5: mexErrMsgTxt("too many right hand side entries\n"); break; case 6: mexErrMsgTxt("wrong type (real/complex)\n"); break; } exit(ierr); } if (ncols>0) { m=1; if (rhstyp[1]=='G' || rhstyp[1]=='g') { m++; } if (rhstyp[2]=='X' || rhstyp[2]=='x') { m++; } } else m=0; m*=nr*ncols; rhsptr=NULL; rhsind=NULL; rhsval=NULL; if (ncols!=0 && (rhstyp[0]=='M' || rhstyp[0]=='m')) { rhsptr=(integer *) MAlloc((size_t)(ncols+1)*sizeof(integer),"Zloadhbo:rhsptr"); rhsind=(integer *) MAlloc((size_t)nrhsix*sizeof(integer), "Zloadhbo:rhsind"); rhsval=(doublecomplex *) MAlloc((size_t)nrhsix*sizeof(doublecomplex), "Zloadhbo:rhsval"); } A.ia=(integer *) MAlloc((size_t)(nc+1)*sizeof(integer), "Zloadhbo:A.ia"); A.ja=(integer *) MAlloc((size_t)nz*sizeof(integer), "Zloadhbo:A.ja"); A.a =(doublecomplex*)MAlloc((size_t)nz*sizeof(doublecomplex),"Zloadhbo:A.a"); A.nr=nr; A.nc=nc; rhs =(doublecomplex *)MAlloc((size_t)m*sizeof(doublecomplex),"Zloadhbo:rhs"); /* advance pointer to reserve space when uncompressing the right hand side */ if (ncols!=0 && (rhstyp[0]=='M' || rhstyp[0]=='m')) rhs+=nr*ncols; tmp = 3; tmp2 = nc; tmp3 = nz; if (ncols!=0 && (rhstyp[0]=='M' || rhstyp[0]=='m')) m-=nr*ncols; Zreadmtc(&tmp2,&tmp3,&tmp,fname,A.a,A.ja,A.ia, rhs,&m,rhstyp,&nr,&nc,&nz,title,key,type, &nrhsix,rhsptr,rhsind,rhsval,&ierr,strlen(fname),2,72,8,3); if (ncols!=0 && (rhstyp[0]=='M' || rhstyp[0]=='m')) m+=nr*ncols; if (ierr) { mexPrintf(" ierr = %d\n",ierr); mexErrMsgTxt(" error in reading the matrix, stop.\n"); return; } /* set output parameters */ nlhs=3; fout =mxCreateSparse((mwSize)nr,(mwSize)nc, (mwSize)nz, mxCOMPLEX); plhs[0]=fout; sr = (double *) mxGetPr(fout); si = (double *) mxGetPi(fout); irs = (mwIndex *) mxGetIr(fout); jcs = (mwIndex *) mxGetJc(fout); jcs[0]=0; for (i=0; i<nc; i++) { jcs[i+1]=A.ia[i+1]-1; for (j=A.ia[i]-1; j<A.ia[i+1]-1; j++) { irs[j]=A.ja[j]-1; sr[j] =A.a[j].r; si[j] =A.a[j].i; } } if (ncols>0) { m=1; if (rhstyp[1]=='G' || rhstyp[1]=='g') { m++; } if (rhstyp[2]=='X' || rhstyp[2]=='x') { m++; } } else m=0; fout=mxCreateDoubleMatrix((mwSize)nr,(mwSize)m*ncols, mxCOMPLEX); plhs[1]=fout; if (ncols!=0 && (rhstyp[0]=='M' || rhstyp[0]=='m')) { } else { pr = mxGetPr(fout); pi = mxGetPi(fout); for (i=0; i<nr*m*ncols; i++) { pr[i]=rhs[i].r; pi[i]=rhs[i].i; } } rhstyp[3]='\0'; plhs[2] = mxCreateString(rhstyp); free(A.a); free(A.ia); free(A.ja); if (ncols>0) free(rhs); if (ncols!=0 && (rhstyp[0]=='M' || rhstyp[0]=='m')) { free(rhsptr); free(rhsind); free(rhsval); } return; }
Need ompcore(double D[], double x[], double DtX[], double XtX[], double G[], mwSize n, mwSize m, mwSize L, int T, double eps, int gamma_mode, int profile, double msg_delta, int erroromp) { profdata pd; /* mxArray *Gamma;*/ mwIndex i, j, signum, pos, *ind, *gammaIr, *gammaJc, gamma_count; mwSize allocated_coefs, allocated_cols; int DtX_specified, XtX_specified, batchomp, standardomp, *selected_atoms,*times_atoms ; double *alpha, *r, *Lchol, *c, *Gsub, *Dsub, sum, *gammaPr, *tempvec1, *tempvec2; double eps2, resnorm, delta, deltaprev, secs_remain; int mins_remain, hrs_remain; clock_t lastprint_time, starttime; Need my; /*** status flags ***/ DtX_specified = (DtX!=0); /* indicates whether D'*x was provided */ XtX_specified = (XtX!=0); /* indicates whether sum(x.*x) was provided */ standardomp = (G==0); /* batch-omp or standard omp are selected depending on availability of G */ batchomp = !standardomp; /*** allocate output matrix ***/ if (gamma_mode == FULL_GAMMA) { /* allocate full matrix of size m X L */ Gamma = mxCreateDoubleMatrix(m, L, mxREAL); gammaPr = mxGetPr(Gamma); gammaIr = 0; gammaJc = 0; } else { /* allocate sparse matrix with room for allocated_coefs nonzeros */ /* for error-omp, begin with L*sqrt(n)/2 allocated nonzeros, otherwise allocate L*T nonzeros */ allocated_coefs = erroromp ? (mwSize)(ceil(L*sqrt((double)n)/2.0) + 1.01) : L*T; Gamma = mxCreateSparse(m, L, allocated_coefs, mxREAL); gammaPr = mxGetPr(Gamma); gammaIr = mxGetIr(Gamma); gammaJc = mxGetJc(Gamma); gamma_count = 0; gammaJc[0] = 0; } /*** helper arrays ***/ alpha = (double*)mxMalloc(m*sizeof(double)); /* contains D'*residual */ ind = (mwIndex*)mxMalloc(n*sizeof(mwIndex)); /* indices of selected atoms */ selected_atoms = (int*)mxMalloc(m*sizeof(int)); /* binary array with 1's for selected atoms */ times_atoms = (int*)mxMalloc(m*sizeof(int)); c = (double*)mxMalloc(n*sizeof(double)); /* orthogonal projection result */ /* current number of columns in Dsub / Gsub / Lchol */ allocated_cols = erroromp ? (mwSize)(ceil(sqrt((double)n)/2.0) + 1.01) : T; /* Cholesky decomposition of D_I'*D_I */ Lchol = (double*)mxMalloc(n*allocated_cols*sizeof(double)); /* temporary vectors for various computations */ tempvec1 = (double*)mxMalloc(m*sizeof(double)); tempvec2 = (double*)mxMalloc(m*sizeof(double)); if (batchomp) { /* matrix containing G(:,ind) - the columns of G corresponding to the selected atoms, in order of selection */ Gsub = (double*)mxMalloc(m*allocated_cols*sizeof(double)); } else { /* matrix containing D(:,ind) - the selected atoms from D, in order of selection */ Dsub = (double*)mxMalloc(n*allocated_cols*sizeof(double)); /* stores the residual */ r = (double*)mxMalloc(n*sizeof(double)); } if (!DtX_specified) { /* contains D'*x for the current signal */ DtX = (double*)mxMalloc(m*sizeof(double)); } /*** initializations for error omp ***/ if (erroromp) { eps2 = eps*eps; /* compute eps^2 */ if (T<0 || T>n) { /* unspecified max atom num - set max atoms to n */ T = n; } } /*** initialize timers ***/ initprofdata(&pd); /* initialize profiling counters */ starttime = clock(); /* record starting time for eta computations */ lastprint_time = starttime; /* time of last status display */ /********************** perform omp for each signal **********************/ for (signum=0; signum<L; ++signum) { /* initialize residual norm and deltaprev for error-omp */ if (erroromp) { if (XtX_specified) { resnorm = XtX[signum]; } else { resnorm = dotprod(x+n*signum, x+n*signum, n); addproftime(&pd, XtX_TIME); } deltaprev = 0; /* delta tracks the value of gamma'*G*gamma */ } else { /* ignore residual norm stopping criterion */ eps2 = 0; resnorm = 1; } if (resnorm>eps2 && T>0) { /* compute DtX */ if (!DtX_specified) { matT_vec(1, D, x+n*signum, DtX, n, m); addproftime(&pd, DtX_TIME); } /* initialize alpha := DtX */ memcpy(alpha, DtX + m*signum*DtX_specified, m*sizeof(double)); /* mark all atoms as unselected */ for (i=0; i<m; ++i) { selected_atoms[i] = 0; } for (i=0; i<m; ++i) { times_atoms[i] = 0; } } /* main loop */ i=0; while (resnorm>eps2 && i<T) { /* index of next atom */ pos = maxabs(alpha, m); addproftime(&pd, MAXABS_TIME); /* stop criterion: selected same atom twice, or inner product too small */ if (selected_atoms[pos] || alpha[pos]*alpha[pos]<1e-14) { break; } /* mark selected atom */ ind[i] = pos; selected_atoms[pos] = 1; times_atoms[pos]++; /* matrix reallocation */ if (erroromp && i>=allocated_cols) { allocated_cols = (mwSize)(ceil(allocated_cols*MAT_INC_FACTOR) + 1.01); Lchol = (double*)mxRealloc(Lchol,n*allocated_cols*sizeof(double)); batchomp ? (Gsub = (double*)mxRealloc(Gsub,m*allocated_cols*sizeof(double))) : (Dsub = (double*)mxRealloc(Dsub,n*allocated_cols*sizeof(double))) ; } /* append column to Gsub or Dsub */ if (batchomp) { memcpy(Gsub+i*m, G+pos*m, m*sizeof(double)); } else { memcpy(Dsub+i*n, D+pos*n, n*sizeof(double)); } /*** Cholesky update ***/ if (i==0) { *Lchol = 1; } else { /* incremental Cholesky decomposition: compute next row of Lchol */ if (standardomp) { matT_vec(1, Dsub, D+n*pos, tempvec1, n, i); /* compute tempvec1 := Dsub'*d where d is new atom */ addproftime(&pd, DtD_TIME); } else { vec_assign(tempvec1, Gsub+i*m, ind, i); /* extract tempvec1 := Gsub(ind,i) */ } backsubst('L', Lchol, tempvec1, tempvec2, n, i); /* compute tempvec2 = Lchol \ tempvec1 */ for (j=0; j<i; ++j) { /* write tempvec2 to end of Lchol */ Lchol[j*n+i] = tempvec2[j]; } /* compute Lchol(i,i) */ sum = 0; for (j=0; j<i; ++j) { /* compute sum of squares of last row without Lchol(i,i) */ sum += SQR(Lchol[j*n+i]); } if ( (1-sum) <= 1e-14 ) { /* Lchol(i,i) is zero => selected atoms are dependent */ break; } Lchol[i*n+i] = sqrt(1-sum); } addproftime(&pd, LCHOL_TIME); i++; /* perform orthogonal projection and compute sparse coefficients */ vec_assign(tempvec1, DtX + m*signum*DtX_specified, ind, i); /* extract tempvec1 = DtX(ind) */ cholsolve('L', Lchol, tempvec1, c, n, i); /* solve LL'c = tempvec1 for c */ addproftime(&pd, COMPCOEF_TIME); /* update alpha = D'*residual */ if (standardomp) { mat_vec(-1, Dsub, c, r, n, i); /* compute r := -Dsub*c */ vec_sum(1, x+n*signum, r, n); /* compute r := x+r */ /*memcpy(r, x+n*signum, n*sizeof(double)); /* assign r := x */ /*mat_vec1(-1, Dsub, c, 1, r, n, i); /* compute r := r-Dsub*c */ addproftime(&pd, COMPRES_TIME); matT_vec(1, D, r, alpha, n, m); /* compute alpha := D'*r */ addproftime(&pd, DtR_TIME); /* update residual norm */ if (erroromp) { resnorm = dotprod(r, r, n); addproftime(&pd, UPDATE_RESNORM_TIME); } } else { mat_vec(1, Gsub, c, tempvec1, m, i); /* compute tempvec1 := Gsub*c */ memcpy(alpha, DtX + m*signum*DtX_specified, m*sizeof(double)); /* set alpha = D'*x */ vec_sum(-1, tempvec1, alpha, m); /* compute alpha := alpha - tempvec1 */ addproftime(&pd, UPDATE_DtR_TIME); /* update residual norm */ if (erroromp) { vec_assign(tempvec2, tempvec1, ind, i); /* assign tempvec2 := tempvec1(ind) */ delta = dotprod(c,tempvec2,i); /* compute c'*tempvec2 */ resnorm = resnorm - delta + deltaprev; /* residual norm update */ deltaprev = delta; addproftime(&pd, UPDATE_RESNORM_TIME); } } } /*** generate output vector gamma ***/ if (gamma_mode == FULL_GAMMA) { /* write the coefs in c to their correct positions in gamma */ for (j=0; j<i; ++j) { gammaPr[m*signum + ind[j]] = c[j]; } } else { /* sort the coefs by index before writing them to gamma */ quicksort(ind,c,i); addproftime(&pd, INDEXSORT_TIME); /* gamma is full - reallocate */ if (gamma_count+i >= allocated_coefs) { while(gamma_count+i >= allocated_coefs) { allocated_coefs = (mwSize)(ceil(GAMMA_INC_FACTOR*allocated_coefs) + 1.01); } mxSetNzmax(Gamma, allocated_coefs); mxSetPr(Gamma, mxRealloc(gammaPr, allocated_coefs*sizeof(double))); mxSetIr(Gamma, mxRealloc(gammaIr, allocated_coefs*sizeof(mwIndex))); gammaPr = mxGetPr(Gamma); gammaIr = mxGetIr(Gamma); } /* append coefs to gamma and update the indices */ for (j=0; j<i; ++j) { gammaPr[gamma_count] = c[j]; gammaIr[gamma_count] = ind[j]; gamma_count++; } gammaJc[signum+1] = gammaJc[signum] + i; } /*** display status messages ***/ if (msg_delta>0 && (clock()-lastprint_time)/(double)CLOCKS_PER_SEC >= msg_delta) { lastprint_time = clock(); /* estimated remainig time */ secs2hms( ((L-signum-1)/(double)(signum+1)) * ((lastprint_time-starttime)/(double)CLOCKS_PER_SEC) , &hrs_remain, &mins_remain, &secs_remain); mexPrintf("omp: signal %d / %d, estimated remaining time: %02d:%02d:%05.2f\n", signum+1, L, hrs_remain, mins_remain, secs_remain); mexEvalString("drawnow;"); } } /* end omp */ /*** print final messages ***/ if (msg_delta>0) { mexPrintf("omp: signal %d / %d\n", signum, L); } if (profile) { printprofinfo(&pd, erroromp, batchomp, L); } /* free memory */ if (!DtX_specified) { mxFree(DtX); } if (standardomp) { mxFree(r); mxFree(Dsub); } else { mxFree(Gsub); } mxFree(tempvec2); mxFree(tempvec1); mxFree(Lchol); mxFree(c); mxFree(selected_atoms); mxFree(ind); mxFree(alpha); my.qGamma=Gamma; my.qtimes__atoms=times__atoms; /*return Gamma;*/ return my; }
/* read in a problem (in svmlight format) */ void read_problem(const char *filename, mxArray *plhs[]) { int elements, max_index, min_index, i, k; FILE *fp = fopen(filename,"r"); int l = 0; mwIndex *ir, *jc; /* double *labels, *samples; */ double *samples; if(fp == NULL) { mexPrintf("can't open input file %s\n",filename); fake_answer(plhs); return; } max_index = 0; min_index = 1; /* our index starts from 1 */ elements = 0; int index; double value; while(1) { /* label */ /* int index; double value; fscanf(fp,"%lf",&value); */ /* features */ while(1) { int c; do { c = getc(fp); if(c=='\n') goto out; if(c==EOF) goto eof; } while(isspace(c)); ungetc(c,fp); fscanf(fp,"%d:%lf",&index, &value); if (index < min_index) min_index = index; elements++; } out: if(index > max_index) max_index = index; l++; } eof: rewind(fp); /* y */ /* plhs[0] = mxCreateDoubleMatrix(l, 1, mxREAL); */ /* x^T */ if (min_index <= 0) /* plhs[1] = mxCreateSparse(max_index-min_index+1, l, elements, mxREAL); */ plhs[0] = mxCreateSparse(max_index-min_index+1, l, elements, mxREAL); else /* plhs[1] = mxCreateSparse(max_index, l, elements, mxREAL); */ plhs[0] = mxCreateSparse(max_index, l, elements, mxREAL); /* labels = mxGetPr(plhs[0]); */ /* samples = mxGetPr(plhs[1]); */ samples = mxGetPr(plhs[0]); /* ir = mxGetIr(plhs[1]); jc = mxGetJc(plhs[1]); */ ir = mxGetIr(plhs[0]); jc = mxGetJc(plhs[0]); k=0; for(i=0;i<l;i++) { jc[i] = k; /* fscanf(fp,"%lf",&labels[i]); */ while(1) { int c, index; do { c = getc(fp); if(c=='\n') goto out2; } while(isspace(c)); ungetc(c,fp); fscanf(fp,"%d:%lf",&index,&samples[k]); ir[k] = index - min_index; /* precomputed kernel has <index> start from 0 */ ++k; } out2: ; } jc[l] = k; fclose(fp); /* { mxArray *rhs[1], *lhs[1]; rhs[0] = plhs[0]; if(mexCallMATLAB(1, lhs, 1, rhs, "transpose")) { mexPrintf("Error: cannot transpose problem\n"); return; } plhs[0] = lhs[0]; } */ }
/* ************************************************************ PROCEDURE mexFunction - Entry for Matlab ************************************************************ */ void mexFunction(const int nlhs, mxArray *plhs[], const int nrhs, const mxArray *prhs[]) { const mxArray *L_FIELD; mxArray *myplhs[NPAROUT]; int m, i, j, inz, iwsiz, nsuper, tmpsiz, fwsiz, nskip, nadd, m1; double *fwork, *d, *skipPr, *orgd; const double *permPr,*xsuperPr,*Ppr,*absd; int *perm, *snode, *xsuper, *iwork, *xlindx, *skip, *skipJc; const int *LINir, *Pjc, *Pir; double canceltol, maxu, abstol; jcir L; char useAbsd, useDelay; /* ------------------------------------------------------------ Check for proper number of arguments blkchol(L,P, pars,absd) with nparinmin=2. ------------------------------------------------------------ */ if(nrhs < NPARINMIN) mexErrMsgTxt("blkchol requires more input arguments"); if(nlhs > NPAROUT) mexErrMsgTxt("blkchol produces less output arguments"); /* ------------------------------------------------------------ Get input matrix P to be factored. ------------------------------------------------------------ */ if( (m = mxGetM(P_IN)) != mxGetN(P_IN)) mexErrMsgTxt("P must be square"); if(!mxIsSparse(P_IN)) mexErrMsgTxt("P must be sparse"); Pjc = mxGetJc(P_IN); Pir = mxGetIr(P_IN); Ppr = mxGetPr(P_IN); /* ------------------------------------------------------------ Disassemble block Cholesky structure L ------------------------------------------------------------ */ if(!mxIsStruct(L_IN)) mexErrMsgTxt("Parameter `L' should be a structure."); if( (L_FIELD = mxGetField(L_IN,0,"perm")) == NULL) /* L.perm */ mexErrMsgTxt("Missing field L.perm."); if(m != mxGetM(L_FIELD) * mxGetN(L_FIELD)) mexErrMsgTxt("perm size mismatch"); permPr = mxGetPr(L_FIELD); if( (L_FIELD = mxGetField(L_IN,0,"L")) == NULL) /* L.L */ mexErrMsgTxt("Missing field L.L."); if( m != mxGetM(L_FIELD) || m != mxGetN(L_FIELD) ) mexErrMsgTxt("Size L.L mismatch."); if(!mxIsSparse(L_FIELD)) mexErrMsgTxt("L.L should be sparse."); L.jc = mxGetJc(L_FIELD); LINir = mxGetIr(L_FIELD); if( (L_FIELD = mxGetField(L_IN,0,"xsuper")) == NULL) /* L.xsuper */ mexErrMsgTxt("Missing field L.xsuper."); nsuper = mxGetM(L_FIELD) * mxGetN(L_FIELD) - 1; if( nsuper > m ) mexErrMsgTxt("Size L.xsuper mismatch."); xsuperPr = mxGetPr(L_FIELD); if( (L_FIELD = mxGetField(L_IN,0,"tmpsiz")) == NULL) /* L.tmpsiz */ mexErrMsgTxt("Missing field L.tmpsiz."); tmpsiz = mxGetScalar(L_FIELD); /* ------------------------------------------------------------ Disassemble pars structure: canceltol, maxu ------------------------------------------------------------ */ canceltol = 1E-15; /* supply with defaults */ maxu = 5E5; abstol = 1E-20; useAbsd = 0; useDelay = 0; if(nrhs >= NPARINMIN + 1){ /* 3rd argument = pars */ if(!mxIsStruct(PARS_IN)) mexErrMsgTxt("Parameter `pars' should be a structure."); if( (L_FIELD = mxGetField(PARS_IN,0,"canceltol")) != NULL) canceltol = mxGetScalar(L_FIELD); /* pars.canceltol */ if( (L_FIELD = mxGetField(PARS_IN,0,"maxu")) != NULL) maxu = mxGetScalar(L_FIELD); /* pars.maxu */ if( (L_FIELD = mxGetField(PARS_IN,0,"abstol")) != NULL){ abstol = mxGetScalar(L_FIELD); /* pars.abstol */ abstol = MAX(abstol, 0.0); } if( (L_FIELD = mxGetField(PARS_IN,0,"delay")) != NULL) useDelay = mxGetScalar(L_FIELD); /* pars.delay */ /* ------------------------------------------------------------ Get optional vector absd ------------------------------------------------------------ */ if(nrhs >= NPARIN){ useAbsd = 1; absd = mxGetPr(ABSD_IN); if(m != mxGetM(ABSD_IN) * mxGetN(ABSD_IN)) mexErrMsgTxt("absd size mismatch"); } } /* ------------------------------------------------------------ Create sparse output matrix L(m x m). ------------------------------------------------------------ */ L_OUT = mxCreateSparse(m,m, L.jc[m],mxREAL); L.ir = mxGetIr(L_OUT); L.pr = mxGetPr(L_OUT); memcpy(mxGetJc(L_OUT), L.jc, (m+1) * sizeof(int)); memcpy(L.ir, LINir, L.jc[m] * sizeof(int)); /* ------------------------------------------------------------ Create ouput vector d(m). ------------------------------------------------------------ */ D_OUT = mxCreateDoubleMatrix(m,1,mxREAL); d = mxGetPr(D_OUT); /* ------------------------------------------------------------ Compute required sizes of working arrays: iwsiz = 2*(m + nsuper). fwsiz = tmpsiz. ------------------------------------------------------------ */ iwsiz = MAX(2*(m+nsuper), 1); fwsiz = MAX(tmpsiz, 1); /* ------------------------------------------------------------ Allocate working arrays: integer: perm(m), snode(m), xsuper(nsuper+1), iwork(iwsiz), xlindx(m+1), skip(m), double: orgd(m), fwork(fwsiz). ------------------------------------------------------------ */ m1 = MAX(m,1); /* avoid alloc to 0 */ perm = (int *) mxCalloc(m1,sizeof(int)); snode = (int *) mxCalloc(m1,sizeof(int)); xsuper = (int *) mxCalloc(nsuper+1,sizeof(int)); iwork = (int *) mxCalloc(iwsiz,sizeof(int)); xlindx = (int *) mxCalloc(m+1,sizeof(int)); skip = (int *) mxCalloc(m1, sizeof(int)); orgd = (double *) mxCalloc(m1,sizeof(double)); fwork = (double *) mxCalloc(fwsiz,sizeof(double)); /* ------------------------------------------------------------ Convert PERM, XSUPER to integer and C-Style ------------------------------------------------------------ */ for(i = 0; i < m; i++){ j = permPr[i]; perm[i] = --j; } for(i = 0; i <= nsuper; i++){ j = xsuperPr[i]; xsuper[i] = --j; } /* ------------------------------------------------------------ Let L = tril(P(PERM,PERM)), uses orgd(m) as temp working storage. ------------------------------------------------------------ */ permuteP(L.jc,L.ir,L.pr, Pjc,Pir,Ppr, perm, orgd, m); /* ------------------------------------------------------------ If no orgd has been supplied, take orgd = diag(L on input) Otherwise, let orgd = absd(perm). ------------------------------------------------------------ */ if(useAbsd) for(j = 0; j < m; j++) orgd[j] = absd[perm[j]]; else for(j = 0; j < m; j++) orgd[j] = L.pr[L.jc[j]]; /* ------------------------------------------------------------ Create "snode" and "xlindx"; change L.ir to the compact subscript array (with xlindx), and do BLOCK SPARSE CHOLESKY. ------------------------------------------------------------ */ nskip = spchol(m, nsuper, xsuper, snode, xlindx, L.ir, orgd, L.jc, L.pr, d, perm, abstol, canceltol, maxu, skip, &nadd, iwsiz, iwork, fwsiz, fwork); if(nskip < 0) mexErrMsgTxt("Insufficient workspace in pblkchol"); /* ------------------------------------------------------------ Copy original row-indices from LINir to L.ir. ------------------------------------------------------------ */ memcpy(L.ir, LINir, L.jc[m] * sizeof(int)); /* ------------------------------------------------------------ Create output matrices skip = sparse([],[],[],m,1,nskip), diagadd = sparse([],[],[],m,1,nadd), ------------------------------------------------------------ */ SKIP_OUT = mxCreateSparse(m,1, MAX(1,nskip),mxREAL); memcpy(mxGetIr(SKIP_OUT), skip, nskip * sizeof(int)); skipJc = mxGetJc(SKIP_OUT); skipJc[0] = 0; skipJc[1] = nskip; skipPr = mxGetPr(SKIP_OUT); /* ------------------------------------------------------------ useDelay = 1 then L(:,i) is i-th column before ith pivot; useful for pivot-delaying strategy. (Fwslv(L, L(:,i)) still required.) ------------------------------------------------------------ */ if(useDelay == 1) for(j = 0; j < nskip; j++) skipPr[j] = 1.0; else for(j = 0; j < nskip; j++){ i = skip[j]; skipPr[j] = L.pr[L.jc[i]]; /* Set skipped l(:,i)=ei. */ L.pr[L.jc[i]] = 1.0; fzeros(L.pr+L.jc[i]+1,L.jc[i+1]-L.jc[i]-1); } DIAGADD_OUT = mxCreateSparse(m,1, MAX(1,nadd),mxREAL); memcpy(mxGetIr(DIAGADD_OUT), iwork, nadd * sizeof(int)); skipJc = mxGetJc(DIAGADD_OUT); skipJc[0] = 0; skipJc[1] = nadd; skipPr = mxGetPr(DIAGADD_OUT); for(j = 0; j < nadd; j++) skipPr[j] = orgd[iwork[j]]; /* ------------------------------------------------------------ Release working arrays. ------------------------------------------------------------ */ mxFree(fwork); mxFree(orgd); mxFree(skip); mxFree(xlindx); mxFree(iwork); mxFree(xsuper); mxFree(snode); mxFree(perm); /* ------------------------------------------------------------ Copy requested output parameters (at least 1), release others. ------------------------------------------------------------ */ i = MAX(nlhs, 1); memcpy(plhs,myplhs, i * sizeof(mxArray *)); for(; i < NPAROUT; i++) mxDestroyArray(myplhs[i]); }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray*prhs[]) { double *Pw_d, *pr_x, *Pw_z, *Pz_d; double beta; int *ir_x, prev_ir_x,*ir_Pw_d, *jc_x, *jc_Pw_d, *bad_index; int element_count, nTopics; int nn,ii,jj; unsigned int nWords, nDocs, indc, indx, indy, next_indx; bool temperedEM; /* sanity check of the parameters */ if ((!(mxIsSparse(prhs[0]))) ||(!((nrhs==3)||(nrhs==4)))) { printf("usage : C = mex_Estep(X,Pw_z,Pz_d)\n"); printf(" or : C = mex_Estep(X,Pw_z,Pz_d,beta)\n"); printf(" computes the normalization oonstant 'C' only for those values\n"); printf(" which are needed (nonzeros of X). If no 'beta' is given this function\n"); printf(" does plain EM, TEM otherwise\n"); return; } nWords = mxGetM(prhs[0]); nDocs = mxGetN(prhs[0]); nTopics = mxGetM(prhs[2]); jc_x = mxGetJc(prhs[0]); ir_x = mxGetIr(prhs[0]); pr_x = mxGetPr(prhs[0]); Pw_z = mxGetPr(prhs[1]); Pz_d = mxGetPr(prhs[2]); if (nrhs == 4) beta = *mxGetPr(prhs[3]); else beta = 1; temperedEM = beta!=1; /* sanity check of the parameters */ if ((! ( mxGetM(prhs[1]) == nWords))|| (!(mxGetN(prhs[1]) == nTopics) ) ){ printf("Dimensions mismatch of Pw_z, should be of size %d x %d\n",nWords,nTopics); return; } if ((!(mxGetM(prhs[2])==nTopics))||(!(mxGetN(prhs[2])==nDocs))){ printf("Dimensions mismatch of Pz_d, should be of size %d x %d\n",nTopics,nDocs); return; } /* create sparse output matrix */ plhs[0] = mxCreateSparse(nWords, nDocs, numnonzeros(prhs[0]), mxREAL); jc_Pw_d = mxGetJc(plhs[0]); ir_Pw_d = mxGetIr(plhs[0]); Pw_d = mxGetPr(plhs[0]); element_count = 0; jc_Pw_d[0] = 0; indx = 0; if (!(temperedEM)){ /* plain EM */ for (indc = 0; indc < 10; indc++) { jc_Pw_d[indc+1] = jc_Pw_d[indc]; next_indx = jc_x[indc]; /* next column index */ while (indx < next_indx) { /* while nonzero entries in the matrix */ jc_Pw_d[indc]++; /* point to next index */ /* copy element of sparse matrix */ ir_Pw_d[element_count] = ir_x[indx]; ii = indc; jj = ir_Pw_d[element_count]; Pw_d[element_count] = 0; /* sum over all topics */ for (nn=0;nn<nTopics;nn++) Pw_d[element_count] += (Pz_d[ii*nTopics+nn] * Pw_z[jj+nWords*nn]); printf("%d %d %d %d %f\n",jc_x[indc], ir_x[indx], jc_Pw_d[indc], ir_Pw_d[element_count],Pw_d[element_count]); indx++; element_count++; } } } else { /* tempered EM - see comments in plain EM */ for (indc = 0; indc < nDocs; indc++) { jc_Pw_d[indc+1] = jc_Pw_d[indc]; next_indx = jc_x[indc+1]; while (indx < next_indx) { jc_Pw_d[indc+1]++; ir_Pw_d[element_count] = ir_x[indx]; ii = indc; jj = ir_Pw_d[element_count]; Pw_d[element_count] = 0; for (nn=0;nn<nTopics;nn++) Pw_d[element_count] += pow(Pz_d[ii*nTopics+nn] * Pw_z[jj+nWords*nn],beta); indx++; element_count++; } } } }
void mexFunction( int nargout, mxArray *out[], int nargin, const mxArray *in[] ) { /* declare variables */ int nr, nc, np, total; int i, j, k, ix, iy, jx, jy; int *ir, *jc; int squareDistance; /* unsigned long *pi, *pj; */ unsigned int *pi, *pj; double *w; double temp,a1,a2,wij; double rMin; double sigmaX, sigmaIntensite,valeurMinW; double *image; /* check argument */ if (nargin<7) { mexErrMsgTxt("Four input arguments required"); } if (nargout>1) { mexErrMsgTxt("Too many output arguments"); } /* get edgel information */ nr = mxGetM(in[0]); nc = mxGetN(in[0]); np = nr * nc; image = mxGetPr(in[0]); /* get new index pair */ if (!mxIsUint32(in[1]) | !mxIsUint32(in[2])) { mexErrMsgTxt("Index pair shall be of type UINT32"); } if (mxGetM(in[2]) * mxGetN(in[2]) != np + 1) { mexErrMsgTxt("Wrong index representation"); } pi = mxGetData(in[1]); pj = mxGetData(in[2]); /* create output */ out[0] = mxCreateSparse(np,np,pj[np],mxREAL); if (out[0]==NULL) { mexErrMsgTxt("Not enough memory for the output matrix"); } w = mxGetPr(out[0]); ir = mxGetIr(out[0]); jc = mxGetJc(out[0]); rMin = mxGetScalar(in[3]); sigmaX = mxGetScalar(in[4]); sigmaIntensite= mxGetScalar(in[5]); valeurMinW = mxGetScalar(in[6]); a1 = 1.0/ (sigmaX*sigmaX); a2 = 1.0 / (sigmaIntensite*sigmaIntensite ); /* computation */ total = 0; for (j=0; j<np; j++) { jc[j] = total; jx = j / nr; /* col */ jy = j % nr; /* row */ for (k=pj[j]; k<pj[j+1]; k++) { i = pi[k]; if (i==j) { wij= 1; /*voir*/ } else { ix = i / nr; iy = i % nr; squareDistance = (ix-jx)*(ix-jx)+(iy-jy)*(iy-jy); temp = image[i]-image[j]; wij = exp(- squareDistance * a1 - temp*temp * a2 ); /*if(wij < valeurMinW) wij = -0.1;*/ } ir[total] = i; w[total] = wij; total = total + 1; } /* i */ } /* j */ jc[np] = total; }
void mexFunction ( int nlhs, mxArray *plhs [], int nrhs, const mxArray *prhs [] ) { /* Compressed column form of L, x and b */ mwIndex *Lp, *Ap, *Ai, *Up, *pp, *pi ; Int *Li, *Ui; mwIndex *Lp1, *Li1, *Up1, *Ui1 ; double *Lx, *Ax, *Ux, *px ; double *Lx1, *Ux1 ; double *t1, *t2 ; mwIndex anrow ; mwIndex ancol ; mwIndex lnnz ; mwIndex unnz ; mwIndex i ; mwIndex j ; mwIndex app_xnnz ; mwIndex memsize ; mwIndex result ; mwIndex *ws; /* workspace */ double *X ; /* space to scatter x */ mwIndex *pinv ; /* column permutation inverse */ if ( nlhs != 3 || nrhs < 3 ) { mexErrMsgTxt (" Incorrect number of arguments to sproductmex \n") ; } Ap = mxGetJc(prhs[0]) ; Ai = mxGetIr(prhs[0]) ; Ax = mxGetPr(prhs[0]) ; anrow = mxGetM (prhs[0]) ; ancol = mxGetN (prhs[0]) ; t1 = mxGetPr (prhs[1]) ; t2 = mxGetPr (prhs[2]) ; lnnz = (mwIndex)*t1 ; unnz = (mwIndex)*t2 ; /*printf("lnnz=%d unnz=%d\n", lnnz, unnz);*/ /* O(n) initialization */ ws = (mwIndex *) mxCalloc ( (ancol)+(4*anrow), sizeof(mwIndex)) ; X = (double *) mxCalloc ( 2*anrow, sizeof(double)) ; pinv = (mwIndex *) mxCalloc ( ancol, sizeof(mwIndex)) ; Lp = (mwIndex *) mxCalloc ( ancol+1, sizeof(mwIndex)) ; Li = (mwIndex *) mxCalloc ( lnnz, sizeof(Int)) ; Lx = (double *) mxCalloc ( lnnz, sizeof(double)) ; Up = (mwIndex *) mxCalloc ( ancol+1, sizeof(mwIndex)) ; Ui = (mwIndex *) mxCalloc ( unnz, sizeof(Int)) ; Ux = (double *) mxCalloc ( unnz, sizeof(double)) ; PRINT(("Calling basker \n")); result = basker_basker_l(Ap, Ai, Ax, anrow, ancol, ws , X, Lp, &Li, &Lx, Up, &Ui, &Ux, &lnnz, &unnz, pinv) ; PRINT(("Back in mex function %d \n",Lp[ancol])); if (result) { mxFree (X) ; mxFree (ws) ; mxFree (Lp) ; mxFree (Li) ; mxFree (Lx) ; mxFree (Up) ; mxFree (Ui) ; mxFree (Ux) ; mexErrMsgTxt (" basker failed \n") ; } plhs[0] = mxCreateSparse (anrow, ancol, Lp[ancol], mxREAL) ; Lp1 = mxGetJc (plhs[0]) ; Li1 = mxGetIr (plhs[0]) ; Lx1 = mxGetPr (plhs[0]) ; plhs[1] = mxCreateSparse (anrow, ancol, Up[ancol], mxREAL) ; Up1 = mxGetJc (plhs[1]) ; Ui1 = mxGetIr (plhs[1]) ; Ux1 = mxGetPr (plhs[1]) ; plhs[2] = mxCreateSparse (ancol, ancol, ancol, mxREAL) ; pp = mxGetJc (plhs[2]) ; pi = mxGetIr (plhs[2]) ; px = mxGetPr (plhs[2]) ; Lp1[0] = Lp[0]; for ( i = 0 ; i < ancol ; i++) { Lp1[i+1] = Lp[i+1]; for ( j = Lp[i] ; j < Lp[i+1] ; j++ ) { Li1[j] = Li[j]; Lx1[j] = Lx[j]; } } Up1[0] = Up[0]; for ( i = 0 ; i < ancol ; i++) { Up1[i+1] = Up[i+1]; for ( j = Up[i] ; j < Up[i+1] ; j++ ) { Ui1[j] = Ui[j]; Ux1[j] = Ux[j]; } } for ( i = 0 ; i < ancol ; i++) { pp[i] = i ; pi[ pinv[i] ] = i ; px[i] = 1 ; } pp[anrow] = ancol ; /*for ( i = 0 ; i < ancol ; i++) printf("pinv[%d] = %d\n", i, pinv[i]);*/ for ( i = 0 ; i < ancol ; i++) { for ( j = Lp1[i] ; j < Lp1[i+1] ; j++ ) { Li1[j] = pinv[Li1[j]] ; } } mxFree (X) ; mxFree (ws) ; mxFree (pinv) ; mxFree (Lp) ; mxFree (Li) ; mxFree (Lx) ; mxFree (Up) ; mxFree (Ui) ; mxFree (Ux) ; }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { double *srww_old, *srww_new,*srwp_old,*srdp_new, *probs, *DS_NEW, *WS_NEW, *WS_OLD, *SI_NEW, *WC_OLD, *PROBA, *C, *Z; double ALPHA,BETA, GAMMA0, GAMMA1, DELTA; int *irww_old, *irww_new, *jcww_old, *jcww_new, *irwp_old, *jcwp_old, *irdp_new, *jcdp_new; int *z,*d,*w, *s, *c, *sc, *order, *wp_old, *dp_new, *dp_new2, *ztot_old, *wtot_new, *wc_new; int W_NEW, W_OLD,T_NEW, T_OLD,D_NEW,NITER,SEED,OUTPUT, nzmax_new, nzmax_old, nzmaxdp_new, ntokens_new, ntokens_old; int i,j,cc,nt,n,wi,wipre,di, startindex, endindex, currentrow, count; int NSAMPLE, updatecols; /* Check for proper number of arguments. */ if (nrhs != 19) { mexErrMsgTxt("19 input arguments required"); } else if (nlhs != 4) { mexErrMsgTxt("4 output arguments required"); } // Syntax 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 // [ DP_NEW,C,Z,PROB ] = NewDocumentsLDACOL( WS_NEW , DS_NEW , SI_NEW , WW_NEW , T , N , NSAMPLE , ALPHA , BETA , GAMMA0, GAMMA1 , DELTA , SEED , OUTPUT , WW_OLD , WP_OLD , WC_OLD , WS_OLD, UPDATECOLS ); /* process the input arguments */ if (mxIsDouble( prhs[ 0 ] ) != 1) mexErrMsgTxt("WS_NEW must be double precision"); WS_NEW = mxGetPr(prhs[0]); ntokens_new = mxGetM( prhs[ 0 ] ) * mxGetN( prhs[ 0 ] ); if (mxIsDouble( prhs[ 1 ] ) != 1) mexErrMsgTxt("DS_NEW must be double precision"); DS_NEW = mxGetPr(prhs[1]); if (mxIsDouble( prhs[ 2 ] ) != 1) mexErrMsgTxt("SI_NEW must be double precision"); SI_NEW = mxGetPr(prhs[2]); if ((mxIsSparse( prhs[ 3 ] ) != 1) || (mxIsDouble( prhs[ 3 ] ) != 1)) mexErrMsgTxt("WW_NEW collocation matrix must be a sparse double precision matrix"); /* dealing with sparse array WW_NEW */ srww_new = mxGetPr(prhs[3]); irww_new = mxGetIr(prhs[3]); jcww_new = mxGetJc(prhs[3]); nzmax_new = mxGetNzmax(prhs[3]); W_NEW = mxGetM( prhs[3] ); if (mxGetN( prhs[3] ) != W_NEW) mexErrMsgTxt("WW_NEW matrix should be square"); D_NEW = 0; for (i=0; i<ntokens_new; i++) { if (DS_NEW[ i ] > D_NEW) D_NEW = (int) DS_NEW[ i ]; if (WS_NEW[ i ] > W_NEW) mexErrMsgTxt("Some word tokens in WS_NEW stream exceed number of word types in WW_NEW matrix"); } T_NEW = (int) mxGetScalar(prhs[4]); if (T_NEW<=0) mexErrMsgTxt("Number of topics must be greater than zero"); NITER = (int) mxGetScalar(prhs[5]); if (NITER<0) mexErrMsgTxt("Number of iterations must be greater than zero"); NSAMPLE = (int) mxGetScalar(prhs[6]); if (NSAMPLE<0) mexErrMsgTxt("Number of samples must be greater than zero"); ALPHA = (double) mxGetScalar(prhs[7]); if (ALPHA<=0) mexErrMsgTxt("ALPHA must be greater than zero"); BETA = (double) mxGetScalar(prhs[8]); if (BETA<=0) mexErrMsgTxt("BETA must be greater than zero"); GAMMA0 = (double) mxGetScalar(prhs[9]); if (GAMMA0<=0) mexErrMsgTxt("GAMMA0 must be greater than zero"); GAMMA1 = (double) mxGetScalar(prhs[10]); if (GAMMA1<=0) mexErrMsgTxt("GAMMA1 must be greater than zero"); DELTA = (double) mxGetScalar(prhs[11]); if (DELTA<=0) mexErrMsgTxt("DELTA must be greater than zero"); SEED = (int) mxGetScalar(prhs[12]); // set the seed of the random number generator OUTPUT = (int) mxGetScalar(prhs[13]); // dealing with sparse array WW_OLD if ((mxIsSparse( prhs[ 14 ] ) != 1) || (mxIsDouble( prhs[ 14 ] ) != 1)) mexErrMsgTxt("WW_OLD collocation frequency matrix must be a sparse double precision matrix"); srww_old = mxGetPr(prhs[14]); irww_old = mxGetIr(prhs[14]); jcww_old = mxGetJc(prhs[14]); nzmax_old = mxGetNzmax(prhs[14]); W_OLD = mxGetM( prhs[14] ); if (W_OLD != W_NEW) mexErrMsgTxt("WW_OLD and WW_NEW matrices have different dimensions"); if (mxGetN( prhs[14] ) != W_NEW) mexErrMsgTxt("WW_OLD matrix should be square"); // dealing with sparse array WP_OLD if ((mxIsSparse( prhs[ 15 ] ) != 1) || (mxIsDouble( prhs[ 15 ] ) != 1)) mexErrMsgTxt("WP_OLD topic-word matrix must be a sparse double precision matrix"); srwp_old = mxGetPr(prhs[15]); irwp_old = mxGetIr(prhs[15]); jcwp_old = mxGetJc(prhs[15]); if (mxGetM( prhs[15] ) != W_NEW) mexErrMsgTxt("Number of words in WP_OLD matrix does not match WW_NEW number of words"); if (mxGetN( prhs[15] ) != T_NEW) mexErrMsgTxt("Number of topics in WP_OLD matrix does not match given number of topics"); WC_OLD = mxGetPr( prhs[ 16 ]); if ((mxGetM( prhs[16] ) * mxGetN( prhs[16] )) != W_NEW ) mexErrMsgTxt("Number of words in WC_OLD matrix does not match WW_NEW number of words"); if (mxIsDouble( prhs[ 17 ] ) != 1) mexErrMsgTxt("WS_OLD must be double precision"); WS_OLD = mxGetPr(prhs[ 17 ]); ntokens_old = mxGetM( prhs[ 17 ] ) * mxGetN( prhs[ 17 ] ); updatecols = (int) mxGetScalar(prhs[18]); // seeding seedMT( 1 + SEED * 2 ); // seeding only works on uneven numbers /* allocate memory */ z = (int *) mxCalloc( ntokens_new , sizeof( int )); d = (int *) mxCalloc( ntokens_new , sizeof( int )); w = (int *) mxCalloc( ntokens_new , sizeof( int )); s = (int *) mxCalloc( ntokens_new , sizeof( int )); c = (int *) mxCalloc( ntokens_new , sizeof( int )); sc = (int *) mxCalloc( ntokens_new , sizeof( int )); for (i=0; i<ntokens_new; i++) w[ i ] = (int) (WS_NEW[ i ] - 1); // Matlab indexing not zero based for (i=0; i<ntokens_new; i++) d[ i ] = (int) (DS_NEW[ i ] - 1); // Matlab indexing not zero based for (i=0; i<ntokens_new; i++) s[ i ] = (int) SI_NEW[ i ]; order = (int *) mxCalloc( ntokens_new , sizeof( int )); wp_old = (int *) mxCalloc( T_NEW*W_NEW , sizeof( int )); dp_new = (int *) mxCalloc( T_NEW*D_NEW , sizeof( int )); dp_new2 = (int *) mxCalloc( T_NEW*D_NEW , sizeof( int )); wc_new = (int *) mxCalloc( W_NEW , sizeof( int )); ztot_old = (int *) mxCalloc( T_NEW , sizeof( int )); wtot_new = (int *) mxCalloc( W_NEW , sizeof( int )); probs = (double *) mxCalloc( T_NEW , sizeof( double )); // FILL IN WTOT_NEW with OLD COUNTS for (i=0; i<ntokens_old; i++) { j = (int) WS_OLD[ i ] - 1; wtot_new[ j ]++; // calculate number of words of each type } // FILL IN WTOT_NEW with NEW COUNTS if (updatecols==1) for (i=0; i<ntokens_new; i++) { j = w[ i ]; wtot_new[ j ]++; // calculate number of words of each type } // FILL IN WC WITH COUNTS FROM OLD SET for (i=0; i<W_NEW; i++) { wc_new[ i ] = (int) WC_OLD[ i ]; } // FILL IN wp_old and ztot_old for (j=0; j<T_NEW; j++) { startindex = *( jcwp_old + j ); endindex = *( jcwp_old + j + 1 ) - 1; for (i=startindex; i<=endindex; i++) { currentrow = *( irwp_old + i ); count = (int) *( srwp_old + i ); wp_old[ j + currentrow*T_NEW ] = count; ztot_old[ j ] += count; } } // FILL IN SC COUNTS for (i=1; i<ntokens_new; i++) // start with second item { wi = w[ i ]; // word index count = 0; // what is the previous word? wipre = w[ i-1 ]; // calculate how many times the current word follows the previous word IN THE OLD DOCUMENT SET startindex = *( jcww_old + wipre ); // look up start and end index for column wipre in WW_OLD matrix endindex = *( jcww_old + wipre + 1 ) - 1; for (j=startindex; j<=endindex; j++) { currentrow = *( irww_old + j ); if (currentrow == wi) count = (int) *( srww_old + j ); } // calculate how many times the current word follows the previous word IN THE NEW DOCUMENT SET if (updatecols==1) { startindex = *( jcww_new + wipre ); // look up start and end index for column wipre in WW_NEW matrix endindex = *( jcww_new + wipre + 1 ) - 1; for (j=startindex; j<=endindex; j++) { currentrow = *( irww_new + j ); if (currentrow == wi) count += (int) *( srww_new + j ); // add the count to what was there previously !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! } } sc[ i ] = count; } /*for (i=0; i<10; i++) { mexPrintf( "i=%4d w[i]=%3d d[i]=%d z[i]=%d s[i]=%d\n" , i , w[i] , d[i] , z[i] , s[i] ); }*/ if (OUTPUT==2) { mexPrintf( "Running NEW DOCUMENT LDA COL Gibbs Sampler Version 1.0\n" ); mexPrintf( "Arguments:\n" ); mexPrintf( "\tNumber of words W = %d\n" , W_NEW ); mexPrintf( "\tNumber of docs D = %d\n" , D_NEW ); mexPrintf( "\tNumber of topics T = %d\n" , T_NEW ); mexPrintf( "\tNumber of iterations N = %d\n" , NITER ); mexPrintf( "\tNumber of samples S = %d\n" , NSAMPLE ); mexPrintf( "\tHyperparameter ALPHA = %4.4f\n" , ALPHA ); mexPrintf( "\tHyperparameter BETA = %4.4f\n" , BETA ); mexPrintf( "\tHyperparameter GAMMA0 = %4.4f\n" , GAMMA0 ); mexPrintf( "\tHyperparameter GAMMA1 = %4.4f\n" , GAMMA1 ); mexPrintf( "\tHyperparameter DELTA = %4.4f\n" , DELTA ); mexPrintf( "\tSeed number = %d\n" , SEED ); mexPrintf( "\tNumber of tokens = %d\n" , ntokens_new ); mexPrintf( "\tUpdating collocation counts with new documents? = %d\n" , updatecols ); } /* --------------------------------------------- create the PROB vector -----------------------------------------------*/ plhs[ 3 ] = mxCreateDoubleMatrix( ntokens_new , 1 , mxREAL ); PROBA = mxGetPr( plhs[ 3 ] ); /* run the model */ GibbsSamplerLDACOL( ALPHA, BETA, GAMMA0,GAMMA1,DELTA, W_NEW, T_NEW, D_NEW, NITER, NSAMPLE , OUTPUT, ntokens_new, z, d, w, s, c, sc, wp_old, dp_new, dp_new2, ztot_old, wtot_new, order, probs, wc_new , PROBA , updatecols ); /* --------------------------------------------- convert the full DP matrix into a sparse matrix -----------------------------------------------*/ nzmaxdp_new = 0; for (i=0; i<D_NEW; i++) { for (j=0; j<T_NEW; j++) nzmaxdp_new += (int) ( *( dp_new2 + j + i*T_NEW )) > 0; // !!!!!!!!!!!!!!!!!! copy from dp_new2 } if (OUTPUT==2) { mexPrintf( "Constructing sparse output matrix dp_new\n" ); mexPrintf( "Number of nonzero entries for DP = %d\n" , nzmaxdp_new ); } plhs[0] = mxCreateSparse( D_NEW,T_NEW,nzmaxdp_new,mxREAL); srdp_new = mxGetPr(plhs[0]); irdp_new = mxGetIr(plhs[0]); jcdp_new = mxGetJc(plhs[0]); n = 0; for (j=0; j<T_NEW; j++) { *( jcdp_new + j ) = n; for (i=0; i<D_NEW; i++) { cc = (int) *( dp_new2 + i*T_NEW + j ); // !!!!!!!!!!!!!!!!!! copy from dp_new2 if (cc >0) { *( srdp_new + n ) = cc; *( irdp_new + n ) = i; n++; } } } *( jcdp_new + T_NEW ) = n; /* --------------------------------------------- create the C route vector -----------------------------------------------*/ plhs[ 1 ] = mxCreateDoubleMatrix( ntokens_new , 1 , mxREAL ); C = mxGetPr( plhs[ 1 ] ); for (i=0; i<ntokens_new; i++) C[ i ] = (double) c[ i ]; /* --------------------------------------------- create the topic assignment vector -----------------------------------------------*/ plhs[ 2 ] = mxCreateDoubleMatrix( ntokens_new , 1 , mxREAL ); Z = mxGetPr( plhs[ 2 ] ); for (i=0; i<ntokens_new; i++) Z[ i ] = (double) z[ i ] + 1; }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { mwIndex *ir, *jc; double *pr; char *filename, *pch, mystring[MAX]; int buflen, d, i, D, W, NNZ; FILE *doc; /* Check for proper number of arguments. */ if (nrhs != 1) { mexErrMsgTxt("Only one input argument required"); } else if (nlhs != 1) { mexErrMsgTxt("Only one output argument required"); } // open document file buflen = (int) (1 + (mxGetM(prhs[0])*mxGetN(prhs[0]))); filename = (char *) mxCalloc(buflen, sizeof(char)); mxGetString( prhs[0], filename, buflen); doc = fopen(filename, "r"); if (doc == NULL) mexErrMsgTxt("Text file cannot be found."); // read the file header fgets(mystring , sizeof(mystring) , doc); if ((mystring != NULL) && (atoi(mystring) != 0)) { D = atoi(mystring); mexPrintf( "#Document: %d \n", D); } else { mexErrMsgTxt("File header error."); } fgets(mystring , sizeof(mystring) , doc); if ((mystring != NULL) && (atoi(mystring) != 0)){ W = atoi(mystring); mexPrintf( "#Vocabulary: %d \n", W); } else { mexErrMsgTxt("File header error."); } fgets(mystring , sizeof(mystring) , doc); if ((mystring != NULL) && (atoi(mystring) != 0)){ NNZ = atoi(mystring); mexPrintf( "#NNZ: %d \n", NNZ); } else { mexErrMsgTxt("File header error."); } // create W x D sparse matrix for data plhs[0] = mxCreateSparse(W, D, NNZ, mxREAL); pr = (double *) mxGetPr(plhs[0]); ir = mxGetIr(plhs[0]); jc = mxGetJc(plhs[0]); // copy data to sparse matrix i = 0; jc[0] = 0; while (fgets(mystring , sizeof(mystring) , doc) != NULL) { pch = strtok(mystring, " "); if ((pch != NULL) && (atoi(pch) != 0)) { d = atoi(pch); pch = strtok(NULL, " "); ir[i] = atoi(pch) - 1; pch = strtok(NULL, " "); pr[i] = atoi(pch); i++; jc[d] = i; } } fclose(doc); }
/* ************************************************************ PROCEDURE mexFunction - Entry for Matlab [perm,dz] = incorder(At,Ajc1,ifirst) ************************************************************ */ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { mxArray *myplhs[NPAROUT]; mwIndex i, m, firstPSD, lenud, iwsiz, lenfull, maxnnz; mwIndex *iwork, *Atjc1, *Ajc, *Air, *perm; const mwIndex *Atjc2, *Atir; double *permPr; const double *Ajc1Pr; char *cwork; jcir dz; /* ------------------------------------------------------------ Check for proper number of arguments ------------------------------------------------------------ */ mxAssert(nrhs >= NPARINMIN, "incorder requires more input arguments."); mxAssert(nlhs <= NPAROUT, "incorder produces less output arguments."); /* -------------------------------------------------- GET STATISTICS: -------------------------------------------------- */ if(nrhs == NPARIN){ firstPSD = (mwIndex) mxGetScalar(IFIRST_IN); /* double to mwIndex */ mxAssert(firstPSD>0,""); --firstPSD; /* Fortran to C */ } else firstPSD = 0; /* default: use all subscripts */ lenfull = mxGetM(AT_IN); lenud = lenfull - firstPSD; /* -------------------------------------------------- Check size At, and get At. -------------------------------------------------- */ mxAssert(mxIsSparse(AT_IN), "At must be a sparse matrix."); m = mxGetN(AT_IN); Atjc2 = mxGetJc(AT_IN)+1; /* points to end of constraint */ Atir = mxGetIr(AT_IN); /* subscripts */ /* ------------------------------------------------------------ ALLOCATE WORKING arrays: mwIndex Atjc1(m), Ajc(1+lenud), Air(maxnnz), perm(m), iwork(iwsiz). iwsiz = MAX(lenud,1+m) char cwork(lenud). ------------------------------------------------------------ */ Atjc1 = (mwIndex *) mxCalloc(MAX(m,1), sizeof(mwIndex)); Ajc = (mwIndex *) mxCalloc(1+lenud, sizeof(mwIndex)); perm = (mwIndex *) mxCalloc(MAX(1,m), sizeof(mwIndex)); iwsiz = MAX(lenud, 1 + m); iwork = (mwIndex *) mxCalloc(iwsiz, sizeof(mwIndex)); /* iwork(iwsiz) */ cwork = (char *) mxCalloc(MAX(1,lenud), sizeof(char)); /* ------------------------------------------------------------ Get input AJc1 ------------------------------------------------------------ */ if(nrhs == NPARIN){ Ajc1Pr = mxGetPr(AJC1_IN); mxAssert(mxGetM(AJC1_IN) * mxGetN(AJC1_IN) >= m, "Ajc1 size mismatch"); /* ------------------------------------------------------------ Double to mwIndex: Atjc1 ------------------------------------------------------------ */ for(i = 0; i < m; i++) Atjc1[i] = (mwIndex) Ajc1Pr[i]; /* double to mwIndex */ /* ------------------------------------------------------------ Let maxnnz = number of PSD nonzeros = sum(Atjc2-Atjc1) ------------------------------------------------------------ */ maxnnz = 0; for(i = 0; i < m; i++) maxnnz += Atjc2[i] - Atjc1[i]; } else{ memcpy(Atjc1, mxGetJc(AT_IN), m * sizeof(mwIndex)); /* default column start */ maxnnz = Atjc2[m-1]; /* maxnnz = nnz(At) */ } /* ------------------------------------------------------------ ALLOCATE WORKING array mwIndex Air(maxnnz) ------------------------------------------------------------ */ Air = (mwIndex *) mxCalloc(MAX(1,maxnnz), sizeof(mwIndex)); /* ------------------------------------------------------------ CREATE OUTPUT ARRAYS PERM(m) and DZ=sparse(lenfull,m,lenud). ------------------------------------------------------------ */ PERM_OUT = mxCreateDoubleMatrix(m,(mwSize)1,mxREAL); permPr = mxGetPr(PERM_OUT); DZ_OUT = mxCreateSparse(lenfull,m,lenud,mxREAL); dz.jc = mxGetJc(DZ_OUT); dz.ir = mxGetIr(DZ_OUT); /* ------------------------------------------------------------ Let (Ajc,Air) := At(first:end,:)', the transpose of PSD-part. Uses iwork(lenud) ------------------------------------------------------------ */ spPartTransp(Air,Ajc, Atir,Atjc1,Atjc2, firstPSD,lenfull, m,iwork); /* ------------------------------------------------------------ The main job: greedy order of columns of At ------------------------------------------------------------ */ incorder(perm, dz.jc,dz.ir, Atjc1,Atjc2,Atir, Ajc,Air, m, firstPSD,lenud, iwork, cwork); /* uses iwork(m+1) */ /* ------------------------------------------------------------ REALLOC (shrink) dz to dz.jc[m] nonzeros. ------------------------------------------------------------ */ mxAssert(dz.jc[m] <= lenud,""); maxnnz = MAX(1,dz.jc[m]); /* avoid realloc to 0 */ if((dz.ir = (mwIndex *) mxRealloc(dz.ir, maxnnz * sizeof(mwIndex))) == NULL) mexErrMsgTxt("Memory allocation error"); if((dz.pr = (double *) mxRealloc(mxGetPr(DZ_OUT), maxnnz*sizeof(double))) == NULL) mexErrMsgTxt("Memory allocation error"); mxSetPr(DZ_OUT,dz.pr); mxSetIr(DZ_OUT,dz.ir); mxSetNzmax(DZ_OUT,maxnnz); for(i = 0; i < maxnnz; i++) dz.pr[i] = 1.0; /* ------------------------------------------------------------ Convert C-mwIndex to Fortran-double ------------------------------------------------------------ */ for(i = 0; i < m; i++) permPr[i] = perm[i] + 1.0; /* ------------------------------------------------------------ Release working arrays ------------------------------------------------------------ */ mxFree(cwork); mxFree(iwork); mxFree(perm); mxFree(Air); mxFree(Ajc); mxFree(Atjc1); /* ------------------------------------------------------------ Copy requested output parameters (at least 1), release others. ------------------------------------------------------------ */ i = MAX(nlhs, 1); memcpy(plhs,myplhs, i * sizeof(mxArray *)); for(; i < NPAROUT; i++) mxDestroyArray(myplhs[i]); }
/* ************************************************************ PROCEDURE mexFunction - Entry for Matlab y = bwblksolve(L,b, [y]) y(L.fullperm) = L.L' \ b ************************************************************ */ void mexFunction(const int nlhs, mxArray *plhs[], const int nrhs, const mxArray *prhs[]) { const mxArray *L_FIELD; mwIndex m,n, j, k, nsuper, inz; double *y, *fwork; const double *permPr, *b, *xsuperPr; const mwIndex *yjc, *yir, *bjc, *bir; mwIndex *perm, *xsuper, *iwork, *snode; jcir L; char bissparse; /* ------------------------------------------------------------ Check for proper number of arguments ------------------------------------------------------------ */ mxAssert(nrhs >= MINNPARIN, "fwblkslv requires more input arguments."); mxAssert(nlhs == 1, "fwblkslv generates only 1 output argument."); /* ------------------------------------------------------------ Disassemble block Cholesky structure L ------------------------------------------------------------ */ mxAssert(mxIsStruct(L_IN), "Parameter `L' should be a structure."); L_FIELD = mxGetField(L_IN,(mwIndex)0,"perm"); /* L.perm */ mxAssert( L_FIELD != NULL, "Missing field L.perm."); m = mxGetM(L_FIELD) * mxGetN(L_FIELD); permPr = mxGetPr(L_FIELD); L_FIELD = mxGetField(L_IN,(mwIndex)0,"L"); /* L.L */ mxAssert( L_FIELD != NULL, "Missing field L.L."); mxAssert( m == mxGetM(L_FIELD) && m == mxGetN(L_FIELD), "Size L.L mismatch."); mxAssert(mxIsSparse(L_FIELD), "L.L should be sparse."); L.jc = mxGetJc(L_FIELD); L.ir = mxGetIr(L_FIELD); L.pr = mxGetPr(L_FIELD); L_FIELD = mxGetField(L_IN,(mwIndex)0,"xsuper"); /* L.xsuper */ mxAssert( L_FIELD != NULL, "Missing field L.xsuper."); nsuper = mxGetM(L_FIELD) * mxGetN(L_FIELD) - 1; mxAssert( nsuper <= m, "Size L.xsuper mismatch."); xsuperPr = mxGetPr(L_FIELD); /* ------------------------------------------------------------ Get rhs matrix b. If it is sparse, then we also need the sparsity structure of y. ------------------------------------------------------------ */ b = mxGetPr(B_IN); mxAssert( mxGetM(B_IN) == m, "Size mismatch b."); n = mxGetN(B_IN); if( (bissparse = mxIsSparse(B_IN)) ){ bjc = mxGetJc(B_IN); bir = mxGetIr(B_IN); mxAssert(nrhs >= NPARIN, "bwblkslv requires more inputs in case of sparse b."); mxAssert(mxGetM(Y_IN) == m && mxGetN(Y_IN) == n, "Size mismatch y."); mxAssert(mxIsSparse(Y_IN), "y should be sparse."); } /* ------------------------------------------------------------ Allocate output y. If bissparse, then Y_IN gives the sparsity structure. ------------------------------------------------------------ */ if(!bissparse) Y_OUT = mxCreateDoubleMatrix(m, n, mxREAL); else{ yjc = mxGetJc(Y_IN); yir = mxGetIr(Y_IN); Y_OUT = mxCreateSparse(m,n, yjc[n],mxREAL); memcpy(mxGetJc(Y_OUT), yjc, (n+1) * sizeof(mwIndex)); memcpy(mxGetIr(Y_OUT), yir, yjc[n] * sizeof(mwIndex)); } y = mxGetPr(Y_OUT); /* ------------------------------------------------------------ Allocate working arrays ------------------------------------------------------------ */ fwork = (double *) mxCalloc(m, sizeof(double)); iwork = (mwIndex *) mxCalloc(2*m+nsuper+1, sizeof(mwIndex)); perm = iwork; /* m */ xsuper = iwork + m; /*nsuper+1*/ snode = xsuper + (nsuper+1); /* m */ /* ------------------------------------------------------------ Convert real to integer array, and from Fortran to C style. ------------------------------------------------------------ */ for(k = 0; k < m; k++) perm[k] = permPr[k] - 1; for(k = 0; k <= nsuper; k++) xsuper[k] = xsuperPr[k] - 1; /* ------------------------------------------------------------ In case of sparse b, we also create snode, which maps each subnode to the supernode containing it. ------------------------------------------------------------ */ if(bissparse) for(j = 0, k = 0; k < nsuper; k++) while(j < xsuper[k+1]) snode[j++] = k; /* ------------------------------------------------------------ The actual job is done here: y(perm) = L'\b. ------------------------------------------------------------ */ if(!bissparse) for(j = 0; j < n; j++){ memcpy(fwork,b, m * sizeof(double)); bwsolve(fwork,L.jc,L.ir,L.pr,xsuper,nsuper,y); /* y(m) as work */ for(k = 0; k < m; k++) /* y(perm) = fwork */ y[perm[k]] = fwork[k]; y += m; b += m; } else{ /* sparse y,b: don't use perm */ fzeros(fwork,m); for(j = 0; j < n; j++){ inz = yjc[j]; for(k = bjc[j]; k < bjc[j+1]; k++) /* fwork = b */ fwork[bir[k]] = b[k]; selbwsolve(fwork,L.jc,L.ir,L.pr,xsuper,nsuper, snode, yir+inz,yjc[j+1]-inz); for(k = inz; k < yjc[j+1]; k++) y[k] = fwork[yir[k]]; for(k = inz; k < yjc[j+1]; k++) /* fwork = all-0 */ fwork[yir[k]] = 0.0; } } /* ------------------------------------------------------------ RELEASE WORKING ARRAYS. ------------------------------------------------------------ */ mxFree(fwork); mxFree(iwork); }
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { mxArray *rhs[2]; mxArray *blk_cell_pr, *A_cell_pr; double *A, *B, *blksize; mwIndex *irA, *jcA, *irB, *jcB; mwIndex *cumblksize, *blknnz; mwSize iscellA, mblk, mA, nA, m1, n1, rowidx, colidx, isspA, isspB; mwIndex subs[2]; mwSize nsubs=2; mwSize n, n2, k, nsub, index, numblk, NZmax; double ir2=1/sqrt(2); /* CHECK FOR PROPER NUMBER OF ARGUMENTS */ if (nrhs < 2){ mexErrMsgTxt("mexsmat: requires at least 2 input arguments."); } else if (nlhs>1){ mexErrMsgTxt("mexsmat: requires 1 output argument."); } /* CHECK THE DIMENSIONS */ iscellA = mxIsCell(prhs[1]); if (iscellA) { mA = mxGetM(prhs[1]); nA = mxGetN(prhs[1]); } else { mA = 1; nA = 1; } if (mxGetM(prhs[0]) != mA) { mexErrMsgTxt("mexsmat: blk and Avec not compatible"); } /***** main body *****/ if (nrhs > 3) {rowidx = (mwSize)*mxGetPr(prhs[3]); } else {rowidx = 1;} if (rowidx > mA) { mexErrMsgTxt("mexsmat: rowidx exceeds size(Avec,1)."); } subs[0] = rowidx-1; /* subtract 1 to adjust for Matlab index */ subs[1] = 1; index = mxCalcSingleSubscript(prhs[0],nsubs,subs); blk_cell_pr = mxGetCell(prhs[0],index); if (blk_cell_pr == NULL) { mexErrMsgTxt("mexsmat: blk not properly specified"); } numblk = mxGetN(blk_cell_pr); blksize = mxGetPr(blk_cell_pr); cumblksize = mxCalloc(numblk+1,sizeof(mwSize)); blknnz = mxCalloc(numblk+1,sizeof(mwSize)); cumblksize[0] = 0; blknnz[0] = 0; n = 0; n2 = 0; for (k=0; k<numblk; ++k) { nsub = (mwSize) blksize[k]; n += nsub; n2 += nsub*(nsub+1)/2; cumblksize[k+1] = n; blknnz[k+1] = n2; } /***** assign pomwSizeers *****/ if (iscellA) { subs[0] = rowidx-1; subs[1] = 0; index = mxCalcSingleSubscript(prhs[1],nsubs,subs); A_cell_pr = mxGetCell(prhs[1],index); A = mxGetPr(A_cell_pr); m1 = mxGetM(A_cell_pr); n1 = mxGetN(A_cell_pr); isspA = mxIsSparse(A_cell_pr); if (isspA) { irA = mxGetIr(A_cell_pr); jcA = mxGetJc(A_cell_pr); } } else { A = mxGetPr(prhs[1]); m1 = mxGetM(prhs[1]); n1 = mxGetN(prhs[1]); isspA = mxIsSparse(prhs[1]); if (isspA) { irA = mxGetIr(prhs[1]); jcA = mxGetJc(prhs[1]); } } if (numblk > 1) { isspB = 1; } else { if (nrhs > 2) {isspB = (mwSize)*mxGetPr(prhs[2]);} else {isspB = isspA;} } if (nrhs > 4) {colidx = (mwSize)*mxGetPr(prhs[4]) -1;} else {colidx = 0;} if (colidx > n1) { mexErrMsgTxt("mexsmat: colidx exceeds size(Avec,2)."); } /***** create return argument *****/ if (isspB) { if (isspA) { NZmax = jcA[colidx+1]-jcA[colidx]; } else { NZmax = blknnz[numblk]; } rhs[0] = mxCreateSparse(n,n,2*NZmax,mxREAL); B = mxGetPr(rhs[0]); irB = mxGetIr(rhs[0]); jcB = mxGetJc(rhs[0]); } else { plhs[0] = mxCreateDoubleMatrix(n,n,mxREAL); B = mxGetPr(plhs[0]); } /***** Do the computations in a subroutine *****/ if (numblk == 1) { smat1(n,ir2,A,irA,jcA,isspA,m1,colidx,B,irB,jcB,isspB); } else { smat2(n,numblk,cumblksize,blknnz,ir2,A,irA,jcA,isspA,m1,colidx,B,irB,jcB,isspB); } if (isspB) { /*** if isspB, (actual B) = B+B' ****/ mexCallMATLAB(1, &rhs[1], 1, &rhs[0], "transpose"); mexCallMATLAB(1, &plhs[0],2, rhs, "+"); mxDestroyArray(*rhs); } return; }
m = mxGetM(prhs[0]); n = mxGetN(prhs[0]); pr = mxGetPr(prhs[0]); pi = mxGetPi(prhs[0]); cmplx = (pi == NULL ? 0 : 1); /* Allocate space for sparse matrix. * NOTE: Assume at most 20% of the data is sparse. Use ceil * to cause it to round up. */ percent_sparse = 0.2; nzmax = (int)ceil((double)m*(double)n*percent_sparse); plhs[0] = mxCreateSparse(m,n,nzmax,cmplx); sr = mxGetPr(plhs[0]); si = mxGetPi(plhs[0]); irs = mxGetIr(plhs[0]); jcs = mxGetJc(plhs[0]); /* Copy nonzeros. */ k = 0; isfull = 0; for (j = 0; (j < n); j++) { int i; jcs[j] = k; for (i = 0; (i < m); i++) { if (IsNonZero(pr[i]) || (cmplx && IsNonZero(pi[i]))) { /* Check to see if non-zero element will fit in
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { double *srwp, *srdp, *srmp, *probs, *d, *w, *ZIN, *XIN, *Z, *X; double ALPHA,BETA, GAMMA; mwIndex *irwp, *jcwp, *irdp, *jcdp, *irmp, *jcmp; int *z,*x, *wp, *mp, *dp, *ztot, *mtot, *stot, *sp, *first, *second, *third; int W,T,S,SINPUT,D,NN,SEED,OUTPUT, nzmax, nzmaxwp,nzmaxmp, nzmaxdp, ntokens; int NWS,NDS,i,j,c,n,wi,di,i1,i2,i3,i4,S2,S3, startcond; // Syntax // [ WP , DP , MP , Z , X ] = GibbsSamplerHMMLDA( WS , DS , T , S , N , ALPHA , BETA , GAMMA , SEED , OUTPUT , ZIN , XIN ) /* Check for proper number of arguments. */ if (nrhs < 10) { mexErrMsgTxt("At least 10 input arguments required"); } else if (nlhs != 5) { mexErrMsgTxt("5 output arguments required"); } startcond = 0; if (nrhs > 10) startcond = 1; if (sizeof( int ) != sizeof( mxINT32_CLASS )) mexErrMsgTxt("Problem with internal integer representation -- contact programmer" ); w = mxGetPr( prhs[0] ); NWS = mxGetN( prhs[0] ); d = mxGetPr( prhs[1] ); NDS = mxGetN( prhs[1] ); if ((mxIsSparse( prhs[ 0 ] ) == 1) || (mxIsDouble( prhs[ 0 ] ) != 1) || (mxGetM( prhs[0]) != 1)) mexErrMsgTxt("WS input stream must be a one-dimensional, non-sparse, double precision vector of word indices"); if ((mxIsSparse( prhs[ 1 ] ) == 1) || (mxIsDouble( prhs[ 1 ] ) != 1) || (mxGetM( prhs[1]) != 1)) mexErrMsgTxt("DS input stream must be a one-dimensional, non-sparse, double precision vector of document indices"); if (NWS != NDS) mexErrMsgTxt("WS and DS input streams must have equal dimensions" ); ntokens = NWS; T = (int) mxGetScalar(prhs[2]); if (T<=0) mexErrMsgTxt("Number of topics must be greater than zero"); SINPUT = (int) mxGetScalar(prhs[3]); if (SINPUT<=0) mexErrMsgTxt("Number of syntactic states must be greater than zero"); // need one syntactic state for sentence start // need one syntactic state for topic state S = SINPUT + 2; NN = (int) mxGetScalar(prhs[4]); if (NN<0) mexErrMsgTxt("Number of iterations must be greater than zero"); ALPHA = (double) mxGetScalar(prhs[5]); if (ALPHA<=0) mexErrMsgTxt("ALPHA must be greater than zero"); BETA = (double) mxGetScalar(prhs[6]); if (BETA<=0) mexErrMsgTxt("BETA must be greater than zero"); GAMMA = (double) mxGetScalar(prhs[7]); if (GAMMA<=0) mexErrMsgTxt("GAMMA must be greater than zero"); SEED = (int) mxGetScalar(prhs[8]); // set the seed of the random number generator OUTPUT = (int) mxGetScalar(prhs[9]); if (startcond==1) { if ((mxGetN( prhs[ 10 ] )*mxGetM( prhs[ 10 ] )) != ntokens) mexErrMsgTxt( "The ZIN vector should have have the same number of tokens as WS" ); if ((mxGetN( prhs[ 11 ] )*mxGetM( prhs[ 11 ] )) != ntokens) mexErrMsgTxt( "The ZIN vector should have have the same number of tokens as WS" ); ZIN = mxGetPr( prhs[ 10 ]); XIN = mxGetPr( prhs[ 11 ]); } // seeding seedMT( 1 + SEED * 2 ); // seeding only works on uneven numbers W = 0; D = 0; for (i=0; i<ntokens; i++) { // in Matlab WI=1...W word occurence, WI=0 sentence marker wi = (int) w[ i ] - 1; // word indices are not zero based in Matlab di = (int) d[ i ] - 1; // document indices are not zero based in Matlab //mexPrintf( "i=%d wi=%d di=%d\n" , i , wi , di ); if (wi > W) W = wi; if (di > D) D = di; if (wi < -1) mexErrMsgTxt("Unrecognized code in word stream (<-2)"); if (di < 0) mexErrMsgTxt("Unrecognized code in document stream (<0)"); } W = W + 1; D = D + 1; if ( wi != -1 ) mexErrMsgTxt("Word stream should end with sentence marker"); n = ntokens; //mexPrintf( "W=%d D=%d n=%d w[n-1]=%d\n" , W , D , n , (int) w[ n-1 ] ); // allocate memory z = (int *) mxCalloc( ntokens , sizeof( int )); x = (int *) mxCalloc( ntokens , sizeof( int )); if (startcond==1) { for (i=0; i<ntokens; i++) { z[ i ] = (int) ZIN[ i ] - 1; x[ i ] = (int) XIN[ i ] - 1; } } first = (int *) mxCalloc( ntokens , sizeof( int )); second = (int *) mxCalloc( ntokens , sizeof( int )); third = (int *) mxCalloc( ntokens , sizeof( int )); mp = (int *) mxCalloc( W*S , sizeof( int )); wp = (int *) mxCalloc( T*W , sizeof( int )); dp = (int *) mxCalloc( T*D , sizeof( int )); ztot = (int *) mxCalloc( T , sizeof( int )); mtot = (int *) mxCalloc( S , sizeof( int )); stot = (int *) mxCalloc( S * S * S , sizeof( int )); sp = (int *) mxCalloc( S * S * S * S , sizeof( int )); probs = (double *) mxCalloc( T+S , sizeof( double )); //for (i=0; i<n; i++) mexPrintf( "i=%4d w[i]=%3d d[i]=%d\n" , i , w[i] , d[i] , z[i] ); if (OUTPUT==2) { mexPrintf( "Running HMM-LDA Gibbs Sampler Version 1.0\n" ); if (startcond==1) mexPrintf( "Starting sampler from previous state\n" ); mexPrintf( "Arguments:\n" ); mexPrintf( "\tNumber of words W = %d\n" , W ); mexPrintf( "\tNumber of docs D = %d\n" , D ); mexPrintf( "\tNumber of topics T = %d\n" , T ); mexPrintf( "\tNumber of syntactic states S = %d\n" , S ); mexPrintf( "\tNumber of iterations N = %d\n" , NN ); mexPrintf( "\tHyperparameter ALPHA = %4.4f\n" , ALPHA ); mexPrintf( "\tHyperparameter BETA = %4.4f\n" , BETA ); mexPrintf( "\tHyperparameter GAMMA = %4.4f\n" , GAMMA ); mexPrintf( "\tSeed number SEED = %d\n" , SEED ); mexPrintf( "Properties of WS stream\n" ); mexPrintf( "\tNumber of tokens NZ = %d\n" , ntokens ); mexPrintf( "Internal Memory Allocation\n" ); mexPrintf( "\tz,x,first,second,third indices combined = %d bytes\n" , 5 * sizeof( int) * ntokens ); mexPrintf( "\twp matrix = %d bytes\n" , sizeof( int ) * W * T ); mexPrintf( "\tmp matrix = %d bytes\n" , sizeof( int ) * W * S ); mexPrintf( "\tdp matrix = %d bytes\n" , sizeof( int ) * D * T ); mexPrintf( "\tstot matrix = %d bytes\n" , sizeof( int ) * S * S * S ); mexPrintf( "\tsp matrix = %d bytes\n" , sizeof( int ) * S * S * S * S ); //mexPrintf( "Checking: sizeof(int)=%d sizeof(long)=%d sizeof(double)=%d\n" , sizeof(int) , sizeof(long) , sizeof(double)); } // run the model GibbsSamplerHMMLDA( ALPHA, BETA, GAMMA, W, T, S , D, NN, OUTPUT, n, z, x, d, w, wp, mp, dp, ztot, mtot, stot , sp , first,second,third, probs, startcond ); // convert the full wp matrix into a sparse matrix nzmaxwp = 0; for (i=0; i<W; i++) { for (j=0; j<T; j++) nzmaxwp += (int) ( *( wp + j + i*T )) > 0; } if (OUTPUT==2) mexPrintf( "Constructing sparse output matrix WP nnz=%d\n" , nzmaxwp ); plhs[0] = mxCreateSparse( W,T,nzmaxwp,mxREAL); srwp = mxGetPr(plhs[0]); irwp = mxGetIr(plhs[0]); jcwp = mxGetJc(plhs[0]); n = 0; for (j=0; j<T; j++) { *( jcwp + j ) = n; for (i=0; i<W; i++) { c = (int) *( wp + i*T + j ); if (c >0) { *( srwp + n ) = c; *( irwp + n ) = i; n++; } } } *( jcwp + T ) = n; // processing DP as sparse output matrix nzmaxdp = 0; for (i=0; i<D; i++) { for (j=0; j<T; j++) nzmaxdp += (int) ( *( dp + j + i*T )) > 0; } if (OUTPUT==2) mexPrintf( "Constructing sparse output matrix DP nnz=%d\n" , nzmaxdp ); plhs[1] = mxCreateSparse( D,T,nzmaxdp,mxREAL); srdp = mxGetPr(plhs[1]); irdp = mxGetIr(plhs[1]); jcdp = mxGetJc(plhs[1]); n = 0; for (j=0; j<T; j++) { *( jcdp + j ) = n; for (i=0; i<D; i++) { c = (int) *( dp + i*T + j ); if (c >0) { *( srdp + n ) = c; *( irdp + n ) = i; n++; } } } *( jcdp + T ) = n; // processing MP as sparse output matrix nzmaxmp = 0; for (i=0; i<W; i++) { for (j=0; j<S; j++) { nzmaxmp += (int) ( mp[ j + i*S ] > 0 ); } } if (OUTPUT==2) mexPrintf( "Constructing sparse output matrix MP nnz=%d\n" , nzmaxmp ); plhs[2] = mxCreateSparse( W,SINPUT,nzmaxmp,mxREAL); srmp = mxGetPr(plhs[2]); irmp = mxGetIr(plhs[2]); jcmp = mxGetJc(plhs[2]); n = 0; for (j=0; j<SINPUT; j++) { *( jcmp + j ) = n; for (i=0; i<W; i++) { c = mp[ i*S + (j+2) ]; if (c >0) { *( srmp + n ) = c; *( irmp + n ) = i; n++; } } } *( jcmp + SINPUT ) = n; /* --------------------------------------------- create the topic assignment vector -----------------------------------------------*/ plhs[ 3 ] = mxCreateDoubleMatrix( ntokens , 1 , mxREAL ); Z = mxGetPr( plhs[ 3 ] ); for (i=0; i<ntokens; i++) Z[ i ] = (double) z[ i ] + 1; /* --------------------------------------------- create the HMM state assignment vector -----------------------------------------------*/ plhs[ 4 ] = mxCreateDoubleMatrix( ntokens , 1 , mxREAL ); X = mxGetPr( plhs[ 4 ] ); for (i=0; i<ntokens; i++) X[ i ] = (double) x[ i ] + 1; }
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { double *A, *U, *V, *VT, *S, *flag, *work, *AA; mwIndex subs[2]; mwSize nsubs=2; mwIndex *irS, *jcS, *iwork; mwSize M, N, lwork, info, options, minMN, maxMN, k, j; mwSize LDA, LDU, LDVT, nU, mVT, mS, nS; char *jobz; /* CHECK FOR PROPER NUMBER OF ARGUMENTS */ if (nrhs > 2){ mexErrMsgTxt("mexsvd: requires at most 2 input arguments."); } if (nlhs > 4){ mexErrMsgTxt("mexsvd: requires at most 4 output argument."); } /* CHECK THE DIMENSIONS */ M = mxGetM(prhs[0]); N = mxGetN(prhs[0]); if (mxIsSparse(prhs[0])) { mexErrMsgTxt("mexeig: sparse matrix not allowed."); } A = mxGetPr(prhs[0]); LDA = M; minMN = MIN(M,N); maxMN = MAX(M,N); options = 0; if (nrhs==2) { options = (int)*mxGetPr(prhs[1]); } if (options==0) { /***** economical SVD ******/ jobz="S"; nU = minMN; mVT = minMN; mS = minMN; nS = minMN; } else { /***** full SVD ******/ jobz="A"; nU = M; mVT = N; mS = M; nS = N; } LDU = M; LDVT = mVT; /***** create return argument *****/ if (nlhs >=3) { /***** compute singular values and vectors ******/ plhs[0] = mxCreateDoubleMatrix(M,nU,mxREAL); U = mxGetPr(plhs[0]); plhs[1] = mxCreateSparse(mS,nS,minMN,mxREAL); S = mxGetPr(plhs[1]); irS = mxGetIr(plhs[1]); jcS = mxGetJc(plhs[1]); plhs[2] = mxCreateDoubleMatrix(N,mVT,mxREAL); V = mxGetPr(plhs[2]); plhs[3] = mxCreateDoubleMatrix(1,1,mxREAL); flag = mxGetPr(plhs[3]); } else { /***** compute only singular values ******/ plhs[0]= mxCreateDoubleMatrix(minMN,1,mxREAL); S = mxGetPr(plhs[0]); plhs[1] = mxCreateDoubleMatrix(1,1,mxREAL); flag = mxGetPr(plhs[1]); U = mxCalloc(M*nU,sizeof(double)); V = mxCalloc(N*mVT,sizeof(double)); jobz="N"; } /***** Do the computations in a subroutine *****/ lwork = 4*minMN*minMN + MAX(maxMN,5*minMN*minMN+4*minMN); work = mxCalloc(lwork,sizeof(double)); iwork = mxCalloc(8*minMN,sizeof(int)); VT = mxCalloc(mVT*N,sizeof(double)); AA = mxCalloc(M*N,sizeof(double)); memcpy(AA,mxGetPr(prhs[0]),(M*N)*sizeof(double)); dgesdd(jobz,&M,&N, AA,&LDA,S,U,&LDU,VT,&LDVT,work,&lwork,iwork, &info); flag[0] = (double)info; if (nlhs >= 3) { for (k=0; k<minMN; k++) { irS[k] = k; } jcS[0] = 0; for (k=1; k<=nS; k++) { if (k<minMN) { jcS[k] = k; } else { jcS[k] = minMN; } } for (k=0; k<mVT; k++) { for (j=0; j<N; j++) { V[j+k*N] = VT[k+j*mVT]; } } } return; }
mxArray* omp_ls(const double m_dict[], const double m_x[], mwSize M, mwSize N, mwSize S, mwSize K, double res_norm_bnd, int sparse_output, int verbose){ // List of indices of selected atoms mwIndex *selected_atoms = 0; // Simple binary mask of selected atoms int* selected_atoms_mask = 0; // The submatrix of selected atoms double* m_subdict = 0; // Copy of subdictionary for least squares double* m_subdict_copy = 0; // The proxy D' x double* v_proxy = 0; // The inner product of residual with atoms double* v_h = 0; // The residual double* v_r = 0; // Result of orthogonal projection LL' c = p_I double* v_c = 0; // Some temporary vectors double *v_t1 = 0, *v_t2 = 0; // Pointer to new atom const double* wv_new_atom; // residual norm squared double res_norm_sqr; // square of upper bound on residual norm double res_norm_bnd_sqr = SQR(res_norm_bnd); // Pointer to current signal const double *wv_x = 0; /// Output array mxArray* p_alpha; double* m_alpha; // row indices for non-zero entries in Alpha mwIndex *ir_alpha; // indices for first non-zero entry in column mwIndex *jc_alpha; /// Index for non-zero entries in alpha mwIndex nz_index; // counters int i, j , k, s; // index of new atom mwIndex new_atom_index; // misc variables double d1, d2; // Maximum number of columns to be used in representations mwSize max_cols; // structure for tracking time spent. omp_profile profile; if (K < 0 || K > M) { // K cannot be greater than M. K = M; } max_cols = (mwSize)(ceil(sqrt((double)M)/2.0) + 1.01); if(max_cols < K){ max_cols = K; } // Memory allocations // Number of selected atoms cannot exceed M selected_atoms = (mwIndex*) mxMalloc(M*sizeof(mwIndex)); // Total number of atoms is N selected_atoms_mask = (int*) mxMalloc(N*sizeof(int)); // Coefficients of solution of least square problem v_c = (double*)mxMalloc(M*sizeof(double)); // Giving enough space for temporary vectors v_t1 = (double*)mxMalloc(N*sizeof(double)); v_t2 = (double*)mxMalloc(N*sizeof(double)); // Keeping max_cols space for subdictionary. m_subdict = (double*)mxMalloc(max_cols*M*sizeof(double)); m_subdict_copy = (double*)mxMalloc(max_cols*M*sizeof(double)); // Proxy vector is in R^N v_proxy = (double*)mxMalloc(N*sizeof(double)); // h is in R^N. v_h = (double*)mxMalloc(N*sizeof(double)); // Residual is in signal space R^M. v_r = (double*)mxMalloc(M*sizeof(double)); if (sparse_output == 0){ p_alpha = mxCreateDoubleMatrix(N, S, mxREAL); m_alpha = mxGetPr(p_alpha); ir_alpha = 0; jc_alpha = 0; }else{ p_alpha = mxCreateSparse(N, S, max_cols*S, mxREAL); m_alpha = mxGetPr(p_alpha); ir_alpha = mxGetIr(p_alpha); jc_alpha = mxGetJc(p_alpha); nz_index = 0; jc_alpha[0] = 0; } omp_profile_init(&profile); for(s=0; s<S; ++s){ wv_x = m_x + M*s; // Initialization res_norm_sqr = inner_product(wv_x, wv_x, M); //Compute proxy p = D' * x mult_mat_t_vec(1, m_dict, wv_x, v_proxy, M, N); omp_profile_toctic(&profile, TIME_DtR); // h = p = D' * r copy_vec_vec(v_proxy, v_h, N); for (i=0; i<N; ++i){ selected_atoms_mask[i] = 0; } // Number of atoms selected so far. k = 0; // Iterate for each atom while (k < K && res_norm_sqr > res_norm_bnd_sqr){ omp_profile_tic(&profile); // Pick the index of (k+1)-th atom new_atom_index = abs_max_index(v_h, N); omp_profile_toctic(&profile, TIME_MaxAbs); // If this atom is already selected, we will break if (selected_atoms_mask[new_atom_index]){ // This is unlikely due to orthogonal structure of OMP if (verbose){ mexPrintf("This atom is already selected."); } break; } // Check for small values d2 = v_h[new_atom_index]; if (SQR(d2) < 1e-14){ // The inner product of residual with new atom is way too small. break; } // Store the index of new atom selected_atoms[k] = new_atom_index; selected_atoms_mask[new_atom_index] = 1; // Copy the new atom to the sub-dictionary wv_new_atom = m_dict + new_atom_index*M; copy_vec_vec(wv_new_atom, m_subdict+k*M, M); omp_profile_toctic(&profile, TIME_DictSubMatrixUpdate); // It is time to increase the count of selected atoms ++k; // Least squares copy_vec_vec(m_subdict, m_subdict_copy, M*k); copy_vec_vec(wv_x, v_t1, M); least_square(m_subdict_copy, v_t1, v_c, M, k, 1); omp_profile_toctic(&profile, TIME_LeastSquares); // Compute residual // r = x - D_I c mult_mat_vec(-1, m_subdict, v_c, v_r, M, k); sum_vec_vec(1, wv_x, v_r, M); omp_profile_toctic(&profile, TIME_RUpdate); // Update h = D' r mult_mat_t_vec(1, m_dict, v_r, v_h, M, N); // Update residual norm squared res_norm_sqr = inner_product(v_r, v_r, M); omp_profile_toctic(&profile, TIME_DtR); //mexPrintf(".\n"); } // Write the output vector if(sparse_output == 0){ // Write the output vector double* wv_alpha = m_alpha + N*s; fill_vec_sparse_vals(v_c, selected_atoms, wv_alpha, N, k); } else{ // Sort the row indices quicksort_indices(selected_atoms, v_c, k); // add the non-zero entries for this column for(j=0; j <k; ++j){ m_alpha[nz_index] = v_c[j]; ir_alpha[nz_index] = selected_atoms[j]; ++nz_index; } // fill in the total number of nonzero entries in the end. jc_alpha[s+1] = jc_alpha[s] + k; } } if(verbose){ omp_profile_print(&profile); } // Memory cleanup mxFree(selected_atoms); mxFree(selected_atoms_mask); mxFree(v_c); mxFree(v_t1); mxFree(v_t2); mxFree(m_subdict); mxFree(m_subdict_copy); mxFree(v_proxy); mxFree(v_h); mxFree(v_r); // Return the result return p_alpha; }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { /*input for C function */ double *in; /*input image*/ double *weight; /*output weight*/ double h; int nx,ny,nxny,newnx,newny; int nwin, bloc; double a, percent_sparse,v,c,sum,e,dist; int i,j,k,nzmax; int *dadr,*dd,x,y,xp,yp,adr,adrp,psize,wsize,ds,realadr,realadrp,li; double *w,*ww,*lw; /*symetry image*/ double* in_sym; mwIndex *irs,*jcs; char s; /*Output for C function */ int l; if (nrhs < 1 ) mexErrMsgTxt("At least one inputs required."); if (nrhs > 6 ) mexErrMsgTxt("Too many inputs required."); if (nlhs != 1) mexErrMsgTxt("One output required."); /*Input Image */ nx = mxGetM(prhs[0]); ny = mxGetN(prhs[0]); in = mxGetPr(prhs[0]); h = mxGetScalar(prhs[1]); nxny=nx*ny; if (nrhs<3) nwin=3; else nwin=mxGetScalar(prhs[2]); if (nrhs<4) bloc=6; else bloc=mxGetScalar(prhs[3]); /*Other parameters*/ percent_sparse=(2*bloc+1)*(2*bloc+1)/(double)nxny; nzmax=(mwSize)ceil((double)nxny*(double)nxny*percent_sparse); plhs[0] = mxCreateSparse(nxny,nxny,nzmax,0); weight= mxGetPr(plhs[0]); /* Create a C pointer to a copy of the output matrix,but be careful that the matrix is tranposed */ a=(2*nwin)/4.; c=1; /*Sparse weight paramters*/ irs= mxGetIr(plhs[0]); jcs= mxGetJc(plhs[0]); /* precompute weights */ ds =nwin; psize = (2*nwin+1)*(2*nwin+1); /* patch size; patch = [-ds,ds]x[-ds,ds] */ wsize = (2*bloc+1)*(2*bloc+1); /* window size; patch = [-d,d]x[-d,d] */ w = (double *)malloc(psize*sizeof(double)); /*patch weight */ dadr = (int *)malloc(psize*sizeof(int));/*patch index */ lw = (double *)malloc(wsize*sizeof(double)); /*local window weight */ /*symstry bord of image*/ newnx=nx+2*ds; newny=ny+2*ds; in_sym = (double *)malloc(newny*newnx*sizeof(double)); /* extend the original image */ for (j=0,k=0;j<newny;j++) { if (j<ds) y=ds-j; else if (j>ny+ds-1) y=2*ny+ds-j-2; else y=j-ds; for (i=0;i<newnx;i++,k++) { if (i<=ds) x=ds-i; else if (i>nx+ds-1) x=2*nx+ds-i-2; else x=i-ds; in_sym[k]=in[y*nx+x]; } } /*Precompute patch weight and index */ for(sum=0.,i=0,x=-ds;x<=ds;x++) for(y=-ds;y<=ds;y++,i++) { dadr[i] = y*newnx+x; w[i] = exp(-(double)(x*x+y*y)/(2.*a*a)); sum += w[i]; } for (i=psize;i--;) w[i] /= 2*sum*h*h; /* Principal loop */ k=0; for (y=ds;y<newny-ds;y++) for (x=ds;x<newnx-ds;x++) { adr = y*newnx+x; realadr=(y-ds)*nx+x-ds; sum = 0.; jcs[realadr] = k; /* loop on patches */ /* Count non zero weight for realadr columns */ for (xp=MAX(x-bloc,ds);xp<=MIN(x+bloc,nx-1+ds);xp++) for (yp=MAX(y-bloc,ds);yp<=MIN(y+bloc,ny-1+ds);yp++) { adrp = yp*newnx+xp; realadrp=(yp-ds)*nx+xp-ds; for (i=psize,dist=0.,ww=w,dd=dadr;i--;ww++,dd++) { v = in_sym[adr+*dd]-in_sym[adrp+*dd]; dist += *ww*(double)(v*v); } e = (adrp==adr?c:exp(-dist)); weight[k] = e; irs[k]=realadrp; k++; } } jcs[nxny]=k; free(dadr); free(w); free(in_sym); }
void mexFunction ( int nargout, mxArray *pargout [ ], int nargin, const mxArray *pargin [ ] ) { double dummy = 0, beta [2], *px, *C, *Ct, *C2, *fil, *Zt, *zt, done=1.0, *zz, dzero=0.0; cholmod_sparse Amatrix, *A, *Lsparse ; cholmod_factor *L ; cholmod_common Common, *cm ; Int minor, *It2, *Jt2 ; mwIndex l, k2, h, k, i, j, ik, *I, *J, *Jt, *It, *I2, *J2, lfi, *w, *w2, *r; mwSize nnz, nnzlow, m, n; int nz = 0; mwSignedIndex one=1, lfi_si; mxArray *Am, *Bm; char *uplo="L", *trans="N"; /* ---------------------------------------------------------------------- */ /* Only one input. We have to find first the Cholesky factorization. */ /* start CHOLMOD and set parameters */ /* ---------------------------------------------------------------------- */ if (nargin == 1) { cm = &Common ; cholmod_l_start (cm) ; sputil_config (SPUMONI, cm) ; /* convert to packed LDL' when done */ cm->final_asis = FALSE ; cm->final_super = FALSE ; cm->final_ll = FALSE ; cm->final_pack = TRUE ; cm->final_monotonic = TRUE ; /* since numerically zero entries are NOT dropped from the symbolic * pattern, we DO need to drop entries that result from supernodal * amalgamation. */ cm->final_resymbol = TRUE ; cm->quick_return_if_not_posdef = (nargout < 2) ; } /* This will disable the supernodal LL', which will be slow. */ /* cm->supernodal = CHOLMOD_SIMPLICIAL ; */ /* ---------------------------------------------------------------------- */ /* get inputs */ /* ---------------------------------------------------------------------- */ if (nargin > 3) { mexErrMsgTxt ("usage: Z = sinv(A), or Z = sinv(LD, 1)") ; } n = mxGetM (pargin [0]) ; m = mxGetM (pargin [0]) ; if (!mxIsSparse (pargin [0])) { mexErrMsgTxt ("A must be sparse") ; } if (n != mxGetN (pargin [0])) { mexErrMsgTxt ("A must be square") ; } /* Only one input. We have to find first the Cholesky factorization. */ if (nargin == 1) { /* get sparse matrix A, use tril(A) */ A = sputil_get_sparse (pargin [0], &Amatrix, &dummy, -1) ; A->stype = -1 ; /* use lower part of A */ beta [0] = 0 ; beta [1] = 0 ; /* ---------------------------------------------------------------------- */ /* analyze and factorize */ /* ---------------------------------------------------------------------- */ L = cholmod_l_analyze (A, cm) ; cholmod_l_factorize_p (A, beta, NULL, 0, L, cm) ; if (cm->status != CHOLMOD_OK) { mexErrMsgTxt ("matrix is not positive definite") ; } /* ---------------------------------------------------------------------- */ /* convert L to a sparse matrix */ /* ---------------------------------------------------------------------- */ Lsparse = cholmod_l_factor_to_sparse (L, cm) ; if (Lsparse->xtype == CHOLMOD_COMPLEX) { mexErrMsgTxt ("matrix is complex") ; } /* ---------------------------------------------------------------------- */ /* Set the sparse Cholesky factorization in Matlab format */ /* ---------------------------------------------------------------------- */ /*Am = sputil_put_sparse (&Lsparse, cm) ; I = mxGetIr(Am); J = mxGetJc(Am); C = mxGetPr(Am); nnz = mxGetNzmax(Am); */ It2 = Lsparse->i; Jt2 = Lsparse->p; Ct = Lsparse->x; nnz = (mwSize) Lsparse->nzmax; Am = mxCreateSparse(m, m, nnz, mxREAL) ; I = mxGetIr(Am); J = mxGetJc(Am); C = mxGetPr(Am); for (j = 0 ; j < n+1 ; j++) J[j] = (mwIndex) Jt2[j]; for ( i = 0 ; i < nnz ; i++) { I[i] = (mwIndex) It2[i]; C[i] = Ct[i]; } cholmod_l_free_sparse (&Lsparse, cm) ; /*FILE *out1 = fopen( "output1.txt", "w" ); if( out1 != NULL ) fprintf( out1, "Hello %d\n", nnz ); fclose (out1);*/ } else { /* The cholesky factorization is given as an input. */ /* We have to copy it into workspace */ It = mxGetIr(pargin [0]); Jt = mxGetJc(pargin [0]); Ct = mxGetPr(pargin [0]); nnz = mxGetNzmax(pargin [0]); Am = mxCreateSparse(m, m, nnz, mxREAL) ; I = mxGetIr(Am); J = mxGetJc(Am); C = mxGetPr(Am); for (j = 0 ; j < n+1 ; j++) J[j] = Jt[j]; for ( i = 0 ; i < nnz ; i++) { I[i] = It[i]; C[i] = Ct[i]; } } /* Evaluate the sparse inverse */ C[nnz-1] = 1.0/C[J[m-1]]; /* set the last element of sparse inverse */ fil = mxCalloc((mwSize)1,sizeof(double)); zt = mxCalloc((mwSize)1,sizeof(double)); Zt = mxCalloc((mwSize)1,sizeof(double)); zz = mxCalloc((mwSize)1,sizeof(double)); for (j=m-2;j!=-1;j--){ lfi = J[j+1]-(J[j]+1); /* if (lfi > 0) */ if ( J[j+1] > (J[j]+1) ) { /* printf("lfi = %u \n ", lfi); printf("lfi*double = %u \n", (mwSize)lfi*sizeof(double)); printf("lfi*lfi*double = %u \n", (mwSize)lfi*(mwSize)lfi*sizeof(double)); printf("\n \n"); */ fil = mxRealloc(fil,(mwSize)lfi*sizeof(double)); for (i=0;i<lfi;i++) fil[i] = C[J[j]+i+1]; /* take the j'th lower triangular column of the Cholesky */ zt = mxRealloc(zt,(mwSize)lfi*sizeof(double)); /* memory for the sparse inverse elements to be evaluated */ Zt = mxRealloc(Zt,(mwSize)lfi*(mwSize)lfi*sizeof(double)); /* memory for the needed sparse inverse elements */ /* Set the lower triangular for Zt */ k2 = 0; for (k=J[j]+1;k<J[j+1];k++){ ik = I[k]; h = k2; for (l=J[ik];l<=J[ik+1];l++){ if (I[l] == I[ J[j]+h+1 ]){ Zt[h+lfi*k2] = C[l]; h++; } } k2++; } /* evaluate zt = fil*Zt */ lfi_si = (mwSignedIndex) lfi; dsymv(uplo, &lfi_si, &done, Zt, &lfi_si, fil, &one, &dzero, zt, &one); /* Set the evaluated sparse inverse elements, zt, into C */ k=lfi-1; for (i = J[j+1]-1; i!=J[j] ; i--){ C[i] = -zt[k]; k--; } /* evaluate the j'th diagonal of sparse inverse */ dgemv(trans, &one, &lfi_si, &done, fil, &one, zt, &one, &dzero, zz, &one); C[J[j]] = 1.0/C[J[j]] + zz[0]; } else { /* evaluate the j'th diagonal of sparse inverse */ C[J[j]] = 1.0/C[J[j]]; } } /* Free the temporary variables */ mxFree(fil); mxFree(zt); mxFree(Zt); mxFree(zz); /* ---------------------------------------------------------------------- */ /* Permute the elements according to r(q) = 1:n */ /* Done only if the Cholesky was evaluated here */ /* ---------------------------------------------------------------------- */ if (nargin == 1) { Bm = mxCreateSparse(m, m, nnz, mxREAL) ; It = mxGetIr(Bm); Jt = mxGetJc(Bm); Ct = mxGetPr(Bm); /* Ct = C(r,r) */ r = (mwIndex *) L->Perm; /* fill reducing ordering */ w = mxCalloc(m,sizeof(mwIndex)); /* column counts of Am */ /* count entries in each column of Bm */ for (j=0; j<m; j++){ k = r ? r[j] : j ; /* column j of Bm is column k of Am */ for (l=J[j] ; l<J[j+1] ; l++){ i = I[l]; ik = r ? r[i] : i ; /* row i of Bm is row ik of Am */ w[ max(ik,k) ]++; } } cumsum2(Jt, w, m); for (j=0; j<m; j++){ k = r ? r[j] : j ; /* column j of Bm is column k of Am */ for (l=J[j] ; l<J[j+1] ; l++){ i= I[l]; ik = r ? r[i] : i ; /* row i of Bm is row ik of Am */ It [k2 = w[max(ik,k)]++ ] = min(ik,k); Ct[k2] = C[l]; } } mxFree(w); /* ---------------------------------------------------------------------- */ /* Transpose the permuted (upper triangular) matrix Bm into Am */ /* (this way we get sorted columns) */ /* ---------------------------------------------------------------------- */ w = mxCalloc(m,sizeof(mwIndex)); for (i=0 ; i<Jt[m] ; i++) w[It[i]]++; /* row counts of Bm */ cumsum2(J, w, m); /* row pointers */ for (j=0 ; j<m ; j++){ for (i=Jt[j] ; i<Jt[j+1] ; i++){ I[ l=w[ It[i] ]++ ] = j; C[l] = Ct[i]; } } mxFree(w); mxDestroyArray(Bm); } /* ---------------------------------------------------------------------- */ /* Fill the upper triangle of the sparse inverse */ /* ---------------------------------------------------------------------- */ w = mxCalloc(m,sizeof(mwIndex)); /* workspace */ w2 = mxCalloc(m,sizeof(mwIndex)); /* workspace */ for (k=0;k<J[m];k++) w[I[k]]++; /* row counts of the lower triangular */ for (k=0;k<m;k++) w2[k] = w[k] + J[k+1] - J[k] - 1; /* column counts of the sparse inverse */ nnz = (mwSize)2*nnz - m; /* The number of nonzeros in Z */ pargout[0] = mxCreateSparse(m,m,nnz,mxREAL); /* The sparse matrix */ It = mxGetIr(pargout[0]); Jt = mxGetJc(pargout[0]); Ct = mxGetPr(pargout[0]); cumsum2(Jt, w2, m); /* column starting points */ for (j = 0 ; j < m ; j++){ /* fill the upper triangular */ for (k = J[j] ; k < J[j+1] ; k++){ It[l = w2[ I[k]]++] = j ; /* place C(i,j) as entry Ct(j,i) */ if (Ct) Ct[l] = C[k] ; } } for (j = 0 ; j < m ; j++){ /* fill the lower triangular */ for (k = J[j]+1 ; k < J[j+1] ; k++){ It[l = w2[j]++] = I[k] ; /* place C(j,i) as entry Ct(j,i) */ if (Ct) Ct[l] = C[k] ; } } mxFree(w2); mxFree(w); /* ---------------------------------------------------------------------- */ /* return to MATLAB */ /* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */ /* free workspace and the CHOLMOD L, except for what is copied to MATLAB */ /* ---------------------------------------------------------------------- */ if (nargin == 1) { cholmod_l_free_factor (&L, cm) ; cholmod_l_finish (cm) ; cholmod_l_print_common (" ", cm) ; } mxDestroyArray(Am); }
void mexFunction(int nlhs, mxArray *plhs[],int nrhs, const mxArray *prhs[]) { double *v, *x, sigma, *lambda, *pr; mwIndex *ir, *jc; char *mode; int imode; //Check Inputs if(nrhs < 1) { printInfo(); return; } if(nrhs < 2) { mexErrMsgTxt("You must supply the callback mode and input vector."); return; } if(mxIsEmpty(prhs[0]) || !mxIsChar(prhs[0])) { mexErrMsgTxt("The mode must be a string!"); return; } if(!mxIsEmpty(prhs[1])) { if(mxIsClass(prhs[1],"scipvar") || mxIsClass(prhs[1],"barvec")) { mexErrMsgTxt("SCIP and BARON cannot be used with this callback function - please specify 'mcode' via symbset as the cbmode."); return; } if(!mxIsDouble(prhs[1]) || mxIsComplex(prhs[1]) || mxIsSparse(prhs[1])) { mexErrMsgTxt("The input vector must be a dense real double vector!"); return; } } else { mexErrMsgTxt("The input vector must be a dense real double vector!"); return; } //Check x input size if(mxGetNumberOfElements(prhs[1]) != getNoVar()) { mexErrMsgTxt("The input vector is not the right size!"); } //Get x x = mxGetPr(prhs[1]); //Determine input mode and setup return variable mode = mxArrayToString(prhs[0]); lower(mode); if(!strcmp(mode,"obj")) { imode = 0; plhs[0] = mxCreateDoubleMatrix(1,1, mxREAL); v = mxGetPr(plhs[0]); } else if(!strcmp(mode,"grad")) { imode = 1; plhs[0] = mxCreateDoubleMatrix(1,getNoVar(), mxREAL); v = mxGetPr(plhs[0]); } else if(!strcmp(mode,"con")) { imode = 2; plhs[0] = mxCreateDoubleMatrix(getNoCon(),1, mxREAL); v = mxGetPr(plhs[0]); } else if(!strcmp(mode,"jac")) { imode = 3; plhs[0] = mxCreateSparse(getNoCon(),getNoVar(),getNNZJac(),mxREAL); pr = mxGetPr(plhs[0]); ir = mxGetIr(plhs[0]); jc = mxGetJc(plhs[0]); } else if(!strcmp(mode,"hess")) { if(nrhs < 4) { mexErrMsgTxt("You must supply the callback mode, input vector, sigma and lambda for Hessian Evaluations."); return; } //Check length of Sigma if(mxIsEmpty(prhs[2]) || !mxIsDouble(prhs[2]) || mxIsComplex(prhs[2]) || mxGetNumberOfElements(prhs[2]) != 1) mexErrMsgTxt("Sigma must be a real, double scalar."); //Check length of Lambda if(!mxIsDouble(prhs[3]) || mxIsComplex(prhs[3]) || mxIsSparse(prhs[3]) || mxGetNumberOfElements(prhs[3]) != getNoCon()) mexErrMsgTxt("Lambda must be a real, double, dense vector with ncon elements."); //Get Sigma, Lambda sigma = *mxGetPr(prhs[2]); lambda = mxGetPr(prhs[3]); imode = 4; plhs[0] = mxCreateSparse(getNoVar(),getNoVar(),getNNZHess(),mxREAL); pr = mxGetPr(plhs[0]); ir = mxGetIr(plhs[0]); jc = mxGetJc(plhs[0]); } else mexErrMsgTxt("Unknown mode - options are 'obj', 'grad', 'con', 'jac', or 'hess'"); mxFree(mode); //Call Req Callback switch(imode) { case 0: //objective *v = objective(x); break; case 1: //gradient gradient(x,v); break; case 2: //constraints constraints(x,v); break; case 3: //jacobian jacobian(x,pr,ir,jc); break; case 4: //hessian hessian(x,sigma,lambda,pr,ir,jc); break; } }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { ASL_pfgh *asl = (ASL_pfgh*)cur_ASL; FILE *nl; Jmp_buf err_jmp0; cgrad *cg, **cgp; char *buf1, buf[512], *what, **whatp; fint *hcs, *hr, i, nerror; int *cs; mwIndex *Ir, *Jc; real *H, *He, *J1, *W, *c, *f, *g, *v, *t, *x; static fint n, nc, nhnz, nz; static real *Hsp; static char ignore_complementarity[] = "Warning: ignoring %d complementarity conditions.\n"; if (nrhs == 1 && mxIsChar(prhs[0])) { if (nlhs < 6 || nlhs > 7) usage(); if (mxGetString(prhs[0], buf1 = buf, sizeof(buf))) mexErrMsgTxt("Expected 'stub' as argument\n"); at_end(); mexAtExit(at_end); asl = (ASL_pfgh*)ASL_alloc(ASL_read_pfgh); return_nofile = 1; if (!(nl = jac0dim(buf1,strlen(buf)))) { sprintf(msgbuf, "Can't open %.*s\n", sizeof(msgbuf)-20, buf); mexErrMsgTxt(msgbuf); } if (n_obj <= 0) printf("Warning: objectve == 0\n"); n = n_var; nc = n_con; nz = nzc; X0 = mxGetPr(plhs[0] = mxCreateDoubleMatrix(n, 1, mxREAL)); LUv = mxGetPr(plhs[1] = mxCreateDoubleMatrix(n, 1, mxREAL)); Uvx = mxGetPr(plhs[2] = mxCreateDoubleMatrix(n, 1, mxREAL)); pi0 = mxGetPr(plhs[3] = mxCreateDoubleMatrix(nc, 1, mxREAL)); LUrhs = mxGetPr(plhs[4] = mxCreateDoubleMatrix(nc, 1, mxREAL)); Urhsx = mxGetPr(plhs[5] = mxCreateDoubleMatrix(nc, 1, mxREAL)); if (nlhs == 7) { cvar = (int*)M1alloc(nc*sizeof(int)); plhs[6] = mxCreateDoubleMatrix(nc, 1, mxREAL); x = mxGetPr(plhs[6]); } else if (n_cc) printf(ignore_complementarity, n_cc); pfgh_read(nl, ASL_findgroups); if (nlhs == 7) for(i = 0; i < nc; i++) x[i] = cvar[i]; /* Arrange to compute the whole sparese Hessian */ /* of the Lagrangian function (both triangles). */ nhnz = sphsetup(0, 0, nc > 0, 0); Hsp = (real *)M1alloc(nhnz*sizeof(real)); return; } if (!asl) mexErrMsgTxt("spamfunc(\"stub\") has not been called\n"); nerror = -1; err_jmp1 = &err_jmp0; what = "(?)"; whatp = &what; if (nlhs == 2) { if (nrhs != 2) usage(); x = sizechk(prhs[0],"x",n); t = sizechk(prhs[1],"0 or 1", 1); if (setjmp(err_jmp0.jb)) { sprintf(msgbuf, "Trouble evaluating %s\n", *whatp); mexErrMsgTxt(msgbuf); } if (t[0] == 0.) { f = mxGetPr(plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL)); c = mxGetPr(plhs[1] = mxCreateDoubleMatrix(nc, 1, mxREAL)); what = "f"; *f = objval(0, x, &nerror); what = "c"; conval(x, c, &nerror); return; } g = mxGetPr(plhs[0] = mxCreateDoubleMatrix(n, 1, mxREAL)); J1 = mxGetPr(plhs[1] = mxCreateSparse(nc, n, nz, mxREAL)); what = "g"; objgrd(0, x, g, &nerror); if (nc) { what = "J"; jacval(x, J1, &nerror); Ir = mxGetIr(plhs[1]); /*memcpy(mxGetJc(plhs[1]), A_colstarts, (n+1)*sizeof(int));*/ for(Jc = mxGetJc(plhs[1]), cs = A_colstarts, i = 0; i <= n; ++i) Jc[i] = cs[i]; cgp = Cgrad; for(i = 0; i < nc; i++) for(cg = *cgp++; cg; cg = cg->next) Ir[cg->goff] = i; } return; } if (nlhs == 0 && (nrhs == 3 || nrhs == 4)) { /* eval2('solution message', x, v): x = primal, v = dual */ /* optional 4th arg = solve_result_num */ if (!mxIsChar(prhs[0])) usage(); x = sizechk(prhs[1],"x",n); v = sizechk(prhs[2],"v",nc); if (mxGetString(prhs[0], buf, sizeof(buf))) mexErrMsgTxt( "Expected 'solution message' as first argument\n"); solve_result_num = nrhs == 3 ? -1 /* unknown */ : (int)*sizechk(prhs[3],"solve_result_num",1); write_sol(buf, x, v, 0); return; } if (nlhs != 1 || nrhs != 1) usage(); v = sizechk(prhs[0],"v",nc); W = mxGetPr(plhs[0] = mxCreateSparse(n, n, nhnz, mxREAL)); what = "W"; sphes(H = Hsp, 0, 0, v); /* Expand the Hessian lower triangle into the full Hessian... */ Ir = mxGetIr(plhs[0]); Jc = mxGetJc(plhs[0]); hcs = sputinfo->hcolstarts; hr = sputinfo->hrownos; for(i = 0; i <= n; i++) Jc[i] = hcs[i]; He = H + hcs[n]; while(H < He) { *W++ = *H++; *Ir++ = *hr++; } }
static mxArray *readdata(file_t *fp, mxArray **header, int start, int howmany){ /* if start!=0 || howmany!=0 and data is cell, will only read cell from start to start+howmany if data is not cell and start==-1, will skip the data. Only the first call to readdata will possibly have howmany!=0 */ if(fp->eof) return NULL; header_t header2; if(read_header2(&header2, fp)){ return NULL; } uint32_t magic=header2.magic & 0xFFFF; if(magic==0){//end of file or empty file fp->eof=1; return NULL; } if(header){ if(header2.str) *header=mxCreateString(header2.str); else *header=mxCreateString(""); } free(header2.str); header2.str=NULL; long nx=header2.nx; long ny=header2.ny; int start_save=start; if(iscell(magic)){ if(start!=-1 && howmany==0){ if(start!=0){ error("Invalid use\n"); } howmany=nx*ny-start; } }else if(fp->isfits){ if(howmany!=0){ /*first read of fits file. determine if we need it*/ if(start>0){ start=-1;//skip this block. } } }else{ if((start!=0 && start!=-1) || howmany!=0){ error("invalid use"); } } int iscell=0; if(fp->eof) return NULL; mxArray *out=NULL; switch(magic){ case MCC_ANY: case MCC_DBL: case MCC_CMP: case MC_CSP: case MC_SP: case MC_DBL: case MC_CMP: case MC_INT32: case MC_INT64: { iscell=1; mwIndex ix; if(fp->eof) return NULL; if(nx*ny>1 && skip_unicell){ out=mxCreateCellMatrix(nx,ny); } mxArray *header0=mxCreateCellMatrix(nx*ny+1,1); for(ix=0; ix<nx*ny; ix++){ int start2=0; if(start==-1 || ix<start || ix>=start+howmany){ start2=-1; } mxArray *header3=NULL; mxArray *tmp=readdata(fp, &header3, start2, 0); if(fp->eof){ break; } if(tmp && tmp!=SKIPPED){ if(nx*ny==1 && skip_unicell){//only one entry out=tmp; }else{ mxSetCell(out, ix, tmp); } if(header3){ mxSetCell(header0, ix, header3); } } } if(header){ mxSetCell(header0, nx*ny, *header); *header=header0; } } break; case M_SP64: case M_SP32: { if(start==-1) error("Invalid use\n"); size_t size; if(magic==M_SP32){ size=4; }else if(magic==M_SP64){ size=8; }else{ size=0; error("Invalid magic\n"); } uint64_t nzmax; if(nx!=0 && ny!=0){ zfread(&nzmax,sizeof(uint64_t),1,fp); }else{ nzmax=0; } if(fp->eof) return NULL; out=mxCreateSparse(nx,ny,nzmax,mxREAL); if(nx!=0 && ny!=0 && nzmax!=0){ if(sizeof(mwIndex)==size){/*Match*/ zfread(mxGetJc(out), size,ny+1,fp); zfread(mxGetIr(out), size,nzmax, fp); }else{ long i; mwIndex *Jc0=mxGetJc(out); mwIndex *Ir0=mxGetIr(out); void *Jc=malloc(size*(ny+1)); void *Ir=malloc(size*nzmax); zfread(Jc, size, ny+1, fp); zfread(Ir, size, nzmax, fp); if(size==4){ uint32_t* Jc2=Jc; uint32_t* Ir2=Ir; for(i=0; i<ny+1; i++){ Jc0[i]=Jc2[i]; } for(i=0; i<nzmax; i++){ Ir0[i]=Ir2[i]; } free(Jc); free(Ir); }else if(size==8){ uint64_t* Jc2=Jc; uint64_t* Ir2=Ir; for(i=0; i<ny+1; i++){ Jc0[i]=Jc2[i]; } for(i=0; i<nzmax; i++){ Ir0[i]=Ir2[i]; } free(Jc); free(Ir); }else{ mexErrMsgTxt("Invalid sparse format\n"); } } zfread(mxGetPr(out), sizeof(double), nzmax, fp); } } break; case M_CSP64: case M_CSP32:/*complex sparse*/ { if(start==-1) error("Invalid use\n"); size_t size; switch(magic){ case M_CSP32: size=4;break; case M_CSP64: size=8;break; default: size=0; } uint64_t nzmax; if(nx!=0 && ny!=0){ zfread(&nzmax,sizeof(uint64_t),1,fp); }else{ nzmax=0; } if(fp->eof) return NULL; out=mxCreateSparse(nx,ny,nzmax,mxCOMPLEX); if(nx!=0 && ny!=0){ long i; if(sizeof(mwIndex)==size){ zfread(mxGetJc(out), size,ny+1,fp); zfread(mxGetIr(out), size,nzmax, fp); }else{ mwIndex *Jc0=mxGetJc(out); mwIndex *Ir0=mxGetIr(out); void *Jc=malloc(size*(ny+1)); void *Ir=malloc(size*nzmax); zfread(Jc, size, ny+1, fp); zfread(Ir, size, nzmax, fp); if(size==4){ uint32_t* Jc2=Jc; uint32_t* Ir2=Ir; for(i=0; i<ny+1; i++){ Jc0[i]=Jc2[i]; } for(i=0; i<nzmax; i++){ Ir0[i]=Ir2[i]; } free(Jc); free(Ir); }else if(size==8){ uint64_t* Jc2=Jc; uint64_t* Ir2=Ir; for(i=0; i<ny+1; i++){ Jc0[i]=Jc2[i]; } for(i=0; i<nzmax; i++){ Ir0[i]=Ir2[i]; } free(Jc); free(Ir); }else{ info("size=%lu\n", size); error("Invalid sparse format\n"); } } dcomplex *tmp=malloc(sizeof(dcomplex)*nzmax); zfread(tmp, sizeof(dcomplex), nzmax, fp); double *Pr=mxGetPr(out); double *Pi=mxGetPi(out); for(i=0; i<nzmax; i++){ Pr[i]=tmp[i].x; Pi[i]=tmp[i].y; } free(tmp); } } break; case M_DBL:/*double array*/ if(start==-1){ if(zfseek(fp, sizeof(double)*nx*ny, SEEK_CUR)){ error("Seek failed\n"); } out=SKIPPED; }else{ out=mxCreateDoubleMatrix(nx,ny,mxREAL); if(nx!=0 && ny!=0){ zfread(mxGetPr(out), sizeof(double),nx*ny,fp); } } break; case M_FLT:/*float array*/ if(start==-1){ if(zfseek(fp, sizeof(float)*nx*ny, SEEK_CUR)){ error("Seek failed\n"); } out=SKIPPED; }else{ mwSize nxy[2]={nx,ny}; out=mxCreateNumericArray(2, nxy,mxSINGLE_CLASS, mxREAL); if(nx!=0 && ny!=0){ zfread((float*)mxGetPr(out), sizeof(float),nx*ny, fp); } }break; case M_INT64:/*long array*/ case M_INT32: case M_INT16: case M_INT8: { int byte=0; mxClassID id; switch(magic){ case M_INT64: byte=8; id=mxINT64_CLASS; break; case M_INT32: byte=4; id=mxINT32_CLASS; break; case M_INT16: byte=2; id=mxINT16_CLASS; break; case M_INT8: byte=1; id=mxINT8_CLASS; break; default: id=0; } if(start==-1){ if(zfseek(fp, byte*nx*ny, SEEK_CUR)){ error("Seek failed\n"); } out=SKIPPED; }else{ out=mxCreateNumericMatrix(nx,ny,id,mxREAL); if(nx!=0 && ny!=0){ /*Don't use sizeof(mxINT64_CLASS), it is just an integer, not a valid C type.*/ zfread(mxGetPr(out), byte,nx*ny,fp); } } } break; case M_CMP:/*double complex array*/ if(start==-1){ if(zfseek(fp, 16*nx*ny, SEEK_CUR)){ error("Seek failed\n"); } out=SKIPPED; }else{ out=mxCreateDoubleMatrix(nx,ny,mxCOMPLEX); if(nx!=0 && ny!=0){ dcomplex*tmp=malloc(sizeof(dcomplex)*nx*ny); zfread(tmp,sizeof(dcomplex),nx*ny,fp); double *Pr=mxGetPr(out); double *Pi=mxGetPi(out); long i; for(i=0; i<nx*ny; i++){ Pr[i]=tmp[i].x; Pi[i]=tmp[i].y; } free(tmp); } } break; case M_ZMP:/*float complex array. convert to double*/ if(start==-1){ if(zfseek(fp, 8*nx*ny, SEEK_CUR)){ error("Seek failed\n"); } out=SKIPPED; }else{ mwSize nxy[2]={nx, ny}; out=mxCreateNumericArray(2, nxy,mxSINGLE_CLASS, mxCOMPLEX); if(nx!=0 && ny!=0){ fcomplex*tmp=malloc(sizeof(fcomplex)*nx*ny); zfread(tmp,sizeof(fcomplex),nx*ny,fp); float *Pr=(float*)mxGetPr(out); float *Pi=(float*)mxGetPi(out); long i; for(i=0; i<nx*ny; i++){ Pr[i]=tmp[i].x; Pi[i]=tmp[i].y; } free(tmp); } } break; case M_HEADER: break; default: fprintf(stderr,"magic=%x\n",magic); warning("Unrecognized file. Please recompile the mex routines in the newest code\n"); out=NULL; } start=start_save; if(!iscell && fp->isfits==1){/*fits file may contain extra extensions.*/ fp->isfits++; int icell=0; mxArray **outarr=NULL; mxArray **headerarr=NULL; while(out){ icell++; outarr=realloc(outarr, sizeof(mxArray*)*icell); headerarr=realloc(headerarr, sizeof(mxArray*)*icell); if(out==SKIPPED) out=NULL; outarr[icell-1]=out; if(header) headerarr[icell-1]=*header; int start2=0; if(howmany!=0){//selective reading. if(icell<start || icell+1>start+howmany){ start2=-1;//don't read next data. } } out=readdata(fp, header, start2, 0); } if(icell>1){/*set output.*/ out=mxCreateCellMatrix(icell, 1); if(header) *header=mxCreateCellMatrix(icell, 1); int i; for(i=0; i<icell; i++){ mxSetCell(out, i, outarr[i]); if(header) mxSetCell(*header, i, headerarr[i]); } free(outarr); free(headerarr); }else{ out=outarr[0]; if(header) *header=headerarr[0]; } } if(!out){ out=mxCreateDoubleMatrix(0,0,mxREAL); } return out; }
/* ************************************************************ PROCEDURE mexFunction - Entry for Matlab y = fwblksolve(L,b, [y]) y = L.L \ b(L.perm) ************************************************************ */ void mexFunction(const int nlhs, mxArray *plhs[], const int nrhs, const mxArray *prhs[]) { const mxArray *L_FIELD; mwIndex m,n, j, k, nsuper, inz; double *y,*fwork; const double *permPr, *b, *xsuperPr; const mwIndex *yjc, *yir, *bjc, *bir; mwIndex *perm, *invperm, *snode, *xsuper, *iwork; jcir L; char bissparse; /* ------------------------------------------------------------ Check for proper number of arguments ------------------------------------------------------------ */ mxAssert(nrhs >= MINNPARIN, "fwblkslv requires more input arguments."); mxAssert(nlhs <= NPAROUT, "fwblkslv generates only 1 output argument."); /* ------------------------------------------------------------ Disassemble block Cholesky structure L ------------------------------------------------------------ */ mxAssert(mxIsStruct(L_IN), "Parameter `L' should be a structure."); if( (L_FIELD = mxGetField(L_IN,(mwIndex)0,"perm")) == NULL) /* L.perm */ mexErrMsgTxt("Missing field L.perm."); m = mxGetM(L_FIELD) * mxGetN(L_FIELD); permPr = mxGetPr(L_FIELD); if( (L_FIELD = mxGetField(L_IN,(mwIndex)0,"L")) == NULL) /* L.L */ mexErrMsgTxt("Missing field L.L."); if( m != mxGetM(L_FIELD) || m != mxGetN(L_FIELD) ) mexErrMsgTxt("Size L.L mismatch."); if(!mxIsSparse(L_FIELD)) mexErrMsgTxt("L.L should be sparse."); L.jc = mxGetJc(L_FIELD); L.ir = mxGetIr(L_FIELD); L.pr = mxGetPr(L_FIELD); if( (L_FIELD = mxGetField(L_IN,(mwIndex)0,"xsuper")) == NULL) /* L.xsuper */ mexErrMsgTxt("Missing field L.xsuper."); nsuper = mxGetM(L_FIELD) * mxGetN(L_FIELD) - 1; if( nsuper > m ) mexErrMsgTxt("Size L.xsuper mismatch."); xsuperPr = mxGetPr(L_FIELD); /* ------------------------------------------------------------ Get rhs matrix b. If it is sparse, then we also need the sparsity structure of y. ------------------------------------------------------------ */ b = mxGetPr(B_IN); if( mxGetM(B_IN) != m ) mexErrMsgTxt("Size mismatch b."); n = mxGetN(B_IN); if( (bissparse = mxIsSparse(B_IN)) ){ bjc = mxGetJc(B_IN); bir = mxGetIr(B_IN); if(nrhs < NPARIN) mexErrMsgTxt("fwblkslv requires more inputs in case of sparse b."); if(mxGetM(Y_IN) != m || mxGetN(Y_IN) != n) mexErrMsgTxt("Size mismatch y."); if(!mxIsSparse(Y_IN)) mexErrMsgTxt("y should be sparse."); } /* ------------------------------------------------------------ Allocate output y. If bissparse, then Y_IN gives the sparsity structure. ------------------------------------------------------------ */ if(!bissparse) Y_OUT = mxCreateDoubleMatrix(m, n, mxREAL); else{ yjc = mxGetJc(Y_IN); yir = mxGetIr(Y_IN); Y_OUT = mxCreateSparse(m,n, yjc[n],mxREAL); memcpy(mxGetJc(Y_OUT), yjc, (n+1) * sizeof(mwIndex)); memcpy(mxGetIr(Y_OUT), yir, yjc[n] * sizeof(mwIndex)); } y = mxGetPr(Y_OUT); /* ------------------------------------------------------------ Allocate working arrays fwork(m) and iwork(2*m + nsuper+1) ------------------------------------------------------------ */ fwork = (double *) mxCalloc(m, sizeof(double)); iwork = (mwIndex *) mxCalloc(2*m+nsuper+1, sizeof(mwIndex)); perm = iwork; invperm = perm; xsuper = iwork + m; snode = xsuper + (nsuper+1); /* ------------------------------------------------------------ Convert real to integer array, and from Fortran to C style. In case of sparse b, we store the inverse perm, instead of perm itself. ------------------------------------------------------------ */ for(k = 0; k <= nsuper; k++) xsuper[k] = xsuperPr[k] - 1; if(!bissparse) for(k = 0; k < m; k++) /* Get perm if !bissparse */ perm[k] = permPr[k] - 1; else{ for(k = 0; k < m; k++){ /* Get invperm if bissparse */ j = permPr[k]; invperm[--j] = k; } /* ------------------------------------------------------------ In case of sparse b, we also create snode, which maps each subnode to the supernode containing it. ------------------------------------------------------------ */ for(j = 0, k = 0; k < nsuper; k++) while(j < xsuper[k+1]) snode[j++] = k; } /* ------------------------------------------------------------ The actual job is done here: y = L\b(perm). ------------------------------------------------------------ */ if(!bissparse) for(j = 0; j < n; j++){ for(k = 0; k < m; k++) /* y = b(perm) */ y[k] = b[perm[k]]; fwsolve(y,L.jc,L.ir,L.pr,xsuper,nsuper,fwork); y += m; b += m; } else for(j = 0, inz = 0; j < n; j++){ for(k = inz; k < yjc[j+1]; k++) /* fwork = all-0 */ fwork[yir[k]] = 0.0; for(k = bjc[j]; k < bjc[j+1]; k++) /* fwork = b(perm) */ fwork[invperm[bir[k]]] = b[k]; selfwsolve(fwork,L.jc,L.ir,L.pr,xsuper,nsuper, snode, yir+inz,yjc[j+1]-inz); for(; inz < yjc[j+1]; inz++) y[inz] = fwork[yir[inz]]; } /* ------------------------------------------------------------ RELEASE WORKING ARRAYS. ------------------------------------------------------------ */ mxFree(iwork); mxFree(fwork); }
const char *model_to_matlab_structure(mxArray *plhs[], int num_of_feature, struct svm_model *model) { int i, j, n; SVM_REAL *ptr; mxArray *return_model, **rhs; int out_id = 0; rhs = (mxArray **)mxMalloc(sizeof(mxArray *)*NUM_OF_RETURN_FIELD); /* Parameters */ #ifdef _ALL_FLOAT rhs[out_id] = mxCreateNumericMatrix(5, 1, mxSINGLE_CLASS, mxREAL); ptr = (float *) mxGetData(rhs[out_id]); #else rhs[out_id] = mxCreateDoubleMatrix(5, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); #endif ptr[0] = (SVM_REAL)model->param.svm_type; ptr[1] = (SVM_REAL)model->param.kernel_type; ptr[2] = (SVM_REAL)model->param.degree; ptr[3] = model->param.gamma; ptr[4] = model->param.coef0; out_id++; /* nr_class */ #ifdef _ALL_FLOAT rhs[out_id] = mxCreateNumericMatrix(1, 1, mxSINGLE_CLASS,mxREAL); ptr = (float *) mxGetData(rhs[out_id]); #else rhs[out_id] = mxCreateDoubleMatrix(1, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); #endif ptr[0] = (SVM_REAL)model->nr_class; out_id++; /* total SV */ #ifdef _ALL_FLOAT rhs[out_id] = mxCreateNumericMatrix(1, 1, mxSINGLE_CLASS,mxREAL); ptr = (float *) mxGetData(rhs[out_id]); #else rhs[out_id] = mxCreateDoubleMatrix(1, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); #endif ptr[0] = (SVM_REAL)model->l; out_id++; /* rho */ n = model->nr_class*(model->nr_class-1)/2; #ifdef _ALL_FLOAT rhs[out_id] = mxCreateNumericMatrix(n, 1, mxSINGLE_CLASS,mxREAL); ptr = (float *) mxGetData(rhs[out_id]); #else rhs[out_id] = mxCreateDoubleMatrix(n, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); #endif for(i = 0; i < n; i++) ptr[i] = model->rho[i]; out_id++; /* Label */ if(model->label) { #ifdef _ALL_FLOAT rhs[out_id] = mxCreateNumericMatrix(model->nr_class, 1, mxSINGLE_CLASS,mxREAL); ptr = (float *) mxGetData(rhs[out_id]); #else rhs[out_id] = mxCreateDoubleMatrix(model->nr_class, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); #endif for(i = 0; i < model->nr_class; i++) ptr[i] = (SVM_REAL)model->label[i]; } else #ifdef _ALL_FLOAT rhs[out_id] = mxCreateNumericMatrix(0, 0, mxSINGLE_CLASS,mxREAL); #else rhs[out_id] = mxCreateDoubleMatrix(0, 0, mxREAL); #endif out_id++; /* probA */ if(model->probA != NULL) { #ifdef _ALL_FLOAT rhs[out_id] = mxCreateNumericMatrix(n, 1, mxSINGLE_CLASS,mxREAL); ptr = (float *) mxGetData(rhs[out_id]); #else rhs[out_id] = mxCreateDoubleMatrix(n, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); #endif for(i = 0; i < n; i++) ptr[i] = model->probA[i]; } else #ifdef _ALL_FLOAT rhs[out_id] = mxCreateNumericMatrix(0, 0, mxSINGLE_CLASS,mxREAL); #else rhs[out_id] = mxCreateDoubleMatrix(0, 0, mxREAL); #endif out_id ++; /* probB */ if(model->probB != NULL) { #ifdef _ALL_FLOAT rhs[out_id] = mxCreateNumericMatrix(n, 1, mxSINGLE_CLASS,mxREAL); ptr = (float *) mxGetData(rhs[out_id]); #else rhs[out_id] = mxCreateDoubleMatrix(n, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); #endif for(i = 0; i < n; i++) ptr[i] = model->probB[i]; } else #ifdef _ALL_FLOAT rhs[out_id] = mxCreateNumericMatrix(0, 0, mxSINGLE_CLASS,mxREAL); #else rhs[out_id] = mxCreateDoubleMatrix(0, 0, mxREAL); #endif out_id++; /* nSV */ if(model->nSV) { #ifdef _ALL_FLOAT rhs[out_id] = mxCreateNumericMatrix(model->nr_class, 1, mxSINGLE_CLASS,mxREAL); ptr = (float *) mxGetData(rhs[out_id]); #else rhs[out_id] = mxCreateDoubleMatrix(model->nr_class, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); #endif for(i = 0; i < model->nr_class; i++) ptr[i] = (SVM_REAL)model->nSV[i]; } else #ifdef _ALL_FLOAT rhs[out_id] = mxCreateNumericMatrix(0, 0, mxSINGLE_CLASS,mxREAL); #else rhs[out_id] = mxCreateDoubleMatrix(0, 0, mxREAL); #endif out_id++; /* sv_coef */ #ifdef _ALL_FLOAT rhs[out_id] = mxCreateNumericMatrix(model->l, model->nr_class-1, mxSINGLE_CLASS,mxREAL); ptr = (float *) mxGetData(rhs[out_id]); #else rhs[out_id] = mxCreateDoubleMatrix(model->l, model->nr_class-1, mxREAL); ptr = mxGetPr(rhs[out_id]); #endif for(i = 0; i < model->nr_class-1; i++) for(j = 0; j < model->l; j++) ptr[(i*(model->l))+j] = model->sv_coef[i][j]; out_id++; /* SVs */ { #ifdef _DENSE_REP #ifdef _ALL_FLOAT rhs[out_id] = mxCreateNumericMatrix(model->l, num_of_feature, mxSINGLE_CLASS,mxREAL); ptr = (float *) mxGetData(rhs[out_id]); #else rhs[out_id] = mxCreateDoubleMatrix(model->l, num_of_feature, mxREAL); ptr = mxGetPr(rhs[out_id]); #endif for(i=0;i < num_of_feature;i++) for(j=0;j < model->l;j++) ptr[(i*(model->l))+j] = model->SV[j].values[i]; #else int ir_index, nonzero_element; mwIndex *ir, *jc; mxArray *pprhs[1], *pplhs[1]; if(model->param.kernel_type == PRECOMPUTED) { nonzero_element = model->l; num_of_feature = 1; } else { nonzero_element = 0; for(i = 0; i < model->l; i++) { j = 0; while(model->SV[i][j].index != -1) { nonzero_element++; j++; } } } /* SV in column, easier accessing */ double *ptr2; rhs[out_id] = mxCreateSparse(num_of_feature, model->l, nonzero_element, mxREAL); ptr2 = mxGetPr(rhs[out_id]); ir = mxGetIr(rhs[out_id]); jc = mxGetJc(rhs[out_id]); jc[0] = ir_index = 0; for(i = 0;i < model->l; i++) { if(model->param.kernel_type == PRECOMPUTED) { /* make a (1 x model->l) matrix */ ir[ir_index] = 0; ptr2[ir_index] = model->SV[i][0].value; ir_index++; jc[i+1] = jc[i] + 1; } else { int x_index = 0; while (model->SV[i][x_index].index != -1) { ir[ir_index] = model->SV[i][x_index].index - 1; ptr2[ir_index] = model->SV[i][x_index].value; ir_index++, x_index++; } jc[i+1] = jc[i] + x_index; } } /* transpose back to SV in row */ pprhs[0] = rhs[out_id]; if(mexCallMATLAB(1, pplhs, 1, pprhs, "transpose")) return "cannot transpose SV matrix"; rhs[out_id] = pplhs[0]; #endif out_id++; } #ifdef _USE_CHI_SQUARE rhs[out_id] = mxCreateString(model->param.feat_parm_text); #endif /* Create a struct matrix contains NUM_OF_RETURN_FIELD fields */ return_model = mxCreateStructMatrix(1, 1, NUM_OF_RETURN_FIELD, field_names); /* Fill struct matrix with input arguments */ for(i = 0; i < NUM_OF_RETURN_FIELD; i++) mxSetField(return_model,0,field_names[i],mxDuplicateArray(rhs[i])); /* return */ plhs[0] = return_model; mxFree(rhs); return NULL; }
/* ************************************************************ PROCEDURE mexFunction - Entry for Matlab ************************************************************ */ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { const mxArray *L_FIELD; mwIndex maxnnz, i,j, nsuper,m,n; const mwIndex *ljc,*lir,*bjc,*bir; mwIndex *xjc,*xir, *snode,*xlindx,*lindx, *iwork,*xsuper, *invperm; bool *cwork; double *xpr; const double *permPr, *xsuperPr; /* ------------------------------------------------------------ Check for proper number of arguments ------------------------------------------------------------ */ mxAssert(nrhs >= NPARIN, "symbfwblk requires more input arguments"); mxAssert(nlhs <= NPAROUT, "symbfwblk produces 1 output argument"); /* ------------------------------------------------------------ Get rhs-input B ------------------------------------------------------------ */ mxAssert(mxIsSparse(B_IN), "B must be sparse"); m = mxGetM(B_IN); n = mxGetN(B_IN); bjc = mxGetJc(B_IN); bir = mxGetIr(B_IN); /* ------------------------------------------------------------ Disassemble block Cholesky structure L ------------------------------------------------------------ */ mxAssert(mxIsStruct(L_IN), "Parameter `L' should be a structure."); L_FIELD = mxGetField(L_IN,(mwIndex)0,"perm"); mxAssert( L_FIELD != NULL, "Missing field L.perm."); /* L.perm */ mxAssert(m == mxGetM(L_FIELD) * mxGetN(L_FIELD), "L.perm size mismatches B"); permPr = mxGetPr(L_FIELD); L_FIELD = mxGetField(L_IN,(mwIndex)0,"L"); mxAssert( L_FIELD!= NULL, "Missing field L.L."); /* L.L */ mxAssert( m == mxGetM(L_FIELD) && m == mxGetN(L_FIELD), "Size L.L mismatch."); mxAssert(mxIsSparse(L_FIELD), "L.L should be sparse."); ljc = mxGetJc(L_FIELD); lir = mxGetIr(L_FIELD); L_FIELD = mxGetField(L_IN,(mwIndex)0,"xsuper"); mxAssert( L_FIELD!= NULL, "Missing field L.xsuper."); /* L.xsuper */ nsuper = mxGetM(L_FIELD) * mxGetN(L_FIELD) - 1; mxAssert( nsuper <= m , "Size L.xsuper mismatch."); xsuperPr = mxGetPr(L_FIELD); /* ------------------------------------------------------------ Allocate mwIndex-part of sparse output matrix X(m x n) Heuristically set nnz to nnz(B) + 4*m. ------------------------------------------------------------ */ maxnnz = bjc[n] + 4 * m; xjc = (mwIndex *) mxCalloc(n + 1, sizeof(mwIndex)); xir = (mwIndex *) mxCalloc(maxnnz, sizeof(mwIndex)); /* ------------------------------------------------------------ Allocate working arrays: mwIndex invperm(m), snode(m), xsuper(nsuper+1), xlindx(nsuper+1), lindx(nnz(L)), iwork(nsuper). char cwork(nsuper). ------------------------------------------------------------ */ invperm = (mwIndex *) mxCalloc(m,sizeof(mwIndex)); snode = (mwIndex *) mxCalloc(m,sizeof(mwIndex)); xsuper = (mwIndex *) mxCalloc(nsuper+1,sizeof(mwIndex)); xlindx = (mwIndex *) mxCalloc(nsuper+1,sizeof(mwIndex)); lindx = (mwIndex *) mxCalloc(ljc[m], sizeof(mwIndex)); iwork = (mwIndex *) mxCalloc(nsuper, sizeof(mwIndex)); cwork = (bool *) mxCalloc(nsuper, sizeof(bool)); /* ------------------------------------------------------------ Convert PERM, XSUPER to integer and C-Style ------------------------------------------------------------ */ for(i = 0; i < m; i++){ j = (mwIndex) permPr[i]; mxAssert(j>0,""); invperm[--j] = i; /* so that invperm[perm[i]] = i */ } for(i = 0; i <= nsuper; i++){ j = (mwIndex) xsuperPr[i]; mxAssert(j>0,""); xsuper[i] = --j; } /* ------------------------------------------------------------ Create "snode" from xsuper, and get compact subscript (xlindx,lindx) from (ljc,lir,xsuper), i.e. nz-pattern per supernode. ------------------------------------------------------------ */ snodeCompress(xlindx,lindx,snode, ljc,lir,xsuper,nsuper); /* ------------------------------------------------------------ Compute nz structure after forward solve ------------------------------------------------------------ */ symbfwmat(xjc, &xir, &maxnnz, bjc, bir, invperm, snode, xsuper, xlindx, lindx, nsuper, m, n, iwork, cwork); /* ------------------------------------------------------------ Create output matrix x ------------------------------------------------------------ */ X_OUT = mxCreateSparse(m,n, (mwSize)1,mxREAL); mxFree(mxGetJc(X_OUT)); /* jc */ mxFree(mxGetIr(X_OUT)); /* ir */ mxFree(mxGetPr(X_OUT)); /* pr */ xpr = (double *) mxCalloc(maxnnz,sizeof(double)); mxSetJc(X_OUT, xjc); mxSetIr(X_OUT, xir); mxSetPr(X_OUT, xpr); mxSetNzmax(X_OUT, maxnnz); for(i = 0; i < maxnnz; i++) xpr[i] = 1.0; /* ------------------------------------------------------------ Release working arrays. ------------------------------------------------------------ */ mxFree(cwork); mxFree(iwork); mxFree(lindx); mxFree(xlindx); mxFree(xsuper); mxFree(snode); mxFree(invperm); }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { mxArray *blk_cell_pr; double *A, *B, *AI, *BI, *blksize; mwIndex *irA, *jcA, *irB, *jcB; int *cumblksize, *blknnz; int mblk, isspA, isspB, iscmpA; mwIndex subs[2]; mwSize nsubs=2; int m, n, n2, nsub, k, index, numblk, NZmax, type; double r2; /* CHECK FOR PROPER NUMBER OF ARGUMENTS */ if (nrhs < 2){ mexErrMsgTxt("mexsvec: requires at least 2 input arguments."); } if (nlhs > 1){ mexErrMsgTxt("mexsvec: requires 1 output argument."); } /* CHECK THE DIMENSIONS */ mblk = mxGetM(prhs[0]); if (mblk > 1) { mexErrMsgTxt("mexsvec: blk can have only 1 row."); } m = mxGetM(prhs[1]); n = mxGetN(prhs[1]); if (m != n) { mexErrMsgTxt("mexsvec: matrix must be square."); } subs[0] = 0; subs[1] = 1; index = mxCalcSingleSubscript(prhs[0],nsubs,subs); blk_cell_pr = mxGetCell(prhs[0],index); numblk = mxGetN(blk_cell_pr); blksize = mxGetPr(blk_cell_pr); if (numblk == 1) { n2 = n*(n+1)/2; } else { cumblksize = mxCalloc(numblk+1,sizeof(int)); blknnz = mxCalloc(numblk+1,sizeof(int)); cumblksize[0] = 0; blknnz[0] = 0; n = 0; n2 = 0; for (k=0; k<numblk; ++k) { nsub = (int) blksize[k]; n += nsub; n2 += nsub*(nsub+1)/2; cumblksize[k+1] = n; blknnz[k+1] = n2; } } /***** assign pointers *****/ A = mxGetPr(prhs[1]); isspA = mxIsSparse(prhs[1]); iscmpA = mxIsComplex(prhs[1]); if (isspA) { irA = mxGetIr(prhs[1]); jcA = mxGetJc(prhs[1]); NZmax = mxGetNzmax(prhs[1]); } else { NZmax = n2; } if (iscmpA) { AI = mxGetPi(prhs[1]); } if ((numblk > 1) & (!isspA)) { mexErrMsgTxt("mexsvec: matrix must be sparse for numblk > 1"); } if (nrhs > 2) { if (mxGetM(prhs[2])>1) { isspB = (int)*mxGetPr(prhs[2]); } else if (NZmax < n2/2) { isspB = 1; } else { isspB = 0; } } else { if (NZmax < n2/2) { isspB = 1; } else { isspB = 0; } } if (nrhs > 3) { type = (int)*mxGetPr(prhs[3]); } else { type = 0; } /***** create return argument *****/ if (isspB) { if (iscmpA) { plhs[0] = mxCreateSparse(n2,1,NZmax,mxCOMPLEX); } else { plhs[0] = mxCreateSparse(n2,1,NZmax,mxREAL); } B = mxGetPr(plhs[0]); irB = mxGetIr(plhs[0]); jcB = mxGetJc(plhs[0]); jcB[0] = 0; } else { if (iscmpA) { plhs[0] = mxCreateDoubleMatrix(n2,1,mxCOMPLEX); } else { plhs[0] = mxCreateDoubleMatrix(n2,1,mxREAL); } B = mxGetPr(plhs[0]); } if (iscmpA) { BI = mxGetPi(plhs[0]); } /***** Do the computations in a subroutine *****/ r2 = sqrt(2); if (type == 0) { if (iscmpA) { if (numblk == 1) { svec1cmp(n,r2,A,irA,jcA,isspA,B,irB,jcB,isspB,AI,BI); } else { svec2cmp(n,numblk,cumblksize,blknnz,r2,A,irA,jcA,isspA,B,irB,jcB,isspB,AI,BI); } } else { if (numblk == 1) { svec1(n,r2,A,irA,jcA,isspA,B,irB,jcB,isspB); } else { svec2(n,numblk,cumblksize,blknnz,r2,A,irA,jcA,isspA,B,irB,jcB,isspB); } } } else { if (iscmpA) { if (numblk == 1) { svec3cmp(n,r2,A,irA,jcA,isspA,B,irB,jcB,isspB,AI,BI); } else { svec4cmp(n,numblk,cumblksize,blknnz,r2,A,irA,jcA,isspA,B,irB,jcB,isspB,AI,BI); } } else { if (numblk == 1) { svec3(n,r2,A,irA,jcA,isspA,B,irB,jcB,isspB); } else { svec4(n,numblk,cumblksize,blknnz,r2,A,irA,jcA,isspA,B,irB,jcB,isspB); } } } return; }