/* return a complex sparse matrix to MATLAB */
mxArray *cs_cl_mex_put_sparse (cs_cl **Ahandle)
{
cs_cl *A ;
double *x, *z ;
mxArray *Amatlab ;
CS_INT k ;
A = *Ahandle ;
if (!A) mexErrMsgTxt ("failed") ;
Amatlab = mxCreateSparse (0, 0, 0, mxCOMPLEX) ;
mxSetM (Amatlab, A->m) ;
mxSetN (Amatlab, A->n) ;
mxSetNzmax (Amatlab, A->nzmax) ;
cs_cl_free (mxGetJc (Amatlab)) ;
cs_cl_free (mxGetIr (Amatlab)) ;
cs_cl_free (mxGetPr (Amatlab)) ;
cs_cl_free (mxGetPi (Amatlab)) ;
mxSetJc (Amatlab, (void *) (A->p)) ; /* assign A->p pointer to MATLAB A */
mxSetIr (Amatlab, (void *) (A->i)) ;
x = cs_dl_malloc (A->nzmax, sizeof (double)) ;
z = cs_dl_malloc (A->nzmax, sizeof (double)) ;
for (k = 0 ; k < A->nzmax ; k++)
{
x [k] = creal (A->x [k]) ; /* copy and split numerical values */
z [k] = cimag (A->x [k]) ;
}
cs_cl_free (A->x) ; /* free copy of complex values */
mxSetPr (Amatlab, x) ;
mxSetPi (Amatlab, z) ;
cs_cl_free (A) ; /* frees A struct only, not A->p, etc */
*Ahandle = NULL ;
return (Amatlab) ;
}
mxArray *spqr_mx_put_sparse
(
cholmod_sparse **Ahandle, // CHOLMOD version of the matrix
cholmod_common *cc
)
{
mxArray *Amatlab ;
cholmod_sparse *A ;
Long nz, is_complex ;
A = *Ahandle ;
is_complex = (A->xtype != CHOLMOD_REAL) ;
Amatlab = mxCreateSparse (0, 0, 0, is_complex ? mxCOMPLEX: mxREAL) ;
mxSetM (Amatlab, A->nrow) ;
mxSetN (Amatlab, A->ncol) ;
mxSetNzmax (Amatlab, A->nzmax) ;
mxFree (mxGetJc (Amatlab)) ;
mxFree (mxGetIr (Amatlab)) ;
mxFree (mxGetPr (Amatlab)) ;
mxSetJc (Amatlab, (mwIndex *) A->p) ;
mxSetIr (Amatlab, (mwIndex *) A->i) ;
nz = cholmod_l_nnz (A, cc) ;
put_values (nz, Amatlab, (double *) A->x, is_complex, cc) ;
A->p = NULL ;
A->i = NULL ;
A->x = NULL ;
A->z = NULL ;
cholmod_l_free_sparse (Ahandle, cc) ;
return (Amatlab) ;
}
int mfiles_cs2mx(const cs *in, mxArray *out) {
if (!out) {
return EXIT_FAILURE;
}
mxSetM(out, in->m);
mxSetN(out, in->n);
mxSetNzmax(out, in->nzmax);
mxSetJc(out, (mwIndex *) in->p);
mxSetIr(out, (mwIndex *) in->i);
mxSetPr(out, in->x);
return EXIT_SUCCESS;
}
void reset_nzmax(mxArray *spArray, const int old_nzmax, const int new_nzmax){
double *ptr;
void *newptr;
int *ir, *jc;
int nbytes;
if(new_nzmax == old_nzmax) return;
nbytes = new_nzmax * sizeof(*ptr);
ptr = mxGetPr(spArray);
newptr = mxRealloc(ptr, nbytes);
mxSetPr(spArray, newptr);
nbytes = new_nzmax * sizeof(*ir);
ir = mxGetIr(spArray);
newptr = mxRealloc(ir, nbytes);
mxSetIr(spArray, newptr);
jc = mxGetJc(spArray);
jc[0] = 0;
jc[1] = new_nzmax;
mxSetNzmax(spArray, new_nzmax);
}
/* return a real sparse matrix to MATLAB */
mxArray *cs_dl_mex_put_sparse (cs_dl **Ahandle)
{
cs_dl *A ;
mxArray *Amatlab ;
A = *Ahandle ;
if (!A) mexErrMsgTxt ("failed") ;
Amatlab = mxCreateSparse (0, 0, 0, mxREAL) ;
mxSetM (Amatlab, A->m) ;
mxSetN (Amatlab, A->n) ;
mxSetNzmax (Amatlab, A->nzmax) ;
cs_free (mxGetJc (Amatlab)) ;
cs_free (mxGetIr (Amatlab)) ;
cs_free (mxGetPr (Amatlab)) ;
mxSetJc (Amatlab, (void *) (A->p)) ; /* assign A->p pointer to MATLAB A */
mxSetIr (Amatlab, (void *) (A->i)) ;
mxSetPr (Amatlab, A->x) ;
cs_free (A) ; /* frees A struct only, not A->p, etc */
*Ahandle = NULL ;
return (Amatlab) ;
}
/* return a sparse matrix to MATLAB */
mxArray *cs_mex_put_sparse (cs **Ahandle)
{
cs *A ;
mxArray *Amatlab ;
A = *Ahandle ;
Amatlab = mxCreateSparse (0, 0, 0, mxREAL) ;
mxSetM (Amatlab, A->m) ;
mxSetN (Amatlab, A->n) ;
mxSetNzmax (Amatlab, A->nzmax) ;
cs_free (mxGetJc (Amatlab)) ;
cs_free (mxGetIr (Amatlab)) ;
cs_free (mxGetPr (Amatlab)) ;
mxSetJc (Amatlab, A->p) ; /* assign A->p pointer to MATLAB A */
mxSetIr (Amatlab, A->i) ;
mxSetPr (Amatlab, A->x) ;
mexMakeMemoryPersistent (A->p) ; /* ensure MATLAB does not free A->p */
mexMakeMemoryPersistent (A->i) ;
mexMakeMemoryPersistent (A->x) ;
cs_free (A) ; /* frees A struct only, not A->p, etc */
*Ahandle = NULL ;
return (Amatlab) ;
}
void SetColumnDoubleSparseMatrix(rMatrix plhs[], int element, int m, int n, double *mat, int column, double *arry, int *index, int size, int *nz)
{
int *jcs, *irs, i, ii, nzmax;
double *sr, a;
jcs = mxGetJc(plhs[element]);
irs = mxGetIr(plhs[element]);
sr = mxGetPr(plhs[element]);
if (m > n)
nzmax = m;
else
nzmax = n;
if (nzmax < 10)
nzmax = 10;
jcs[column - 1] = *nz;
for (i = 0; (i < size); i++) {
a = arry[i];
if (a) {
if (index == NULL)
ii = i;
else
ii = index[i] - 1;
if ((*nz != 0) && (((*nz) % nzmax) == 0)) {
mxSetNzmax(plhs[element], *nz + nzmax);
mxSetPr(plhs[element], matRealloc(sr, (*nz + nzmax) * sizeof(double)));
mxSetIr(plhs[element], matRealloc(irs, (*nz + nzmax) * sizeof(int)));
jcs = mxGetJc(plhs[element]);
irs = mxGetIr(plhs[element]);
sr = mxGetPr(plhs[element]);
}
sr[*nz] = a;
irs[*nz] = ii;
(*nz)++;
}
}
jcs[column] = *nz;
}
void mexFunction(int nlhs,mxArray *plhs[],int nrhs,const mxArray *prhs[])
{
double *m_w_d, *p_w_z, *p_z_d, *p_w_d;
mwIndex *ir, *jc;
size_t d, k;
size_t n_w, n_d, n_z;
mwSize ndim = 1, dims[1];
mwSize nsubs = 1;
mxArray *temp_array;
double *temp;
size_t beg_row_id, end_row_id, cur_row_id;
mwIndex index, subs[1];
mwIndex *beg_of_ir, *beg_of_jc;
mwSize nzmax;
size_t total = 0;
if(!mxIsSparse(prhs[0]))
{
printf("word-doc matrix should be sparse matrix\n");
return;
}
else if(nrhs != 4 || nlhs != 1)
{
printf("usage: p_z_wd = mex_Estep_sparse(m_w_d, p_w_z_n, p_z_d_n, p_w_d)\n");
return;
}
m_w_d = mxGetPr(prhs[0]);
jc = mxGetJc(prhs[0]);
ir = mxGetIr(prhs[0]);
nzmax = mxGetNzmax(prhs[0]);
n_w = mxGetM(prhs[0]);
n_d = mxGetN(prhs[0]);
p_w_z = mxGetPr(prhs[1]);
n_z = mxGetN(prhs[1]);
p_z_d = mxGetPr(prhs[2]);
p_w_d = mxGetPr(prhs[3]);
dims[0] = n_z;
plhs[0] = mxCreateCellArray(ndim, dims);
//total_num_of_cells = mxGetNumberOfElements(plhs[0]);
for(k = 0; k < n_z; k++)
{
total = 0;
subs[0] = k;
index = mxCalcSingleSubscript(plhs[0], nsubs, subs);
temp_array = mxCreateSparse(n_w, n_d, nzmax, mxREAL);
temp = mxGetPr(temp_array);
mxSetNzmax(temp_array, nzmax);
//Place ir data into the newly created sparse array.
beg_of_ir = mxGetIr(temp_array);
memcpy(beg_of_ir, ir, nzmax * sizeof(mwIndex));
//Place jc data into the newly created sparse array.
beg_of_jc = mxGetJc(temp_array);
memcpy(beg_of_jc, jc, (n_d + 1) * sizeof(mwIndex));
for (d = 0; d < n_d; d++)
{
beg_row_id = jc[d];
end_row_id = jc[d + 1];
if (beg_row_id == end_row_id)
continue;
else
{
for (cur_row_id = beg_row_id; cur_row_id < end_row_id; cur_row_id++)
{
temp[total] = p_w_z[k * n_w + ir[cur_row_id]] * p_z_d[d * n_z + k] / p_w_d[total];
total++;
}
}
}
mxSetCell(plhs[0], index, temp_array);
}
return;
}
mxArray *ssmult_transpose // returns C = A' or A.'
(
const mxArray *A,
int conj // compute A' if true, compute A.' if false
)
{
Int *Cp, *Ci, *Ap, *Ai, *W ;
double *Cx, *Cz, *Ax, *Az ; // (TO DO): do single too
mxArray *C ;
Int p, pend, q, i, j, n, m, anz, cnz ;
int C_is_complex ;
//--------------------------------------------------------------------------
// get inputs
//--------------------------------------------------------------------------
m = mxGetM (A) ;
n = mxGetN (A) ;
Ap = mxGetJc (A) ;
Ai = mxGetIr (A) ;
Ax = mxGetPr (A) ;
Az = mxGetPi (A) ;
anz = Ap [n] ;
C_is_complex = mxIsComplex (A) ;
//--------------------------------------------------------------------------
// allocate C but do not initialize it
//--------------------------------------------------------------------------
cnz = MAX (anz, 1) ;
C = mxCreateSparse (0, 0, 0, C_is_complex ? mxCOMPLEX : mxREAL) ;
MXFREE (mxGetJc (C)) ;
MXFREE (mxGetIr (C)) ;
MXFREE (mxGetPr (C)) ;
MXFREE (mxGetPi (C)) ;
Cp = mxMalloc ((m+1) * sizeof (Int)) ;
Ci = mxMalloc (MAX (cnz,1) * sizeof (Int)) ;
Cx = mxMalloc (MAX (cnz,1) * sizeof (double)) ;
Cz = C_is_complex ? mxMalloc (MAX (cnz,1) * sizeof (double)) : NULL ;
mxSetJc (C, Cp) ;
mxSetIr (C, Ci) ;
mxSetPr (C, Cx) ;
mxSetPi (C, Cz) ;
mxSetNzmax (C, cnz) ;
mxSetM (C, n) ;
mxSetN (C, m) ;
//--------------------------------------------------------------------------
// allocate workspace
//--------------------------------------------------------------------------
W = mxCalloc (MAX (m,1), sizeof (Int)) ;
//--------------------------------------------------------------------------
// compute row counts
//--------------------------------------------------------------------------
for (p = 0 ; p < anz ; p++)
{
W [Ai [p]]++ ;
}
//--------------------------------------------------------------------------
// compute column pointers of C and copy back into W
//--------------------------------------------------------------------------
for (p = 0, i = 0 ; i < m ; i++)
{
Cp [i] = p ;
p += W [i] ;
W [i] = Cp [i] ;
}
Cp [m] = p ;
//--------------------------------------------------------------------------
// C = A'
//--------------------------------------------------------------------------
p = 0 ;
if (!C_is_complex)
{
// C = A' (real case)
for (j = 0 ; j < n ; j++)
{
pend = Ap [j+1] ;
for ( ; p < pend ; p++)
{
q = W [Ai [p]]++ ; // find position for C(j,i)
Ci [q] = j ; // place A(i,j) as entry C(j,i)
Cx [q] = Ax [p] ;
}
}
}
else if (conj)
{
// C = A' (complex conjugate)
for (j = 0 ; j < n ; j++)
{
pend = Ap [j+1] ;
for ( ; p < pend ; p++)
{
q = W [Ai [p]]++ ; // find position for C(j,i)
Ci [q] = j ; // place A(i,j) as entry C(j,i)
Cx [q] = Ax [p] ;
Cz [q] = -Az [p] ;
}
}
}
else
{
// C = A.' (complex case)
for (j = 0 ; j < n ; j++)
{
pend = Ap [j+1] ;
for ( ; p < pend ; p++)
{
q = W [Ai [p]]++ ; // find position for C(j,i)
Ci [q] = j ; // place A(i,j) as entry C(j,i)
Cx [q] = Ax [p] ;
Cz [q] = Az [p] ;
}
}
}
//--------------------------------------------------------------------------
// free workspace and return result
//--------------------------------------------------------------------------
MXFREE (W) ;
return (C) ;
}
/* ************************************************************
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);
}
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;
}
/* ************************************************************
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]);
}
int flip(mxArray *X, const mxArray *DL, const mxArray *A, const mxArray *dDL,
const mxArray *s, mwSize offset, mwSize T, const mxArray *h,
const mxArray *wws, const mxArray *wVs)
{
const mwSize *sz = mxGetDimensions(dDL);
mwSize D = sz[0], M = sz[1], p = sz[3], Ndt = sz[4];
mwSize N = mxGetM(DL);
mwSize Tdt = ceil((double) N / (double) Ndt);
mwSize lenh = mxGetM(h);
mwSize pad = (lenh - 1) / 2;
// find maximum
double *DLpr = mxGetPr(DL);
double max = 0, d;
int iMax = -1, jMax = -1;
for (mwSize j = 0; j != M; ++j) {
for (mwSize i = offset + 1; i != offset + T + 1; ++i) {
d = DLpr[N * j + i];
if (d >= max) {
max = d;
iMax = i;
jMax = j;
}
}
}
double Xij;
double *Xpr = mxGetPr(X), *Xpi = mxGetPi(X);
double *hpr = mxGetPr(h), *Apr = mxGetPr(A);
mwIndex *Xir = mxGetIr(X), *Xjc = mxGetJc(X);
double sgn;
if (max > 0) {
// find location in sparse array
double a = 0, r = 0;
int sub;
mwSize l = Xjc[jMax];
while (l != Xjc[jMax + 1] && Xir[l] <= iMax) {
if (Xir[l] == iMax) {
a = Xpr[l];
r = Xpi[l];
break;
} else {
++l;
}
}
if (a == 0) { // add spike - subsample
// determine amplitude and subsample shift
sgn = 1;
max = 0;
for (mwSize j = 0; j != p; ++j) {
double m = 0;
for (mwSize i = 0; i != lenh; ++i) {
m = m + DLpr[jMax * N + iMax - pad + i] * hpr[j * lenh + i];
}
if (m > max) {
sub = j;
max = m;
}
}
for (mwSize i = 0; i != lenh; ++i) {
a = a + Apr[N * jMax + iMax - pad + i] * hpr[sub * lenh + i];
}
r = (double) (sub - (int) p / 2) / (double) p; // CHECK
// grow sparse array if necessary
mwSize nzmax = mxGetNzmax(X);
if (Xjc[M] == nzmax) { // grow X
nzmax *= 2;
mxSetNzmax(X, nzmax);
Xir = (mwIndex*) mxRealloc(Xir, nzmax * sizeof(*Xir));
mxSetIr(X, Xir);
Xpr = (double*) mxRealloc(Xpr, nzmax * sizeof(*Xpr));
mxSetPr(X, Xpr);
Xpi = (double*) mxRealloc(Xpi, nzmax * sizeof(*Xpi));
mxSetPi(X, Xpi);
}
// add values to sparse array
// real: amplitude
// imag: subsample (> 0 => shift right, < 0 => shift left)
for (mwSize j = jMax; j != M; ++j) {
++Xjc[j + 1];
}
for (mwSize i = Xjc[M] - 1; i > l; --i) {
Xir[i] = Xir[i - 1];
Xpr[i] = Xpr[i - 1];
Xpi[i] = Xpi[i - 1];
}
Xir[l] = iMax;
Xpr[l] = a;
Xpi[l] = r;
} else { // remove spike
sgn = -1;
for (mwSize j = jMax + 1; j != M + 1; ++j) {
--Xjc[j];
}
for (; l != Xjc[M]; ++l) {
Xir[l] = Xir[l + 1];
Xpr[l] = Xpr[l + 1];
Xpi[l] = Xpi[l + 1];
}
}
// update change in posterior
double DLij = DLpr[N * jMax + iMax];
sub = (int) p / 2 - round(r * (double) p);
mwSize t = iMax / Tdt;
mwSize start = D * M * (jMax + M * (sub + p * t));
mwSize ii;
double dA;
double *dDLpr = mxGetPr(dDL), *wwspr = mxGetPr(wws),
*wVspr = mxGetPr(wVs), *spr = mxGetPr(s);
for (mwSize j = 0; j != M; ++j) {
for (mwSize i = 0; i != D; ++i) {
dA = dDLpr[start + D * j + i] * a * sgn / wwspr[Ndt * j + t];
ii = N * j + iMax + spr[i];
Apr[ii] = Apr[ii] - dA;
DLpr[ii] = DLpr[ii] - dA * (wVspr[ii] + a * dDLpr[start + D * j + i]);
DLpr[N * jMax + iMax] = -DLij;
}
}
} else {
iMax = -1;
}
return iMax;
}
/* ************************************************************
PROCEDURE mexFunction - Entry for Matlab
************************************************************ */
void mexFunction(const int nlhs, mxArray *plhs[],
const int nrhs, const mxArray *prhs[])
{
const mxArray *L_FIELD;
int maxnnz, i,j, nsuper,m,n;
const int *ljc,*lir,*bjc,*bir;
int *xjc,*xir, *snode,*snodebelow, *iwork,*xsuper;
char *cwork;
double *xpr;
const double *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,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,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 int-part of sparse output matrix X(m x n)
Heuristically set nnz to nnz(B) + 4*m.
------------------------------------------------------------ */
maxnnz = bjc[n] + 4 * m;
xjc = (int *) mxCalloc(n + 1, sizeof(int));
xir = (int *) mxCalloc(maxnnz, sizeof(int));
/* ------------------------------------------------------------
Allocate working arrays:
int snode(m), xsuper(nsuper+1), snodebelow(nsuper),
iwork(nsuper).
char cwork(nsuper+1).
------------------------------------------------------------ */
snode = (int *) mxCalloc(m,sizeof(int));
xsuper = (int *) mxCalloc(nsuper+1,sizeof(int));
snodebelow = (int *) mxCalloc(nsuper,sizeof(int));
iwork = (int *) mxCalloc(nsuper, sizeof(int));
cwork = (char *) mxCalloc(nsuper+1, sizeof(char));
/* ------------------------------------------------------------
Convert XSUPER to integer and C-Style
------------------------------------------------------------ */
for(i = 0; i <= nsuper; i++){
j = xsuperPr[i];
xsuper[i] = --j;
}
/* ------------------------------------------------------------
Create "snode" from xsuper, and get "first-below-diag"
supernodal subscript snodebelow (snodebelow[j]==nsuper means none).
This is enough to determine the nz-pattern of the backward-solve.
------------------------------------------------------------ */
getSnodeBelow(snodebelow,snode, ljc,lir,xsuper,nsuper);
/* ------------------------------------------------------------
Compute nz structure after backward solve
------------------------------------------------------------ */
symbbwmat(xjc, &xir, &maxnnz, bjc, bir, snode, xsuper,
snodebelow, nsuper, m, n, iwork, cwork);
/* ------------------------------------------------------------
Create output matrix x
------------------------------------------------------------ */
X_OUT = mxCreateSparse(m,n, 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(snodebelow);
mxFree(xsuper);
mxFree(snode);
}
void mexFunction
(
int nargout,
mxArray *pargout [ ],
int nargin,
const mxArray *pargin [ ]
)
{
Long *Ap, *Ai, *Zp, *Zi ;
double *Ax, *Az, *Zx ;
Long p, j, build_upper, zero_handling, nrow, ncol, mkind, skind, asize, znz,
status ;
char filename [LEN+1], title [73], key [9], mtype [4] ;
/* ---------------------------------------------------------------------- */
/* check inputs */
/* ---------------------------------------------------------------------- */
if (nargin != 1 || nargout > 5 || !mxIsChar (pargin [0]))
{
mexErrMsgTxt ("Usage: [A Z title key mtype] = RBread (filename)") ;
}
/* ---------------------------------------------------------------------- */
/* get filename */
/* ---------------------------------------------------------------------- */
if (mxGetString (pargin [0], filename, LEN) != 0)
{
mexErrMsgTxt ("filename too long") ;
}
/* ---------------------------------------------------------------------- */
/* read the matrix */
/* ---------------------------------------------------------------------- */
build_upper = TRUE ; /* always build upper tri. part */
zero_handling = (nargout > 1) ? 2 : 1 ; /* prune or extract zeros */
status = RBread (filename, build_upper, zero_handling, title, key, mtype,
&nrow, &ncol, &mkind, &skind, &asize, &znz,
&Ap, &Ai, &Ax, &Az, &Zp, &Zi) ;
if (status != RBIO_OK)
{
RBerror (status) ;
mexErrMsgTxt ("error reading file") ;
}
/* ---------------------------------------------------------------------- */
/* return A to MATLAB */
/* ---------------------------------------------------------------------- */
pargout [0] = mxCreateSparse (0, 0, 0, (mkind == 2) ? mxCOMPLEX : mxREAL) ;
mxFree (mxGetJc (pargout [0])) ;
mxFree (mxGetIr (pargout [0])) ;
mxFree (mxGetPr (pargout [0])) ;
if (mkind == 2) mxFree (mxGetPi (pargout [0])) ;
mxSetM (pargout [0], nrow) ;
mxSetN (pargout [0], ncol) ;
mxSetNzmax (pargout [0], asize) ;
mxSetJc (pargout [0], (mwIndex *) Ap) ;
mxSetIr (pargout [0], (mwIndex *) Ai) ;
mxSetPr (pargout [0], Ax) ;
if (mkind == 2) mxSetPi (pargout [0], Az) ;
/* ---------------------------------------------------------------------- */
/* return Z to MATLAB */
/* ---------------------------------------------------------------------- */
if (nargout > 1)
{
Zx = (double *) SuiteSparse_malloc (znz, sizeof (double)) ;
for (p = 0 ; p < znz ; p++)
{
Zx [p] = 1 ;
}
pargout [1] = mxCreateSparse (0, 0, 0, mxREAL) ;
mxFree (mxGetJc (pargout [1])) ;
mxFree (mxGetIr (pargout [1])) ;
mxFree (mxGetPr (pargout [1])) ;
mxSetM (pargout [1], nrow) ;
mxSetN (pargout [1], ncol) ;
mxSetNzmax (pargout [1], MAX (znz,1)) ;
mxSetJc (pargout [1], (mwIndex *) Zp) ;
mxSetIr (pargout [1], (mwIndex *) Zi) ;
mxSetPr (pargout [1], Zx) ;
}
/* ---------------------------------------------------------------------- */
/* return title */
/* ---------------------------------------------------------------------- */
if (nargout > 2)
{
pargout [2] = mxCreateString (title) ;
}
/* ---------------------------------------------------------------------- */
/* return key */
/* ---------------------------------------------------------------------- */
if (nargout > 3)
{
pargout [3] = mxCreateString (key) ;
}
/* ---------------------------------------------------------------------- */
/* return mtype */
/* ---------------------------------------------------------------------- */
if (nargout > 4)
{
pargout [4] = mxCreateString (mtype) ;
}
}
/* ************************************************************
PROCEDURE mexFunction - Entry for Matlab
************************************************************ */
void mexFunction(const int nlhs, mxArray *plhs[],
const int nrhs, const mxArray *prhs[])
{
mwIndex i,j,jnz,MAXN, m,dimflqr,lenfull,reallength, nf,nx,ns, iwsize;
mwIndex *iwork, *sdpNL, *cpxf, *cpxx, *cpxs, *cpxsi;
bool *cwork;
const double *cpxfPr, *cpxxPr, *cpxsPr, *xpi;
mxArray *MY_FIELD;
coneK cK;
jcir x,y;
/* ------------------------------------------------------------
Check for proper number of arguments
------------------------------------------------------------ */
mxAssert(nrhs >= NPARIN, "makereal requires more input arguments");
mxAssert(nlhs <= NPAROUT, "makereal produces less output arguments");
/* ------------------------------------------------------------
Disassemble cone K structure
------------------------------------------------------------ */
conepars(K_IN, &cK);
dimflqr = cK.frN + cK.lpN + cK.qDim;
for(i = 0; i < cK.rconeN; i++) /* add dim of rotated cone */
dimflqr += cK.rconeNL[i];
lenfull = dimflqr + cK.rDim + cK.hDim;
/* ------------------------------------------------------------
Disassemble cpx structure
------------------------------------------------------------ */
mxAssert(mxIsStruct(CPX_IN), "Parameter `cpx' should be a structure.");
if( (MY_FIELD = mxGetField(CPX_IN,(mwIndex)0,"f")) == NULL) /* cpx.f */
nf = 0;
else{
nf = mxGetM(MY_FIELD) * mxGetN(MY_FIELD);
cpxfPr = mxGetPr(MY_FIELD);
}
if( (MY_FIELD = mxGetField(CPX_IN,(mwIndex)0,"s")) == NULL) /* cpx.s */
ns = 0;
else{
ns = mxGetM(MY_FIELD) * mxGetN(MY_FIELD);
cpxsPr = mxGetPr(MY_FIELD);
}
if( (MY_FIELD = mxGetField(CPX_IN,(mwIndex)0,"x")) == NULL) /* cpx.x */
nx = 0;
else{
nx = mxGetM(MY_FIELD) * mxGetN(MY_FIELD);
cpxxPr = mxGetPr(MY_FIELD);
}
/* ------------------------------------------------------------
Get input matrix x
------------------------------------------------------------ */
mxAssert(mxGetM(X_IN) == lenfull, "Size x mismatch.");
m = mxGetN(X_IN); /* number of columns to handle */
mxAssert( mxIsSparse(X_IN), "X should be sparse.");
x.pr = mxGetPr(X_IN);
if(mxIsComplex(X_IN))
xpi = mxGetPi(X_IN);
else
xpi = (double *) NULL;
x.jc = mxGetJc(X_IN);
x.ir = mxGetIr(X_IN);
/* ------------------------------------------------------------
Allocate iwork[iwsiz], cwork[MAXN], {K.s, cpx.{f[nf],x[nx],s[ns],si[2*ns]}}
------------------------------------------------------------ */
MAXN = MAX(MAX(nf,nx),2*ns);
iwsize = floor(log(1.0 + MAXN) / log(2.0)); /* for binary tree search */
iwsize += 2 * ns + 2 + MAXN;
iwork = (mwIndex *) mxCalloc(iwsize, sizeof(mwIndex));
cwork = (bool *) mxCalloc(MAX(1,MAXN), sizeof(bool));
sdpNL = (mwIndex *) mxCalloc(MAX(1, cK.sdpN + nf + nx + 3*ns), sizeof(mwIndex));
cpxf = sdpNL + cK.sdpN;
cpxx = cpxf + nf;
cpxs = cpxx + nx;
cpxsi = cpxs + ns; /* length 2*ns */
/* ------------------------------------------------------------
Convert double to mwIndex
------------------------------------------------------------ */
for(i = 0; i < cK.sdpN; i++){ /* K.s */
j = cK.sdpNL[i];
sdpNL[i] = j; /* These are lengths, not subscripts!*/
}
for(i = 0; i < nf; i++){ /* cpx.f */
j = cpxfPr[i];
cpxf[i] = --j;
}
for(i = 0; i < nx; i++){ /* cpx.x */
j = cpxxPr[i];
cpxx[i] = --j;
}
for(i = 0; i < ns; i++){ /* cpx.s */
j = cpxsPr[i];
cpxs[i] = --j;
}
/* ------------------------------------------------------------
Create cpxsi(1:2*ns). This lists the 1st subscript and the
1-beyond-last subscript of each Hermitian PSD matrix in x.
------------------------------------------------------------ */
jnz = dimflqr;
j = 0;
for(i = 0; i < ns; i++){
for(; j < cpxs[i]; j++)
jnz += SQR(sdpNL[j]);
cpxsi[2 * i] = jnz; /* start of Hermitian block */
jnz += SQR(sdpNL[j]);
j++;
cpxsi[2 * i + 1] = jnz; /* end of Hermitian block */
}
/* ------------------------------------------------------------
Allocate output Y = sparse([],[],[],reallength(x),m,2 * nnz(x))
------------------------------------------------------------ */
reallength = lenfull + nf + nx;
for(i = 0; i < ns; i++){
reallength += cpxsi[2*i+1] - cpxsi[2*i];
}
jnz = x.jc[m];
if(xpi != (double *) NULL)
jnz *= 2; /* reserve room for imaginary parts */
Y_OUT = mxCreateSparse(reallength, m, jnz, mxREAL);
y.pr = mxGetPr(Y_OUT);
y.jc = mxGetJc(Y_OUT);
y.ir = mxGetIr(Y_OUT);
/* ------------------------------------------------------------
The real job, MAKEREAL:
------------------------------------------------------------ */
y.jc[0] = 0;
jnz = 0;
for(i = 0; i < m; i++){
y.jc[i] = jnz;
j = x.jc[i+1] - x.jc[i];
jnz += makereal(y.ir+jnz, y.pr+jnz, x.ir+x.jc[i],x.pr+x.jc[i],xpi,j,
cpxf,nf, cpxx,nx, cpxsi,ns, lenfull, dimflqr,
cwork, iwork, iwsize);
if(xpi != (double *) NULL)
xpi += j; /* To next imaginary column */
}
y.jc[i] = jnz;
mxAssert(jnz <= mxGetNzmax(Y_OUT),"");
/* ------------------------------------------------------------
REALLOC: Shrink Y to its current size
------------------------------------------------------------ */
jnz = MAX(jnz,1);
if( (y.pr = (double *) mxRealloc(y.pr, jnz*sizeof(double))) == NULL)
mexErrMsgTxt("Memory reallocation error");
mxSetPr(Y_OUT,y.pr);
if( (y.ir = (mwIndex *) mxRealloc(y.ir, jnz*sizeof(mwIndex))) == NULL)
mexErrMsgTxt("Memory reallocation error");
mxSetIr(Y_OUT,y.ir);
mxSetNzmax(Y_OUT,jnz);
/* ------------------------------------------------------------
Release working arrays
------------------------------------------------------------ */
mxFree(sdpNL);
mxFree(cwork);
mxFree(iwork);
}
/* ************************************************************
PROCEDURE mexFunction - Entry for Matlab
************************************************************ */
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
jcir At, Ablk;
mwIndex i,j, nblk,m, blknnz, njc, iwsize, blk0,blk1;
mwIndex *iwork, *Ajc, *blkstart;
const double *blkstartPr, *AjcPr;
bool *cwork;
bool isblk0negative;
/* ------------------------------------------------------------
Check for proper number of arguments
------------------------------------------------------------ */
mxAssert(nrhs >= NPARIN, "findblks requires more input arguments.");
mxAssert(nlhs <= NPAROUT, "findblks produces less output arguments.");
/* --------------------------------------------------
GET inputs At, blkstart, Ablkjc, blk0, blk1
-------------------------------------------------- */
mxAssert(mxIsSparse(AT_IN), "At must be a sparse matrix.");
At.jc = mxGetJc(AT_IN);
At.ir = mxGetIr(AT_IN);
m = mxGetN(AT_IN);
nblk = mxGetM(BLKSTART_IN) * mxGetN(BLKSTART_IN) - 1;
blkstartPr = mxGetPr(BLKSTART_IN);
AjcPr = mxGetPr(ABLKJC_IN);
mxAssert(m == mxGetM(ABLKJC_IN), "Ablkjc size mismatch.");
njc = mxGetN(ABLKJC_IN);
blk0 = (mwIndex) mxGetScalar(BLK0_IN); /* double to mwIndex */
isblk0negative=0;
mxAssert(blk0>0,"");
if(blk0>0)
--blk0; /* Fortran to C */
else
isblk0negative=1;
if(mxGetM(BLK1_IN) * mxGetN(BLK1_IN) != 1)
blk1 = njc; /*default to end */
else{
blk1 = (mwIndex) mxGetScalar(BLK1_IN); /* double to mwIndex (thus inf not allowed) */
mxAssert(blk1>0,"");
--blk1; /* Fortran to C */
}
/* ------------------------------------------------------------
Allocate working array iwork(nblk+2+log_2(1+nblk)),
blkstart(2*nblk), Ajc(2*m)
char cwork(nblk)
------------------------------------------------------------ */
iwsize = nblk + 2 + (mwIndex) floor(log(1.0+nblk)/log(2.0));
iwork = (mwIndex *) mxCalloc(iwsize, sizeof(mwIndex));
blkstart = (mwIndex *) mxCalloc(MAX(2*nblk,1), sizeof(mwIndex));
Ajc = (mwIndex *) mxCalloc(MAX(2*m,1), sizeof(mwIndex));
cwork = (bool *) mxCalloc(MAX(nblk,1), sizeof(bool));
/* ------------------------------------------------------------
Translate blkstart from Fortran-double to C-mwIndex
------------------------------------------------------------ */
for(i = 0; i < nblk; i++){ /* to integers */
j = (mwIndex) blkstartPr[i];
mxAssert(j>0,"");
blkstart[i] = --j;
mxAssert(j>0,"");
blkstart[nblk+i] = --j; /* blkstart minus 1 */
}
/* ------------------------------------------------------------
Convert Ajc from double to mwIndex:
------------------------------------------------------------ */
mxAssert(blk0 < njc, "Ablkjc size mismatches blk0.");
if(isblk0negative)
memcpy(Ajc,At.jc,m*sizeof(mwIndex)); /* default: start of column */
else
for(i = 0; i < m; i++){ /* to integers */
Ajc[i] = (mwIndex) AjcPr[m*blk0 + i];
}
mxAssert(blk1 >= 0, "blk1 must be positive.");
if(blk1 >= njc)
memcpy(Ajc+m,At.jc+1,m*sizeof(mwIndex)); /* default: end of column */
else
for(i = 0; i < m; i++){ /* to integers */
Ajc[m+i] = (mwIndex) AjcPr[blk1*m + i];
}
/* ------------------------------------------------------------
Ablk = sparse(nblk,m,blknnz);
------------------------------------------------------------ */
blknnz = 0;
for(i = 0; i < m; i++)
blknnz += Ajc[m+i]-Ajc[i]; /* upper bound on nnz blocks */
blknnz = MAX(blknnz,1);
ABLK_OUT = mxCreateSparse(nblk,m, blknnz,mxREAL);
Ablk.jc = mxGetJc(ABLK_OUT);
Ablk.ir = mxGetIr(ABLK_OUT);
/* ------------------------------------------------------------
The real job:
------------------------------------------------------------ */
findblks(Ablk.ir,Ablk.jc, Ajc,Ajc+m,At.ir, blkstart,blkstart+nblk,
m,nblk, iwsize,cwork,iwork);
/* ------------------------------------------------------------
REALLOC (shrink) Ablk to Ablk.jc[m] nonzeros.
------------------------------------------------------------ */
mxAssert(Ablk.jc[m] <= blknnz,"");
blknnz = MAX(Ablk.jc[m],1);
if((Ablk.ir = (mwIndex *) mxRealloc(Ablk.ir, blknnz * sizeof(mwIndex))) == NULL)
mexErrMsgTxt("Memory allocation error");
if((Ablk.pr = (double *) mxRealloc(mxGetPr(ABLK_OUT), blknnz*sizeof(double)))
== NULL)
mexErrMsgTxt("Memory allocation error");
mxSetPr(ABLK_OUT,Ablk.pr);
mxSetIr(ABLK_OUT,Ablk.ir);
mxSetNzmax(ABLK_OUT,blknnz);
for(i = 0; i < blknnz; i++)
Ablk.pr[i] = 1.0;
/* ------------------------------------------------------------
Release working arrays
------------------------------------------------------------ */
mxFree(cwork);
mxFree(iwork);
mxFree(Ajc);
mxFree(blkstart);
}
void mexFunction(
int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[]
)
{
/* Declare variable */
mwSize m,n;
mwSize nzmax;
mwIndex *irs,*jcs,j,k;
int cmplx,isfull;
double *pr,*pi,*si,*sr;
double percent_sparse;
/* Check for proper number of input and output arguments */
if (nrhs != 1) {
mexErrMsgIdAndTxt( "MATLAB:fulltosparse:invalidNumInputs",
"One input argument required.");
}
if(nlhs > 1){
mexErrMsgIdAndTxt( "MATLAB:fulltosparse:maxlhs",
"Too many output arguments.");
}
/* Check data type of input argument */
if (!(mxIsDouble(prhs[0]))){
mexErrMsgIdAndTxt( "MATLAB:fulltosparse:inputNotDouble",
"Input argument must be of type double.");
}
if (mxGetNumberOfDimensions(prhs[0]) != 2){
mexErrMsgIdAndTxt( "MATLAB:fulltosparse:inputNot2D",
"Input argument must be two dimensional\n");
}
/* Get the size and pointers to input data */
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=(mwSize)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++) {
mwSize 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
* allocated output array. If not, increase percent_sparse
* by 10%, recalculate nzmax, and augment the sparse array
*/
if (k>=nzmax){
mwSize oldnzmax = nzmax;
percent_sparse += 0.1;
nzmax = (mwSize)ceil((double)m*(double)n*percent_sparse);
/* make sure nzmax increases atleast by 1 */
if (oldnzmax == nzmax)
nzmax++;
mxSetNzmax(plhs[0], nzmax);
mxSetPr(plhs[0], mxRealloc(sr, nzmax*sizeof(double)));
if(si != NULL)
mxSetPi(plhs[0], mxRealloc(si, nzmax*sizeof(double)));
mxSetIr(plhs[0], mxRealloc(irs, nzmax*sizeof(mwIndex)));
sr = mxGetPr(plhs[0]);
si = mxGetPi(plhs[0]);
irs = mxGetIr(plhs[0]);
}
sr[k] = pr[i];
if (cmplx){
si[k]=pi[i];
}
irs[k] = i;
k++;
}
}
pr += m;
pi += m;
}
jcs[n] = k;
}
/* ************************************************************
PROCEDURE mexFunction - Entry for Matlab
y = vectril(x,K)
For the PSD submatrices, we let Yk = tril(Xk+Xk').
Complex numbers are stored as vec([real(Xk) imag(Xk)]).
NB: x and y are sparse.
************************************************************ */
void mexFunction(const int nlhs, mxArray *plhs[],
const int nrhs, const mxArray *prhs[])
{
int i, j, k, jnz, m,lenfull, firstPSD, maxn, iwsize;
jcir x,y;
int *iwork, *psdNL, *blkstart, *xblk;
char *cwork;
double *fwork;
coneK cK;
/* ------------------------------------------------------------
Check for proper number of arguments
------------------------------------------------------------ */
mxAssert(nrhs >= NPARIN, "vectril requires more input arguments");
mxAssert(nlhs <= NPAROUT, "vectril produces less output arguments");
/* ------------------------------------------------------------
Disassemble cone K structure
------------------------------------------------------------ */
conepars(K_IN, &cK);
/* ------------------------------------------------------------
Compute statistics based on cone K structure
------------------------------------------------------------ */
firstPSD = cK.frN + cK.lpN + cK.qDim;
for(i = 0; i < cK.rconeN; i++) /* add dim of rotated cone */
firstPSD += cK.rconeNL[i];
lenfull = firstPSD + cK.rDim + cK.hDim;
/* ------------------------------------------------------------
Get inputs x, blkstart
------------------------------------------------------------ */
mxAssert(mxGetM(X_IN) == lenfull, "X size mismatch.");
m = mxGetN(X_IN); /* number of columns to handle */
mxAssert( mxIsSparse(X_IN), "X should be sparse.");
x.pr = mxGetPr(X_IN);
x.jc = mxGetJc(X_IN);
x.ir = mxGetIr(X_IN);
/* ------------------------------------------------------------
Allocate output Y = sparse([],[],[],length(x),m,nnz(x))
------------------------------------------------------------ */
Y_OUT = mxCreateSparse(lenfull, m, x.jc[m], mxREAL);
y.pr = mxGetPr(Y_OUT);
y.jc = mxGetJc(Y_OUT);
y.ir = mxGetIr(Y_OUT);
y.jc[0] = 0;
/* ------------------------------------------------------------
If x = [], then we are ready with y=[]. Otherwise, proceed:
------------------------------------------------------------ */
if(x.jc[m] > 0){
/* ------------------------------------------------------------
Allocate iwork[iwsize],
iwsize := maxn*(2*maxn+1)+log_2(1+maxn*(maxn-1)/2), where maxn := max(K.s);
cwork[maxn*(maxn-1)/2], fwork(maxn^2), int psdNL(length(K.s)).
int blkstart(sdpN+1), xblk(sdpDim)
------------------------------------------------------------ */
maxn = MAX(cK.rMaxn,cK.hMaxn);
iwsize = log(1 + maxn*(maxn-1)/2) / log(2);
iwsize += maxn * (2*maxn+1);
iwork = (int *) mxCalloc(MAX(1,iwsize), sizeof(int));
cwork = (char *) mxCalloc(MAX(1,maxn*(maxn-1)/2), sizeof(char));
fwork = (double *) mxCalloc(MAX(1,SQR(maxn)), sizeof(double));
psdNL = (int *) mxCalloc(MAX(1,cK.sdpN), sizeof(int));
blkstart = (int *) mxCalloc(1 + cK.sdpN, sizeof(int));
xblk = (int *) mxCalloc(MAX(1,cK.rDim + cK.hDim), sizeof(int));
/* ------------------------------------------------------------
double -> int for K.s
------------------------------------------------------------ */
for(i = 0; i < cK.sdpN; i++)
psdNL[i] = cK.sdpNL[i];
/* ------------------------------------------------------------
Let k = xblk(j-blkstart[0]) iff
blkstart[k] <= j < blkstart[k+1], k=0:psdN-1.
------------------------------------------------------------ */
j = firstPSD;
for(i = 0; i < cK.rsdpN; i++){ /* real sym */
blkstart[i] = j;
j += SQR(psdNL[i]);
}
for(; i < cK.sdpN; i++){ /* complex herm. */
blkstart[i] = j;
j += 2*SQR(psdNL[i]);
}
blkstart[cK.sdpN] = j;
mxAssert(j - firstPSD == cK.rDim + cK.hDim, "Size mismatch blkstart, K.");
j = 0;
for(k = 0; k < cK.sdpN; k++){
i = blkstart[k+1] - blkstart[0];
while(j < i)
xblk[j++] = k;
}
/* ------------------------------------------------------------
Let y(:,i)= vectril(x(:,i)), for i=1:m.
------------------------------------------------------------ */
jnz = 0; /* points into y */
for(i = 0; i < m; i++){
y.jc[i] = jnz;
jnz += vectril(y.ir+jnz,y.pr+jnz, x.ir+x.jc[i],x.pr+x.jc[i],
x.jc[i+1]-x.jc[i],
psdNL, blkstart, xblk, cK.rsdpN,cK.sdpN, iwsize,
cwork, iwork, fwork);
}
y.jc[m] = jnz; /* nnz written into y */
mxAssert(jnz <= x.jc[m],"");
/* ------------------------------------------------------------
REALLOC: Shrink Y to its current size
------------------------------------------------------------ */
jnz = MAX(jnz,1);
if( (y.pr = (double *) mxRealloc(y.pr, jnz*sizeof(double))) == NULL)
mexErrMsgTxt("Memory reallocation error");
mxSetPr(Y_OUT,y.pr);
if( (y.ir = (int *) mxRealloc(y.ir, jnz*sizeof(int))) == NULL)
mexErrMsgTxt("Memory reallocation error");
mxSetIr(Y_OUT,y.ir);
mxSetNzmax(Y_OUT,jnz);
/* ------------------------------------------------------------
Release working arrays
------------------------------------------------------------ */
mxFree(xblk);
mxFree(blkstart);
mxFree(psdNL);
mxFree(fwork);
mxFree(iwork);
mxFree(cwork);
}
}
void mexFunction(
int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[]
)
{
/* Declare variables. */
int j,k,m,n,nzmax,*irs,*jcs, *irs2, *jcs2;
double *overlap, *overlap2, tmp, areaA, areaB;
double percent_sparse;
double *leftA, *rightA, *topA, *bottomA;
double *leftB, *rightB, *topB, *bottomB;
double *verbose;
/* Get the size and pointers to input data. */
m = MAX(mxGetM(prhs[0]), mxGetN(prhs[0]));
n = MAX(mxGetM(prhs[4]), mxGetN(prhs[4]));
/* printf("A=%d, B=%d\n", m, n); */
leftA = mxGetPr(prhs[0]);
rightA = mxGetPr(prhs[1]);
topA = mxGetPr(prhs[2]);
bottomA = mxGetPr(prhs[3]);
leftB = mxGetPr(prhs[4]);
rightB = mxGetPr(prhs[5]);
topB = mxGetPr(prhs[6]);
bottomB = mxGetPr(prhs[7]);
verbose = mxGetPr(prhs[8]);
/* 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.01;
nzmax = (int)ceil((double)m*(double)n*percent_sparse);
plhs[0] = mxCreateSparse(m,n,nzmax,0);
overlap = mxGetPr(plhs[0]);
irs = mxGetIr(plhs[0]);
jcs = mxGetJc(plhs[0]);
plhs[1] = mxCreateSparse(m,n,nzmax,0);
overlap2 = mxGetPr(plhs[1]);
irs2 = mxGetIr(plhs[1]);
jcs2 = mxGetJc(plhs[1]);
/* Assign nonzeros. */
k = 0;
for (j = 0; (j < n); j++) {
int i;
jcs[j] = k;
jcs2[j] = k;
for (i = 0; (i < m); i++) {
tmp = (MAX(0, MIN(rightA[i], rightB[j]) - MAX(leftA[i], leftB[j]) )) *
(MAX(0, MIN(topA[i], topB[j]) - MAX(bottomA[i], bottomB[j]) ));
if (*verbose) {
printf("j=%d,i=%d,tmp=%5.3f\n", j,i,tmp);
}
if (IsNonZero(tmp)) {
/* Check to see if non-zero element will fit in
* allocated output array. If not, increase
* percent_sparse by 20%, recalculate nzmax, and augment
* the sparse array.
*/
if (k >= nzmax) {
int oldnzmax = nzmax;
percent_sparse += 0.2;
nzmax = (int)ceil((double)m*(double)n*percent_sparse);
/* Make sure nzmax increases atleast by 1. */
if (oldnzmax == nzmax)
nzmax++;
printf("reallocating from %d to %d\n", oldnzmax, nzmax);
mxSetNzmax(plhs[0], nzmax);
mxSetPr(plhs[0], mxRealloc(overlap, nzmax*sizeof(double)));
mxSetIr(plhs[0], mxRealloc(irs, nzmax*sizeof(int)));
overlap = mxGetPr(plhs[0]);
irs = mxGetIr(plhs[0]);
mxSetNzmax(plhs[1], nzmax);
mxSetPr(plhs[1], mxRealloc(overlap2, nzmax*sizeof(double)));
mxSetIr(plhs[1], mxRealloc(irs2, nzmax*sizeof(int)));
overlap2 = mxGetPr(plhs[1]);
irs2 = mxGetIr(plhs[1]);
}
overlap[k] = tmp;
irs[k] = i;
areaA = (rightA[i]-leftA[i])*(topA[i]-bottomA[i]);
areaB = (rightB[j]-leftB[j])*(topB[j]-bottomB[j]);
overlap2[k] = MIN(tmp/areaA, tmp/areaB);
irs2[k] = i;
k++;
} /* IsNonZero */
} /* for i */
}
jcs[n] = k;
jcs2[n] = k;
}
mxArray *ssmult_dot /* returns C = A'*B */
(
const mxArray *A,
const mxArray *B,
int ac, /* if true: conj(A) if false: A. ignored if A real */
int bc, /* if true: conj(B) if false: B. ignored if B real */
int cc /* if true: conj(C) if false: C. ignored if C real */
)
{
double cx, cz, ax, az, bx, bz ;
mxArray *C ;
double *Ax, *Az, *Bx, *Bz, *Cx, *Cz ;
Int *Ap, *Ai, *Bp, *Bi, *Cp, *Ci ;
Int m, n, k, cnzmax, i, j, p, paend, pbend, ai, bi, cnz, pa, pb, zallzero,
A_is_complex, B_is_complex, C_is_complex ;
/* ---------------------------------------------------------------------- */
/* get inputs */
/* ---------------------------------------------------------------------- */
m = mxGetM (A) ;
n = mxGetN (A) ;
k = mxGetN (B) ;
if (m != mxGetM (B)) ssmult_invalid (ERROR_DIMENSIONS) ;
Ap = mxGetJc (A) ;
Ai = mxGetIr (A) ;
Ax = mxGetPr (A) ;
Az = mxGetPi (A) ;
A_is_complex = mxIsComplex (A) ;
Bp = mxGetJc (B) ;
Bi = mxGetIr (B) ;
Bx = mxGetPr (B) ;
Bz = mxGetPi (B) ;
B_is_complex = mxIsComplex (B) ;
/* ---------------------------------------------------------------------- */
/* allocate C as an n-by-k full matrix but do not initialize it */
/* ---------------------------------------------------------------------- */
/* NOTE: integer overflow cannot occur here, because this function is not
called unless O(n*k) is less than O(m+nnz(A)). The test is done
in the caller, not here.
*/
cnzmax = n*k ;
cnzmax = MAX (cnzmax, 1) ;
Cx = mxMalloc (cnzmax * sizeof (double)) ;
C_is_complex = A_is_complex || B_is_complex ;
Cz = C_is_complex ? mxMalloc (cnzmax * sizeof (double)) : NULL ;
/* ---------------------------------------------------------------------- */
/* C = A'*B using sparse dot products */
/* ---------------------------------------------------------------------- */
/*
NOTE: this method REQUIRES the columns of A and B to be sorted on input.
That is, the row indices in each column must appear in ascending order.
This is the standard in all versions of MATLAB to date, and likely will
be for some time. However, if MATLAB were to use unsorted sparse
matrices in the future (a lazy sort) then a test should be included in
ssmult to not use ssmult_dot if A or B are unsorted, or they should be
sorted on input.
*/
cnz = 0 ;
for (j = 0 ; j < k ; j++)
{
for (i = 0 ; i < n ; i++)
{
/* compute C (i,j) = A (:,i)' * B (:,j) */
pa = Ap [i] ;
paend = Ap [i+1] ;
pb = Bp [j] ;
pbend = Bp [j+1] ;
if (pa == paend /* nnz (A (:,i)) == 0 */
|| pb == pbend /* nnz (B (:,j)) == 0 */
|| Ai [paend-1] < Bi [pb] /* max(find(A(:,i)))<min(find(B(:,j))) */
|| Ai [pa] > Bi [pbend-1]) /* min(find(A(:,i)))>max(find(B(:,j))) */
{
Cx [i+j*n] = 0 ; /* no work to do */
if (C_is_complex)
{
Cz [i+j*n] = 0 ;
}
continue ;
}
cx = 0 ;
cz = 0 ;
while (pa < paend && pb < pbend)
{
/* The dot product looks like the merge in mergesort, except */
/* no "clean-up" phase is need when one list is exhausted. */
ai = Ai [pa] ;
bi = Bi [pb] ;
if (ai == bi)
{
/* c += A (ai,i) * B (ai,j), and "consume" both entries */
if (!C_is_complex)
{
cx += Ax [pa] * Bx [pb] ;
}
else
{
/* complex case */
ax = Ax [pa] ;
bx = Bx [pb] ;
az = Az ? (ac ? (-Az [pa]) : Az [pa]) : 0.0 ;
bz = Bz ? (bc ? (-Bz [pb]) : Bz [pb]) : 0.0 ;
cx += ax * bx - az * bz ;
cz += az * bx + ax * bz ;
}
pa++ ;
pb++ ;
}
else if (ai < bi)
{
/* consume A(ai,i) and discard it, since B(ai,j) is zero */
pa++ ;
}
else
{
/* consume B(bi,j) and discard it, since A(ai,i) is zero */
pb++ ;
}
}
Cx [i+j*n] = cx ;
if (C_is_complex)
{
Cz [i+j*n] = cz ;
}
}
/* count the number of nonzeros in C(:,j) */
for (i = 0 ; i < n ; i++)
{
/* This could be done above, except for the gcc compiler bug when
cx is an 80-bit nonzero in register above, but becomes zero here
when stored into memory. We need the latter, to correctly handle
the case when cx underflows to zero in 64-bit floating-point.
Do not attempt to "optimize" this code by doing this test above,
unless the gcc compiler bug is fixed (as of gcc version 4.1.0).
*/
if (Cx [i+j*n] != 0 || (C_is_complex && Cz [i+j*n] != 0))
{
cnz++ ;
}
}
}
/* ---------------------------------------------------------------------- */
/* convert C to real if the imaginary part is all zero */
/* ---------------------------------------------------------------------- */
if (C_is_complex)
{
zallzero = 1 ;
for (p = 0 ; zallzero && p < cnzmax ; p++)
{
if (Cz [p] != 0)
{
zallzero = 0 ;
}
}
if (zallzero)
{
/* the imaginary part of C is all zero */
C_is_complex = 0 ;
mxFree (Cz) ;
Cz = NULL ;
}
}
/* ---------------------------------------------------------------------- */
/* allocate integer part of C but do not initialize it */
/* ---------------------------------------------------------------------- */
cnz = MAX (cnz, 1) ;
C = mxCreateSparse (0, 0, 0, C_is_complex ? mxCOMPLEX : mxREAL) ;
mxFree (mxGetJc (C)) ;
mxFree (mxGetIr (C)) ;
mxFree (mxGetPr (C)) ;
mxFree (mxGetPi (C)) ;
Cp = mxMalloc ((k + 1) * sizeof (Int)) ;
Ci = mxMalloc (cnz * sizeof (Int)) ;
mxSetJc (C, Cp) ;
mxSetIr (C, Ci) ;
mxSetM (C, n) ;
mxSetN (C, k) ;
/* ---------------------------------------------------------------------- */
/* C = sparse (C). Note that this is done in-place. */
/* ---------------------------------------------------------------------- */
p = 0 ;
for (j = 0 ; j < k ; j++)
{
Cp [j] = p ;
for (i = 0 ; i < n ; i++)
{
cx = Cx [i+j*n] ;
cz = (C_is_complex ? Cz [i+j*n] : 0) ;
if (cx != 0 || cz != 0)
{
Ci [p] = i ;
Cx [p] = cx ;
if (C_is_complex) Cz [p] = (cc ? (-cz) : cz) ;
p++ ;
}
}
}
Cp [k] = p ;
/* ---------------------------------------------------------------------- */
/* reduce the size of Cx and Cz and return result */
/* ---------------------------------------------------------------------- */
if (cnz < cnzmax)
{
Cx = mxRealloc (Cx, cnz * sizeof (double)) ;
if (C_is_complex)
{
Cz = mxRealloc (Cz, cnz * sizeof (double)) ;
}
}
mxSetNzmax (C, cnz) ;
mxSetPr (C, Cx) ;
if (C_is_complex)
{
mxSetPi (C, Cz) ;
}
return (C) ;
}
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[]) {
mwSize num,sizeWm,sizeWn,n1;
double* u;
mxArray * v;
mwSize nzmaxNew,nzmaxOld,nzmaxt;
mwIndex *ir, *jc, *irs, *jcs;
double *weights,*sr;
mwIndex currentColumnIndex,currentEntryIndexOld, numColumnEntriesOld,currentRowIndex;
mwIndex currentEntryIndexNew, numColumnEntriesNew,skippedEntries;
double ux,uy,derivative;
void * newSr, * newIrs;
// Test number of parameters.
if (nrhs != 2 || nlhs != 1) {
mexWarnMsgTxt("Usage: K = getSparseDerivativeMatrix(u,W)");
return;
}
// Parse parameters
num = mxGetM(prhs[0]);
u = mxGetPr(prhs[0]);
sizeWm= mxGetM(prhs[1]);
sizeWn= mxGetN(prhs[1]);
if (!(num==sizeWm) || !(sizeWm==sizeWn)) {
mexWarnMsgTxt("Error: Dimensions of u and W do not match.");
return;
}
if (!mxIsSparse(prhs[1])) {
mexWarnMsgTxt("Error: Expects sparse matrix W.");
return;
}
nzmaxOld = mxGetNzmax(prhs[1]); // number of nonzero elements of sparse matrix
ir = mxGetIr(prhs[1]);
jc = mxGetJc(prhs[1]);
weights = mxGetPr(prhs[1]);
// Allocate memory for output (sparse real matrix)
v = mxCreateSparse(num, num, nzmaxOld/2, mxREAL);
sr = mxGetPr(v);
irs = mxGetIr(v);
jcs = mxGetJc(v);
currentColumnIndex=0,currentEntryIndexOld=0;
currentEntryIndexNew=0;
nzmaxNew=nzmaxOld/2;
skippedEntries=0;
jcs[0]=0;
while(currentEntryIndexOld<nzmaxOld && currentColumnIndex<sizeWn)
{
numColumnEntriesOld=jc[currentColumnIndex+1];
uy=u[currentColumnIndex];
while(currentEntryIndexOld<numColumnEntriesOld)
{
currentRowIndex=ir[currentEntryIndexOld];
if (currentRowIndex<currentColumnIndex)
{
ux= u[currentRowIndex];
derivative=uy-ux;
if (derivative != 0)
{
sr[currentEntryIndexNew]=derivative;
irs[currentEntryIndexNew]=currentRowIndex;
currentEntryIndexNew++;
}
else
{
skippedEntries++;
}
}
else
{
skippedEntries++;
}
currentEntryIndexOld++;
}
jcs[currentColumnIndex+1]=numColumnEntriesOld-skippedEntries;
currentColumnIndex++;
}
nzmaxNew=nzmaxOld-skippedEntries;
for(;currentColumnIndex<sizeWn;currentColumnIndex++)
{
jcs[currentColumnIndex+1]=nzmaxNew;
}
newSr = mxRealloc(sr, nzmaxNew * sizeof(double));
mxSetPr(v,(double*)newSr);
newIrs= mxRealloc(irs, nzmaxNew * sizeof(mwIndex));
mxSetIr(v,(mwIndex*) newIrs);
mxSetNzmax(v,nzmaxNew);
plhs[0]=v;
}
