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[])
{
char *CIN;
int *DS, *WS, *SI, *ZIN;
double *srww,*srwp,*srdp, *probs, *WC, *WWC, *ZZ;
double ALPHA,BETA, GAMMA0, GAMMA1, DELTA;
mwIndex *irww, *jcww, *irwp, *jcwp, *irdp, *jcdp;
int *z,*d,*w, *s, *c, *sc, *order, *wp, *dp, *ztot, *wtot, *wc;
int W,T,D,NN,SEED,OUTPUT, nzmax, nzmaxwp, nzmaxdp, ntokens;
int i,j,cc,n,nt,wi,di;
int startcond;
mexPrintf( "GibbsSamplerLDACOL: entering...\n" );
mexEvalString("drawnow;");
/* Check for proper number of arguments. */
if (nrhs < 13) {
mexErrMsgTxt("At least 13 input arguments required");
} else if (nlhs != 5) {
mexErrMsgTxt("5 output arguments required");
}
//[ WP,DP,WC,C,Z ] = GibbsSamplerLDACOL( WS , DS , SI , WW , T , N , ALPHA , BETA , GAMMA0, GAMMA1 , DELTA , SEED , OUTPUT , CIN , ZIN );
/* process the input arguments */
if (mxIsInt32( prhs[ 0 ] ) != 1)
mexErrMsgTxt("WS must be int32");
WS = (int *)mxGetData(prhs[0]);
if (mxIsInt32( prhs[ 1 ] ) != 1)
mexErrMsgTxt("DS must be int32");
DS = (int *)mxGetData(prhs[1]);
if (mxIsInt32( prhs[ 2 ] ) != 1)
mexErrMsgTxt("SI must be int32");
SI = (int *)mxGetData(prhs[2]);
//for (int yy=0;yy<20;yy++)
// printf("%2d: WS=%4u, DS=%4u, SI=%4u\n",yy,WS[yy],DS[yy],SI[yy]);
if ((mxIsSparse( prhs[ 3 ] ) != 1) || (mxIsDouble( prhs[ 3 ] ) != 1))
mexErrMsgTxt("WW collocation matrix must be a sparse double precision matrix");
/* dealing with sparse array WW */
srww = mxGetPr(prhs[3]);
irww = mxGetIr(prhs[3]);
jcww = mxGetJc(prhs[3]);
nzmax= mxGetNzmax(prhs[3]);
W = mxGetM( prhs[3] );
ntokens = mxGetM( prhs[ 0 ] ) * mxGetN( prhs[ 0 ] );
D = 0;
for (i=0; i<ntokens; i++) {
if (DS[ i ] > D) D = (int) DS[ i ];
}
T = (int) mxGetScalar(prhs[4]);
if (T<=0) mexErrMsgTxt("Number of topics must be greater than zero");
NN = (int) mxGetScalar(prhs[5]);
if (NN<0) mexErrMsgTxt("Number of iterations must be greater than zero");
ALPHA = (double) mxGetScalar(prhs[6]);
if (ALPHA<=0) mexErrMsgTxt("ALPHA must be greater than zero");
BETA = (double) mxGetScalar(prhs[7]);
if (BETA<=0) mexErrMsgTxt("BETA must be greater than zero");
GAMMA0 = (double) mxGetScalar(prhs[8]);
if (GAMMA0<=0) mexErrMsgTxt("GAMMA0 must be greater than zero");
GAMMA1 = (double) mxGetScalar(prhs[9]);
if (GAMMA1<=0) mexErrMsgTxt("GAMMA1 must be greater than zero");
DELTA = (double) mxGetScalar(prhs[10]);
if (DELTA<=0) mexErrMsgTxt("DELTA must be greater than zero");
SEED = (int) mxGetScalar(prhs[11]);
// set the seed of the random number generator
OUTPUT = (int) mxGetScalar(prhs[12]);
// assume that we start a new chain
startcond = 0;
if (nrhs > 13) {
startcond = 1;
if (mxIsInt8( prhs[ 13 ] ) != 1)
mexErrMsgTxt("C must be int8");
CIN = (char*)mxGetData(prhs[13]);
if (mxIsInt32( prhs[ 14 ] ) != 1)
mexErrMsgTxt("Z must be int32");
ZIN = (int*)mxGetData(prhs[14]);
//for (int yy=0;yy<20;yy++)
// printf("%2d: Z=%4u, C=%4u\n",yy,ZIN[yy],CIN[yy]);
}
// seeding
seedMT( 1 + SEED * 2 ); // seeding only works on uneven numbers
/* allocate memory */
if (OUTPUT==2) {
mexPrintf( "GibbsSamplerLDACOL: Allocating z,d,w,s,c,sc\n" );
mexEvalString("drawnow;");
}
z = (int *) mxCalloc( ntokens , sizeof( int ));
d = (int *) mxCalloc( ntokens , sizeof( int ));
w = (int *) mxCalloc( ntokens , sizeof( int ));
s = (int *) mxCalloc( ntokens , sizeof( int ));
c = (int *) mxCalloc( ntokens , sizeof( int ));
sc = (int *) mxCalloc( ntokens , sizeof( int ));
if (startcond==1) {
if (OUTPUT==2) {
mexPrintf( "GibbsSamplerLDACOL: Preparing c,z\n" );
}
for (i=0; i<ntokens; i++) c[ i ] = (int) CIN[ i ];
for (i=0; i<ntokens; i++) z[ i ] = (int) ZIN[ i ] - (int) 1;
}
if (OUTPUT==2) {
mexPrintf( "GibbsSamplerLDACOL: Preparing w,d,s\n" );
mexEvalString("drawnow;");
}
for (i=0; i<ntokens; i++) w[ i ] = (int) (WS[ i ] - 1); // Matlab indexing not zero based
for (i=0; i<ntokens; i++) d[ i ] = (int) (DS[ i ] - 1); // Matlab indexing not zero based
for (i=0; i<ntokens; i++) s[ i ] = (int) SI[ i ];
if (OUTPUT==2) {
mexPrintf( "GibbsSamplerLDACOL: Allocating order,wp,dp,wc,ztot,wtot,probs\n" );
mexEvalString("drawnow;");
}
order = (int *) mxCalloc( ntokens , sizeof( int ));
wp = (int *) mxCalloc( T*W , sizeof( int ));
dp = (int *) mxCalloc( T*D , sizeof( int ));
wc = (int *) mxCalloc( W , sizeof( int ));
ztot = (int *) mxCalloc( T , sizeof( int ));
wtot = (int *) mxCalloc( W , sizeof( int ));
probs = (double *) mxCalloc( T , sizeof( double ));
n = ntokens;
/*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 LDA COL Gibbs Sampler Version 1.0\n" );
if (startcond==1) mexPrintf( "Starting with C and Z vector given as input\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 iterations N = %d\n" , NN );
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 );
mexPrintf( "Internal Memory Allocation\n" );
mexPrintf( "\tw,d,z,s,c,sc,order indices combined = %d bytes\n" , 7 * sizeof( int) * ntokens );
mexPrintf( "\twp (full) matrix (%dx%d) = %d bytes\n" , W,T,sizeof( int ) * W * T );
mexPrintf( "\tdp (full) matrix (%dx%d) = %d bytes\n" , D,T,sizeof( int ) * D * T );
mexPrintf( "Checking: sizeof(char)=%d sizeof(int)=%d sizeof(long)=%d sizeof(double)=%d\n" , sizeof(char),sizeof(int) , sizeof(long) , sizeof(double));
mexEvalString("drawnow;");
}
/* run the model */
GibbsSamplerLDACOL( ALPHA, BETA, GAMMA0,GAMMA1,DELTA, W, T, D, NN, OUTPUT, n, z, d, w, s, c, sc, wp, dp, ztot, wtot, order, probs , srww, irww, jcww, wc, startcond );
/* ---------------------------------------------
Erasing variables to free memory
-----------------------------------------------*/
if (OUTPUT==2) {
mexPrintf( "Freeing internal memory from d,w,s,sc,ztot,wtot,probs\n");
mexEvalString("drawnow;");
mxFree(d);
mxFree(w);
mxFree(s);
mxFree(sc);
mxFree(ztot);
mxFree(wtot);
mxFree(probs);
}
/* ---------------------------------------------
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\n" );
mexPrintf( "Number of nonzero entries for WP = %d\n" , nzmaxwp );
mexEvalString("drawnow;");
}
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++) {
cc = (int) *( wp + i*T + j );
if (cc >0) {
*( srwp + n ) = cc;
*( irwp + n ) = i;
n++;
}
}
}
*( jcwp + T ) = n;
if (OUTPUT==2) {
mexPrintf( "Freeing internal memory from matrix 'wp'\n");
mexEvalString("drawnow;");
mxFree(wp);
}
/* ---------------------------------------------
convert the full DP matrix into a sparse 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\n" );
mexPrintf( "Number of nonzero entries for DP = %d\n" , nzmaxdp );
mexEvalString("drawnow;");
}
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++) {
cc = (int) *( dp + i*T + j );
if (cc >0) {
*( srdp + n ) = cc;
*( irdp + n ) = i;
n++;
}
}
}
*( jcdp + T ) = n;
if (OUTPUT==2) {
mexPrintf( "Freeing internal memory from matrix 'dp'\n");
mexEvalString("drawnow;");
mxFree(dp);
}
/* ---------------------------------------------
create the WC count matrix
-----------------------------------------------*/
plhs[ 2 ] = mxCreateDoubleMatrix( W , 1 , mxREAL );
WC = mxGetPr( plhs[ 2 ] );
for (i=0; i<W; i++) WC[ i ] = (double) wc[ i ];
if (OUTPUT==2) {
mexPrintf( "Freeing internal memory from matrix 'wc'\n");
mexEvalString("drawnow;");
mxFree(wc);
}
/* ---------------------------------------------
create the C route vector
-----------------------------------------------*/
plhs[ 3 ] = mxCreateDoubleMatrix( ntokens , 1 , mxREAL );
WWC = mxGetPr( plhs[ 3 ] );
for (i=0; i<ntokens; i++) WWC[ i ] = (double) c[ i ];
if (OUTPUT==2) {
mexPrintf( "Freeing internal memory from matrix 'c'\n");
mexEvalString("drawnow;");
mxFree(c);
}
/* ---------------------------------------------
create the topic assignment vector
-----------------------------------------------*/
plhs[ 4 ] = mxCreateDoubleMatrix( ntokens , 1 , mxREAL );
ZZ = mxGetPr( plhs[ 4 ] );
for (i=0; i<ntokens; i++) ZZ[ i ] = (double) z[ i ] + 1;
if (OUTPUT==2) {
mexPrintf( "Freeing internal memory from matrix 'z'\n");
mexEvalString("drawnow;");
mxFree(z);
}
}
