CPNLBase *
CPersistCondSoftMaxDistribFun::Load(CContextLoad *pContext)
{
int nNode;
bool bFactor;
bool isUnitFun;
CCondSoftMaxDistribFun *pDF;
const CNodeType *const* ppNodeType;
LoadForDistribFun(&isUnitFun, &nNode, &ppNodeType, pContext);
pContext->GetAttribute(&nNode, "NumberOfNodes");
pContext->GetAttribute(&bFactor, "IsFactor");
CMatrix<CSoftMaxDistribFun*> *mat = static_cast<CMatrix<CSoftMaxDistribFun*>*>(
pContext->Get("DistributionMatrix"));
pDF = CCondSoftMaxDistribFun::Create(nNode, ppNodeType);
CMatrixIterator<CSoftMaxDistribFun*> *it = mat->InitIterator();
intVector index;
for(; mat->IsValueHere(it); mat->Next(it))
{
mat->Index(it, &index);
pDF->SetDistribFun(*mat->Value(it), &index.front());
}
delete it;
return pDF;
}
void CSamplingInfEngine::Normalization(CPotential *pot)
{
if( pot->GetDistributionType() != dtTabular )
{
const pConstNodeTypeVector *nt = pot->GetDistribFun()->GetNodeTypesVector();
CDistribFun *pUnitFun = CGaussianDistribFun::
CreateUnitFunctionDistribution(nt->size(), &nt->front());
pot->SetDistribFun(pUnitFun);
delete pUnitFun;
}
else
{
CMatrix< float > *pMatToSample;
pMatToSample = static_cast<CTabularDistribFun*>(pot->GetDistribFun())
->GetMatrix(matTable);
EMatrixClass mc = pMatToSample->GetMatrixClass();
if( mc != mcNumericDense || mc != mc2DNumericDense )
{
CMatrixIterator<float>* iter = pMatToSample->InitIterator();
for( iter; pMatToSample->IsValueHere( iter ); pMatToSample->Next(iter) )
{
*const_cast<float*>(pMatToSample->Value( iter )) = 1.0f;;
}
delete iter;
}
else
{
floatVector *data = const_cast< floatVector *>(
static_cast<CNumericDenseMatrix<float>*>(pMatToSample)->GetVector());
floatVector::iterator it1 = data->begin();
floatVector::iterator it2 = data->end();
for( ; it1 != it2; it1++ )
{
*it1 = 1.0f;
}
}
}
}
bool CSamplingInfEngine::
ConvertingFamilyToPot( int node, const CEvidence* pEv )
{
bool ret = false;
CPotential* potToSample = m_potsToSampling[node];
Normalization(potToSample);
int i;
if( !IsAllNdsTab() )
{
if( GetModel()->GetModelType() == mtBNet )
{
for( i = 0; i < m_environment[node].size(); i++ )
{
int num = m_environment[node][i];
CPotential *pot1 = static_cast< CCPD* >( m_currentFactors[ num ] )
->ConvertWithEvidenceToPotential(pEv);
CPotential *pot2 = pot1->Marginalize(&node, 1);
delete pot1;
*potToSample *= *pot2;
delete pot2;
}
}
else
{
for( i = 0; i < m_environment[node].size(); i++ )
{
int num = m_environment[node][i];
CPotential *pot1 = static_cast< CPotential* >( m_currentFactors[ num ] )
->ShrinkObservedNodes(pEv);
CPotential *pot2 = pot1->Marginalize(&node, 1);
delete pot1;
*potToSample *= *pot2;
delete pot2;
}
}
}
else
{
CMatrix< float > *pMatToSample;
pMatToSample = static_cast<CTabularDistribFun*>(potToSample->GetDistribFun())
->GetMatrix(matTable);
intVector dims;
intVector vls;
intVector domain;
for( i = 0; i < m_environment[node].size(); i++ )
{
int num = m_environment[node][i];
m_currentFactors[ num ]->GetDomain(&domain);
GetObsDimsWithVls( domain, node, pEv, &dims, &vls);
CMatrix< float > *pMat;
pMat = static_cast<CTabularDistribFun*>(m_currentFactors[ num ]->
GetDistribFun())->GetMatrix(matTable);
pMat->ReduceOp( &dims.front(), dims.size(), 2, &vls.front(),
pMatToSample, PNL_ACCUM_TYPE_MUL );
dims.clear();
vls.clear();
domain.clear();
}
}
//check for non zero elements
CMatrix<float> *pMat;
if( potToSample->GetDistributionType()==dtTabular )
{
pMat = potToSample->GetDistribFun()->GetMatrix(matTable);
}
else
{
CGaussianDistribFun* pDistr = static_cast<CGaussianDistribFun*>(potToSample->GetDistribFun());
if(pDistr->GetMomentFormFlag())
{
pMat = pDistr->GetMatrix(matCovariance);
}
else
{
pMat = pDistr->GetMatrix(matK);
}
}
CMatrixIterator<float>* iter = pMat->InitIterator();
for( iter; pMat->IsValueHere( iter ); pMat->Next(iter) )
{
if(*(pMat->Value( iter )) > FLT_EPSILON)
{
ret = true;
break;
}
}
delete iter;
return ret;
}
