/*
* Manual page at statistics.def
*/
INT16 CGEN_PUBLIC CStatistics_Setup
(
CStatistics* _this,
INT32 nOrder,
INT32 nDim,
INT32 nCls,
CData* idLtb,
INT32 nIcLtb
)
{
INT32 c = 0; /* Statistics class loop counter */
INT32 n = 0; /* Dimension loop couner */
FLOAT64* lpMin = NULL; /* Ptr. to class' k minimum vector */
FLOAT64* lpMax = NULL; /* Ptr. to class' k maximum vector */
/* Validate */ /* --------------------------------- */
CHECK_THIS_RV(NOT_EXEC); /* Check this pointer */
if (nOrder<2) nOrder = 2; /* Default order is 2 */
if (nDim <1) nDim = 1; /* Default dimensionality is 1 */
if (nCls <1) nCls = 1; /* Default number of classes is 1 */
/* Initialize statistics */ /* --------------------------------- */
CStatistics_Reset(_this,TRUE); /* Start over */
IFIELD_RESET(CData,"dat"); /* Create/reset statistic data */
CData_Array(_this->m_idDat,T_DOUBLE,nDim,nCls*(nOrder+nDim+2)); /* Allocate statistic data */
CData_SetNBlocks(_this->m_idDat,nCls); /* Set number of blocks */
if (CData_IsEmpty(_this->m_idDat)) return IERROR(_this,ERR_NOMEM,0,0,0); /* Check if it worked out... */
for (c=0; c<nCls; c++) /* Loop over classes */
{ /* >> */
lpMin = CStatistics_GetPtr(_this,c,STA_DAI_MIN); /* Get ptr. to class' k min. vec. */
lpMax = CStatistics_GetPtr(_this,c,STA_DAI_MAX); /* Get ptr. to class' k max. vec. */
for (n=0; n<nDim; n++) /* Loop over dimensions */
{ /* >> */
lpMin[n] = T_DOUBLE_MAX; /* Initialize minimum vector */
lpMax[n] = T_DOUBLE_MIN; /* Initialize maximum vector */
} /* << */
} /* << */
/* Initialize label table */ /* --------------------------------- */
if (CData_IsEmpty(idLtb)) return O_K; /* No label table -> that's it */
if (CData_GetNRecs(idLtb)!=nCls) /* Bad number of labels */
return IERROR(_this,STA_NOTSETUP," (wrong no. of labels in idLtb)",0,0); /* -> Error */
if (nIcLtb<0) /* Label component not specified */
for (nIcLtb=0; nIcLtb<CData_GetNComps(idLtb); nIcLtb++) /* Seek first symbolic component */
if (dlp_is_symbolic_type_code(CData_GetCompType(idLtb,nIcLtb))) /* ... */
break; /* ... */
if (!dlp_is_symbolic_type_code(CData_GetCompType(idLtb,nIcLtb))) /* Label component not symbolic */
return IERROR(_this,STA_NOTSETUP," (label comp. not found in idLtb)",0,0); /* -> Error */
IFIELD_RESET(CData,"ltb"); /* Create/reset label table */
CData_SelectComps(_this->m_idLtb,idLtb,nIcLtb,1); /* Copy label table */
return O_K; /* Done */
}
/**
* Writes the data transfer file of this process. This method is called
* immediately before starting the operating system process.
*/
INT16 CGEN_PUBLIC CProcess::SendData()
{
DLP_FILE* pfScr; // Slave script file pointer
INT32 i; // Loop counter
char sScrFn[L_PATH]; // Slave script file name
char sDtoFn[L_PATH]; // Data transfer file name
if (m_nState & PRC_DATASENT) return NOT_EXEC; // Data have already been sent
if (m_iDto) // This process is a function call
{ // >>
sprintf(sScrFn,"%s.xtp",m_psTmpFile); // Get slave script file name
sprintf(sDtoFn,"%s.xml",m_psTmpFile); // Get data transfer fine name
pfScr = dlp_fopen(sScrFn,"w"); // Open temporary script file
for (i=0; dlp_strcmp(__sSlaveScript[i],"\0")!=0; i++) // Loop over slave script lines
{ // >>
dlp_fwrite(__sSlaveScript[i],1,dlp_strlen(__sSlaveScript[i]),pfScr); // Write a line
dlp_fwrite("\n",1,1,pfScr); // Write a line break
} // <<
dlp_fclose(pfScr); // Close temporary script file
CDlpObject_Save(m_iDto,sDtoFn,SV_XML|SV_ZIP); // Save data transfer object
sprintf(m_psCmdLine,"%s %s %s",dlp_get_binary_path(),sScrFn,sDtoFn); // Change the command line
// -- ???? -->
IDESTROY(m_iDto); IFIELD_RESET(CDlpObject,"dto"); // Save memory!
// <----------
} // <<
m_nState |= PRC_DATASENT; // Remember data have been sent
return O_K;
}
INT16 CDgen::Reset(BOOL bResetMembers)
{
DEBUGMSG(-1,"CDgen::Reset; (bResetMembers=%d)",(int)bResetMembers,0,0);
//{{CGEN_RESETCODE
RESET;
IFIELD_RESET(CData,"tsq");
IFIELD_RESET(CData,"spl");
IFIELD_RESET(CData,"dom");
IFIELD_RESET(CData,"txt");
IFIELD_RESET(CData,"gen");
m_idSpl->AddComp("key" , 33);
m_idSpl->AddComp("val" ,255);
m_idTxt->AddComp("line",255);
m_idGen->AddComp("line",255);
//}}CGEN_RESETCODE
return O_K;
}
/*
* Manual page at process.def
*/
INT32 CGEN_PUBLIC CProcess::Start()
{
const SMic* pMic = NULL; // Method invocation context of Start()
CFunction* iCaller = NULL; // Function calling Start()
CFunction* iFnc = NULL; // Process function
StkItm* pStkItm = NULL; // Stack item
INT32 nArgs = 0; // Number of process function arguments
// Validate and initialize // ------------------------------------
if (m_nState!=0) // Not virginal
return IERROR(this,PRC_CANTSTART,"multiple starts not allowed",0,0); // Forget it!
if (!(pMic = CDlpObject_MicGet(_this))) return -1; // Get method invocation context
iCaller = (CFunction*)CDlpObject_OfKind("function",pMic->iCaller); // Get calling CFunction
if (!iCaller) return -1; // Must be a function!
// Initialize process // ------------------------------------
sprintf(m_psTmpFile,"%s%ld",dlp_tempnam(NULL,"~dLabPro#process#"),(long)dlp_time());// Initialize temp. file name prefix
// Marshal arguments // ------------------------------------
if (!(pStkItm=iCaller->StackGet(0))) return IERROR(this,PRC_TOOFEWARGS,0,0,0);// Get stack top
if (pStkItm->nType==T_INSTANCE) // Stack top is an instance
iFnc = (CFunction*)CDlpObject_OfKind("function",pStkItm->val.i); // Get function to be called
if (iFnc) // This process is a function call
{ // >>
IFIELD_RESET(CDlpObject,"dto"); // Create data transfer object
nArgs = CData_GetNRecs(iFnc->m_idArg); // Get number of function arguments
Marshal(m_iDto,iCaller,nArgs); // Marshal arguments for transfer
} // <<
else // This process is a program call
dlp_strcpy(m_psCmdLine,iCaller->PopString(0)); // Get program command line
#ifdef USE_FORK
if (iFnc) // This process is a function call
{ // >>
m_hPid=fork(); // Fork the process
if(m_hPid>0){ // Parent process >>
m_nState |= PRC_DATASENT; // Remember data have been sent
m_nState |= PRC_RUNNING; // Set running flag
m_hThread = 0; // Clear thread handle
return O_K; // Everything is fine
} // <<
if(m_hPid==0) return DoJobFork(iCaller,iFnc); // The child process runs the function
return IERROR(this,PRC_CANTSTART,"fork() failed",0,0); // On error (fid<0) we return
} // <<
#endif
// Start job in watcher thread // ------------------------------------
m_hPid = 0; // Reset process id
SendData(); // Send transfer data
m_hThread = dlp_create_thread(DoJob,this); // Do the job and watch it
return O_K; // Yo!
}
INT16 CDlpFile_Reset(CDlpObject* __this, BOOL bResetMembers)
{
GET_THIS_VIRTUAL_RV(CDlpFile,NOT_EXEC);
DEBUGMSG(-1,"CDlpFile_Reset; (bResetMembers=%d)",(int)bResetMembers,0,0);
{
/*{{CGEN_RESETCODE */
CData* idFlistData;
char lpsB1[255];
char lpsB2[255];
char lpsB3[ 32];
char lpsB4[255];
if (_this->m_idFlistData==NULL) IFIELD_RESET(CData,"flist_data");
IFIELD_RESET(CData,"recfile");
dlp_strcpy(lpsB1,_this->m_lpsFlist);
dlp_strcpy(lpsB2,_this->m_lpsPath);
dlp_strcpy(lpsB3,_this->m_lpsExt);
dlp_strcpy(lpsB4,_this->m_lpsSep);
idFlistData = AS(CData,_this->m_idFlistData);
_this->m_idFlistData = NULL;
RESET;
_this->m_idFlistData = BASEINST(idFlistData);
dlp_strcpy(_this->m_lpsFlist,lpsB1);
dlp_strcpy(_this->m_lpsPath ,lpsB2);
dlp_strcpy(_this->m_lpsExt ,lpsB3);
dlp_strcpy(_this->m_lpsSep ,lpsB4);
_this->m_nLen = CData_GetNRecs(AS(CData,_this->m_idFlistData));
/*}}CGEN_RESETCODE */
}
return O_K;
}
/*
* Manual page at statistics.def
*/
INT16 CGEN_PUBLIC CStatistics_Pool
(
CStatistics* _this,
CStatistics* iSrc,
CData* idMap
)
{
INT32 i = 0; /* Current component index */
INT32 nC = 0; /* Current pooled statistics class */
INT32 nCs = 0; /* Current source class index */
INT32 nXC = 0; /* Number of pooled classes */
INT32 nRpb = 0; /* Statistics raw data block size */
INT16 nCheckSave = 0; /* Saved check level */
CData* idAux = NULL; /* Auxilary data instance #1 */
CData* idPmp = NULL; /* Pooling map */
CData* idPcd = NULL; /* Pooled class raw data buffer */
/* Initialize */ /* --------------------------------- */
CHECK_THIS_RV(0); /* Check this instance */
IF_NOK(CStatistics_Check(iSrc)) /* Check source statistics */
return IERROR(_this,ERR_INVALARG,"iSrc",0,0); /* ... */
nCheckSave = _this->m_nCheck; /* Save check level */
CStatistics_Reset(BASEINST(_this),TRUE); /* Reset destination */
_this->m_nCheck = nCheckSave; /* Restore check level */
IFIELD_RESET(CData,"dat"); /* Create pool raw stats. data inst. */
/* Protocol */ /* --------------------------------- */
IFCHECK /* On verbose level 1 */
{ /* >> */
printf("\n"); dlp_fprint_x_line(stdout,'-',dlp_maxprintcols()); /* Print protocol header */
printf("\n statistics -pool"); /* ... */
printf("\n"); dlp_fprint_x_line(stdout,'-',dlp_maxprintcols());printf("\n");/* ... */
} /* << */
/* No map --> pool all classes */ /* --------------------------------- */
if (CData_IsEmpty(idMap)) /* NULL or empty map instance */
{ /* >> */
IFCHECK printf("\n Empty pooling map --> pool all classes"); /* Protocol (verbose level 1) */
CStatistics_PoolInt(_this->m_idDat,iSrc->m_idDat,0); /* Pool sum data */
CStatistics_PoolInt(_this->m_idDat,iSrc->m_idDat,1); /* Pool min data */
CStatistics_PoolInt(_this->m_idDat,iSrc->m_idDat,2); /* Pool max data */
STA_PROTOCOL_FOOTER(1,"done"); /* Print protocol footer */
return O_K; /* That's it */
}
IFCHECK printf("\n Pooling by map"); /* Protocol (verbose level 1) */
ICREATEEX(CData,idAux,"CStatistics_Pool.~idAux",NULL); /* Create auxilary data instance #1 */
ICREATEEX(CData,idPmp,"CStatistics_Pool.~idPmp",NULL); /* Create pooling map */
ICREATEEX(CData,idPcd,"CStatistics_Pool.~idPcs",NULL); /* Create pooled raw stats.data inst.*/
/* Find and copy map component (pooled class) */ /* --------------------------------- */
for (i=0; i<CData_GetNComps(idMap); i++) /* Loop over components of idMap */
if (dlp_is_numeric_type_code(CData_GetCompType(idMap,i))) /* Is current component numeric? */
{ /* >> (Yes) */
CData_SelectComps(idPmp,idMap,i,1); /* Copy component */
break; /* Have ready :) */
} /* << */
if (CData_IsEmpty(idPmp)) /* Have not got map component */
{ /* >> */
IERROR(_this,STA_BADCOMP,"map",BASEINST(idMap)->m_lpInstanceName,"numeric");/* Error message */
DLPTHROW(STA_BADCOMP); /* Throw exception */
} /* << */
/* Create source class component */ /* --------------------------------- */
CData_AddComp(idPmp,"srcc",T_LONG); /* Add source class index component */
for (i=0; i<CData_GetNRecs(idPmp); i++) CData_Dstore(idPmp,i,i,1); /* Fill it */
/* Finish pooling map and initialize pooling */ /* --------------------------------- */
CData_Sortup(idPmp,idPmp,0); /* Sort map by pooled class index */
nXC = (INT32)CData_Dfetch(idPmp,CData_GetNRecs(idPmp)-1,0)+1; /* Get greatest pooled class index */
IFCHECK printf("\n Pooling %ld statistics classes",(long)nXC); /* Protocol (verbose level 1) */
IFCHECKEX(3) CData_Print(idPmp); /* Print pooling map (verbose lvl.3) */
nRpb = CData_GetNRecsPerBlock(iSrc->m_idDat); /* Get block size */
/* Prepare pooled statistics */ /* --------------------------------- */
CData_Scopy(_this->m_idDat,iSrc->m_idDat); /* Create target raw data components */
CData_Allocate(_this->m_idDat,nRpb*nXC); /* Allocate target raw data */
CData_SetNBlocks(_this->m_idDat,nXC); /* Set target statistics block number*/
/* Pooling loop */ /* --------------------------------- */
for (i=0; i<CData_GetNRecs(idPmp); ) /* Loop over pooling map */
{ /* >> */
/* - Copy raw statistics data of one pooled class */ /* - - - - - - - - - - - - - - - - */
nC = (INT32)CData_Dfetch(idPmp,0,0); /* Get pooled class index */
IFCHECK printf("\n Pooled class %3ld"); /* Protocol (verbose level 1) */
for (i=0; i<CData_GetNRecs(idPmp); i++) /* Loop over partition of pool.map */
{ /* >> */
if (nC != (INT32)CData_Dfetch(idPmp,0,0)) break; /* Not the current class anymore */
nCs = (INT32)CData_Dfetch(idPmp,i,1); /* Get source class index */
IFCHECK printf("\n - Source class %3ld",nCs); /* Protocol (verbose level 1) */
CData_SelectBlocks(idAux,iSrc->m_idDat,nCs,1); /* Copy raw stats. data block */
CData_Cat(idPcd,idAux); /* Append to buffer */
} /* << */
/* - Pool data */ /* - - - - - - - - - - - - - - - - */
CData_SetNBlocks(idPcd,CData_GetNRecs(idPcd)/nRpb); /* Set block count of aggr. buffer */
IFCHECK /* Protocol (verbose level 1) */
printf("\n - Aggregating %ld statistics classes", /* | */
(long)CData_GetNBlocks(idPcd)); /* | */
CStatistics_PoolInt(idAux,idPcd,0); /* Pool sum data */
CStatistics_PoolInt(idAux,idPcd,1); /* Pool min data */
CStatistics_PoolInt(idAux,idPcd,2); /* Pool max data */
/* - Store pooled raw statistics data block */ /* - - - - - - - - - - - - - - - - */
dlp_memmove /* Copy pooled raw stats. data */
( /* | */
CData_XAddr(_this->m_idDat,nC*nRpb,0), /* | To target statistics block */
CData_XAddr(idAux,0,0), /* | From aggregation buffer */
CData_GetNRecs(idAux)*CData_GetRecLen(idAux) /* | Length of aggregation buffer */
); /* | */
/* - Clean up auxilary instances */ /* - - - - - - - - - - - - - - - - */
CData_Reset(idPcd,TRUE); /* Clear aggregation buffer */
}
/* Clean up */ /* --------------------------------- */
IDESTROY(idAux); /* Destroy auxilary data instance #1 */
IDESTROY(idPmp); /* Destroy pooling map */
IDESTROY(idPcd); /* Destroy pooled cls. raw data inst.*/
STA_PROTOCOL_FOOTER(1,"done"); /* Print protocol footer */
return O_K; /* Ok */
DLPCATCH(STA_BADCOMP) /* == Catch STA_BADCOMP exception */
IDESTROY(idAux); /* Destroy auxilary data instance #1 */
IDESTROY(idPmp); /* Destroy pooling map */
IDESTROY(idPcd); /* Destroy pooled cls. raw data inst.*/
STA_PROTOCOL_FOOTER(1,"FAILED"); /* Print protocol footer */
return NOT_EXEC; /* Not ok */
}
INT16 CGmm_PrecalcD(CGmm* _this, BOOL bCleanup)
#endif
{
INT32 i = 0; /* Triangular inv. cov. matrix cntr. */
INT32 c = 0; /* Index of inv. covariance matrix */
INT32 k = 0; /* Gaussian loop counter */
INT32 n = 0; /* Dimension loop counter */
INT32 m = 0; /* Dimension loop counter */
INT32 K = 0; /* Number of single Gaussians */
INT32 N = 0; /* Feature space dimensionality */
GMM_FTYPE nDelta1 = 0.; /* Class indep. term of delta const. */
#ifdef __TMS
GMM_FTYPE *mean = (GMM_FTYPE*)CData_XAddr(AS(CData,_this->m_idMean),0,0);
#endif
/* Clean up precalculated data */ /* --------------------------------- */
dlp_free(_this->m_lpAlpha); /* Clear alpha vector */
dlp_free(_this->m_lpBeta ); /* Clear beta vectors */
dlp_free(_this->m_lpGamma); /* Clear gamma vector */
dlp_free(_this->m_lpDelta); /* Clear delta vector */
dlp_free(_this->m_lpI ); /* Clear inv. cov. pointer array */
dlp_free(_this->m_lpV ); /* Clear inverse variance array */
if(_this->m_idSse2Icov){
CData *idSse2Icov=AS(CData,_this->m_idSse2Icov);
IDESTROY(idSse2Icov); /* Destroy inv.covs. for SSE2 opt. */
_this->m_idSse2Icov=NULL;
}
dlp_free(_this->m_lpSse2Buf); /* Clear aux. buffer for SSE2 opt. */
dlp_free(_this->m_lpLdlL); /* Clear L-matrix buffer for LDL */
dlp_free(_this->m_lpLdlD); /* Clear D-vector buffer for LDL */
_this->m_nN = 0; /* Clear feature space dimensionality*/
_this->m_nK = 0; /* Clear number of single Gaussians */
if (bCleanup) return O_K; /* When cleaning up that's it */
/* Initialize */ /* --------------------------------- */
K = CGmm_GetNGauss(_this); /* Get nuumber of single Gaussians */
N = CGmm_GetDim(_this); /* Get feature space dimensionality */
nDelta1 = -N/2*log(2*F_PI); /* Compute part of delta term */
/* Basic validation */ /* --------------------------------- */
IF_NOK(CGmm_CheckMean(_this)) DLPTHROW(GMM_NOTSETUP); /* Check mean vectors */
IF_NOK(CGmm_CheckIvar(_this)) DLPTHROW(GMM_NOTSETUP); /* Check inverse variance vectors */
IF_NOK(CGmm_CheckCdet(_this)) DLPTHROW(GMM_NOTSETUP); /* Check (co-)variance determinants */
/* Basic dimensions */ /* --------------------------------- */
_this->m_nN = N; /* Feature space dimensionality */
_this->m_nK = K; /* Number of single Gaussians */
/* Create inverse covariance matrix map */ /* --------------------------------- */
if (_this->m_idIcov) /* If using covariances */
{ /* >> */
IF_NOK(CGmm_CheckIcov(_this)) DLPTHROW(GMM_NOTSETUP); /* Inverse covariance data corrupt */
_this->m_lpI = dlp_calloc(K,sizeof(GMM_FTYPE*)); /* Allocate map */
if (!_this->m_lpI) DLPTHROW(ERR_NOMEM); /* Out of memory */
for (k=0; k<K; k++) /* Loop over Gaussians */
{ /* >> */
c=_this->m_idCmap ? (INT32)CData_Dfetch(AS(CData,_this->m_idCmap),k,0) : k;/* Cov. mat. idx. for Gaussian k */
I[k] = (GMM_FTYPE*)CData_XAddr(AS(CData,_this->m_idIcov),c,0); /* Store ptr. to inv. cov. matrix*/
} /* << */
} /* << */
/* Create inverse variance vector map */ /* --------------------------------- */
IF_NOK(CGmm_CheckIvar(_this)) DLPTHROW(GMM_NOTSETUP); /* Inverse covariance data corrupt */
_this->m_lpV = dlp_calloc(K,sizeof(GMM_FTYPE*)); /* Allocate map */
if (!_this->m_lpV) DLPTHROW(ERR_NOMEM); /* Out of memory */
for (k=0; k<K; k++) /* Loop over Gaussians */
V[k] = (GMM_FTYPE*)CData_XAddr(AS(CData,_this->m_idIvar),k,0); /* Store ptr. to inv. cov. matrix*/
/* LDL-factorization */ /* --------------------------------- */
if(_this->m_nLDL) /* LDL factorization used */
{ /* >> */
/* TODO: GMM_TYPE is float => dlm_factldl in float */ /* ------------------------------- */
_this->m_lpLdlL = dlp_malloc(K*N*(N-1)/2*sizeof(GMM_FTYPE)); /* Alloc L matrix */
_this->m_lpLdlD = dlp_malloc(K*N*sizeof(GMM_FTYPE)); /* Alloc D vector */
if (!_this->m_lpLdlL || !_this->m_lpLdlD) DLPTHROW(ERR_NOMEM); /* Out of memory */
{
FLOAT64 *lpAux1 = (FLOAT64 *)dlp_malloc(N*N*sizeof(FLOAT64)); /* Alloc auxilary matrix #1 */
FLOAT64 *lpAux2 = (FLOAT64 *)dlp_malloc(N*N*sizeof(FLOAT64)); /* Alloc auxilary matrix #2 */
if (!lpAux1 || !lpAux2) DLPTHROW(ERR_NOMEM); /* Out of memory */
for(k=0;k<K;k++) /* Loop over all Gaussians */
{ /* >> */
for(n=0;n<N;n++) /* Loop over Gaussian dimension */
{ /* >> */
lpAux1[n*N+n] = V[k][n]; /* Copy inverse variance values*/
for(m=0;m<n;m++) lpAux1[n*N+m] = lpAux1[m*N+n] = /* Copy inverse covariance val.*/
I?I[k][m*N-2*m-m*(m-1)/2+n-1]:0.; /* | */
} /* << */
dlm_factldl(lpAux1,lpAux2,N); /* Factorize matrix */
for(n=0;n<N;n++) /* Loop over Gaussian dimension */
{ /* >> */
for(m=n+1;m<N;m++) Li(N,k,n,m) = lpAux1[n*N+m]; /* Store L matrix values */
D(N,k,n) = lpAux2[n*N+n]; /* Store D vector values */
} /* << */
if(_this->m_nLdlCoef>=0 && _this->m_nLdlCoef<N*(N-1)/2)
{
FLOAT64 nMinAbs;
memcpy(lpAux1,&L(N,k,0),N*(N-1)/2);
#if GMM_FTYPE_CODE == T_FLOAT
qsort(lpAux1,N*(N-1)/2,sizeof(FLOAT64),cf_absfloat_down);
#else
qsort(lpAux1,N*(N-1)/2,sizeof(FLOAT64),cf_absdouble_down);
#endif
nMinAbs=fabs(lpAux1[_this->m_nLdlCoef]);
for(n=0;n<N*(N-1)/2;n++) if(fabs(L(N,k,n))<=nMinAbs) L(N,k,n)=0.;
}
} /* << */
dlp_free(lpAux1); /* Free auxilary matrix #1 */
dlp_free(lpAux2); /* Free auxilary matrix #2 */
}
} /* << */
/* Precalculate alpha and beta vectors */ /* --------------------------------- */
if(!_this->m_nLDL) /* No LDL factorization used */
{ /* >> */
_this->m_lpAlpha = dlp_calloc(K,sizeof(GMM_FTYPE)); /* Allocate buffer */
_this->m_lpBeta = dlp_calloc(K*N,sizeof(GMM_FTYPE)); /* Allocate buffer */
if (!_this->m_lpAlpha || !_this->m_lpBeta) DLPTHROW(ERR_NOMEM); /* Out of memory */
for (k=0; k<K; k++) /* Loop over Gaussians */
for (n=0; n<N; n++) /* Loop over dimensions */
for (m=0; m<N; m++) /* Loop over dimensions */
if (m==n) /* Main diagonal (variances)?*/
{ /* >> */
alpha[k] += V[k][n]*mu(k,m)*mu(k,n); /* Sum up alpha val. (n==m)*/
beta [k*N+n] += V[k][n]*mu(k,m); /* Sum up beta value (n==m)*/
} /* << */
else if (_this->m_lpI) /* Otherwise cov.(if present)*/
{ /* >> */
if (m>n) i = n*N - 2*n - n*(n-1)/2 + m - 1; /* Calc index if I[n,m] in */
else i = m*N - 2*m - m*(m-1)/2 + n - 1; /* | triangular icov. mat. */
alpha[k] += I[k][i]*mu(k,m)*mu(k,n); /* Sum up alpha val. (n!=m)*/
beta [k*N+n] += I[k][i]*mu(k,m); /* Sum up beta value (n!=m)*/
} /* << */
} /* << */
else /* LDL factorization used */
{ /* >> */
_this->m_lpAlpha = NULL; /* No alpha needed here */
_this->m_lpBeta = dlp_calloc(K*N,sizeof(GMM_FTYPE)); /* Allocate buffer */
if (!_this->m_lpBeta) DLPTHROW(ERR_NOMEM); /* Out of memory */
for(k=0;k<K;k++) for(n=0;n<N;n++) /* Loop over Gaussians & dimensions*/
{ /* >> */
beta[k*N+n] = mu(k,n); /* Init beta with mean value */
for(m=n+1;m<N;m++) beta[k*N+n] += mu(k,m)*Li(N,k,n,m); /* Calculate beta from L*mu */
} /* << */
} /* << */
/* Allocate gamma vector */ /* --------------------------------- */
/* NOTE: If this fails there will just be no lazy computation -> no big deal*//* */
if (_this->m_idCmap && _this->m_idIcov && _this->m_lpI) /* Wanna do lazy computation? */
if (CData_GetDescr(AS(CData,_this->m_idIvar),0)==0.) /* Only if variances are tied too */
_this->m_lpGamma = dlp_calloc(K,sizeof(GMM_FTYPE)); /* Allocate buffer */
/* Precalculate delta vector */ /* --------------------------------- */
_this->m_lpDelta = dlp_calloc(K,sizeof(GMM_FTYPE)); /* Allocate buffer */
if (!_this->m_lpDelta) DLPTHROW(ERR_NOMEM); /* Out of memory */
for (k=0; k<K; k++) /* Loop over Gaussians */
delta[k] = nDelta1-(GMM_FTYPE)(0.5*log( /* Calculate delta[k] */
CData_Dfetch(AS(CData,_this->m_idCdet),k,0))); /* | */
/* SSE2 precalculated objects */ /* --------------------------------- */
#ifdef GMM_SSE2 /* Use SSE2? */
IFIELD_RESET(CData,"sse2_icov"); /* Create/reset SSE2 inv.cov. matrs. */
CGmm_Extract(_this,NULL,_this->m_idSse2Icov); /* ... and go get 'em */
_this->m_lpSse2Buf = dlp_calloc(2*N,sizeof(GMM_FTYPE)); /* Allocate auxilary buffer */
if (!_this->m_lpSse2Buf) DLPTHROW(ERR_NOMEM); /* Out of memory */
#endif /* #ifdef GMM_SSE2 */
/* Final checkup */ /* --------------------------------- */
#ifndef __NOXALLOC
IF_NOK(CGmm_CheckPrecalc(_this)) DLPTHROW(GMM_NOTSETUP); /* Check precalculated data */
#endif
return O_K; /* That's it folks ... */
DLPCATCH(GMM_NOTSETUP) /* On NOT_EXEC exception */
DLPCATCH(ERR_NOMEM) /* On ERR_NOMEM exception */
#if GMM_FTYPE_CODE == T_FLOAT
CGmm_PrecalcF(_this,TRUE); /* - Free memory of precalc'd. data */
#else
CGmm_PrecalcD(_this,TRUE); /* - Free memory of precalc'd. data */
#endif
return NOT_EXEC; /* - Indicate failure */
}