double MarkovChain::getSequenceProbability(char* sequence, int seqElementsNum, char* elements, int numOfElements, char ** sequences, int numSequences){
double probability = 1.0;
int ** transitionMatrix = createTransitionMatrix(elements, numOfElements, sequences, numSequences);;
int * rowsTotals = countRowsTotals(transitionMatrix, numOfElements);
double **transitionProbabilityMatrix = createTransitionProbabilityMatrix(rowsTotals, transitionMatrix, numOfElements);
double * firstStateProbabilities = calculateFirstStatesProbabilities (elements, numOfElements, sequences, numSequences);
for (int i = 0; i < seqElementsNum-1; i++) {
int row = getElementPosition(sequence[i], elements, numOfElements);
int col = getElementPosition(sequence[i+1], elements, numOfElements);
probability = probability * transitionProbabilityMatrix[row][col];
}
int firstElementPos = getElementPosition(sequence[0], elements, numOfElements);
probability = firstStateProbabilities[firstElementPos] * probability;
for(int i = 0; i < numOfElements; i++)
free(transitionMatrix[i]);
free(transitionMatrix);
free(rowsTotals);
for(int i = 0; i < numOfElements; i++)
free(transitionProbabilityMatrix[i]);
free(transitionProbabilityMatrix);
free (firstStateProbabilities);
return probability;
}
/*!
If there are more than one transformation, a new temporary grid will be created and it will play the role of grid destination.
This new created one keeps a pointer to the real transformed element of grid destination and generate new copies of other elements from grid source.
\param [in] elementPositionInGrid position of element in grid
\param [in] transType transformation type
*/
void CGridTransformation::setUpGridDestination(int elementPositionInGrid, ETranformationType transType)
{
if (isSpecialTransformation(transType)) return;
if (!tempGridDests_.empty() && (getNbAlgo() == tempGridDests_.size()))
{
tempGridDests_.resize(0);
}
if (1 == getNbAlgo())
{
tmpGridDestination_ = gridDestination_;
return;
}
std::vector<CScalar*> scalarListDestP = gridDestination_->getScalars();
std::vector<CScalar*> scalarListSrcP = gridSource_->getScalars(), scalarDst;
std::vector<CAxis*> axisListDestP = gridDestination_->getAxis();
std::vector<CAxis*> axisListSrcP = gridSource_->getAxis(), axisDst;
std::vector<CDomain*> domListDestP = gridDestination_->getDomains();
std::vector<CDomain*> domListSrcP = gridSource_->getDomains(), domainDst;
CArray<int,1> axisDomainOrderSrc = gridSource_->axis_domain_order;
CArray<int,1> axisDomainOrderDst = gridDestination_->axis_domain_order;
std::map<int,std::pair<int,int> > elementPositionSrc = getElementPosition(gridSource_);
std::map<int,std::pair<int,int> > elementPositionDst = getElementPosition(gridDestination_);
CArray<int,1> elementOrder(axisDomainOrderDst.numElements());
for (int idx = 0; idx < axisDomainOrderDst.numElements(); ++idx)
{
if (elementPositionInGrid == idx)
{
int dimElementDst = elementPositionDst[idx].first;
int elementIndex = elementPositionDst[idx].second;
switch (dimElementDst)
{
case 2:
domainDst.push_back(domListDestP[elementIndex]);
break;
case 1:
axisDst.push_back(axisListDestP[elementIndex]);
break;
case 0:
scalarDst.push_back(scalarListDestP[elementIndex]);
break;
default:
break;
}
elementOrder(idx) = dimElementDst;
}
else
{
int dimElementSrc = elementPositionSrc[idx].first;
int elementIndex = elementPositionSrc[idx].second;
switch (dimElementSrc)
{
case 2:
domainDst.push_back(domListSrcP[elementIndex]);
break;
case 1:
axisDst.push_back(axisListSrcP[elementIndex]);
break;
case 0:
scalarDst.push_back(scalarListSrcP[elementIndex]);
break;
default:
break;
}
elementOrder(idx) = dimElementSrc;
}
}
tmpGridDestination_ = CGrid::createGrid(domainDst, axisDst, scalarDst, elementOrder);
tempGridDests_.push_back(tmpGridDestination_);
}
/*!
Assign the current grid destination to the grid source in the new transformation.
The current grid destination plays the role of grid source in next transformation (if any).
Only element on which the transformation is performed is modified
\param [in] elementPositionInGrid position of element in grid
\param [in] transType transformation type
*/
void CGridTransformation::setUpGridSource(int elementPositionInGrid)
{
if (!tempGridSrcs_.empty() && (getNbAlgo()-1) == tempGridSrcs_.size())
{
tempGridSrcs_.resize(0);
}
std::vector<CScalar*> scalarListDestP = tmpGridDestination_->getScalars();
std::vector<CScalar*> scalarListSrcP = gridSource_->getScalars(), scalarSrc;
std::vector<CAxis*> axisListDestP = tmpGridDestination_->getAxis();
std::vector<CAxis*> axisListSrcP = gridSource_->getAxis(), axisSrc;
std::vector<CDomain*> domListDestP = tmpGridDestination_->getDomains();
std::vector<CDomain*> domListSrcP = gridSource_->getDomains(), domainSrc;
CArray<int,1> axisDomainOrderSrc = gridSource_->axis_domain_order;
CArray<int,1> axisDomainOrderDst = tmpGridDestination_->axis_domain_order;
std::map<int,std::pair<int,int> > elementPositionSrc = getElementPosition(gridSource_);
std::map<int,std::pair<int,int> > elementPositionDst = getElementPosition(tmpGridDestination_);
for (int idx = 0; idx < axisDomainOrderDst.numElements(); ++idx)
{
if (elementPositionInGrid == idx)
{
int dimElementDst = elementPositionDst[idx].first;
int elementIndex = elementPositionDst[idx].second;
if (2 == dimElementDst)
{
CDomain* domain = CDomain::createDomain();
domain->domain_ref.setValue(domListDestP[elementIndex]->getId());
domain->solveRefInheritance(true);
domain->checkAttributesOnClient();
domainSrc.push_back(domain);
}
else if (1 == dimElementDst)
{
CAxis* axis = CAxis::createAxis();
axis->axis_ref.setValue(axisListDestP[elementIndex]->getId());
axis->solveRefInheritance(true);
axis->checkAttributesOnClient();
axisSrc.push_back(axis);
}
else
{
CScalar* scalar = CScalar::createScalar();
scalar->scalar_ref.setValue(scalarListDestP[elementIndex]->getId());
scalar->solveRefInheritance(true);
scalar->checkAttributesOnClient();
scalarSrc.push_back(scalar);
}
}
else
{
int dimElementDst = elementPositionDst[idx].first;
int elementIndex = elementPositionDst[idx].second;
switch (dimElementDst)
{
case 2:
domainSrc.push_back(domListDestP[elementIndex]);
break;
case 1:
axisSrc.push_back(axisListDestP[elementIndex]);
break;
case 0:
scalarSrc.push_back(scalarListDestP[elementIndex]);
break;
default:
break;
}
}
}
gridSource_ = CGrid::createGrid(domainSrc, axisSrc, scalarSrc, tmpGridDestination_->axis_domain_order);
tempGridSrcs_.push_back(gridSource_);
}
// get local bounds of an element.
//
MLRect MLPositioner::getElementBounds(int elementIdx)
{
Vec2 e = getElementPosition(elementIdx);
return correctRect(MLRect(e, e + mElementSize));
}
