double MarginalCovarianceCholesky::computeEntry(int r, int c)
{
assert(r <= c);
int idx = computeIndex(r, c);
LookupMap::const_iterator foundIt = _map.find(idx);
if (foundIt != _map.end()) {
return foundIt->second;
}
// compute the summation over column r
double s = 0.;
const int& sc = _Ap[r];
const int& ec = _Ap[r+1];
for (int j = sc+1; j < ec; ++j) { // sum over row r while skipping the element on the diagonal
const int& rr = _Ai[j];
double val = rr < c ? computeEntry(rr, c) : computeEntry(c, rr);
s += val * _Ax[j];
}
double result;
if (r == c) {
const double& diagElem = _diag[r];
result = diagElem * (diagElem - s);
} else {
result = -s * _diag[r];
}
_map[idx] = result;
return result;
}
Matrix calculateDemagTensor_old(long double lx, long double ly, long double lz, int nx, int ny, int nz, int ex, int ey, int ez, int repeat_x, int repeat_y, int repeat_z)
{
LOG_DEBUG<< "Generating.";
Matrix N(Shape(6, ex, ey, ez)); N.fill(0.0);
Matrix::wo_accessor N_acc(N);
const int dx_len = repeat_x*nx-1;
const int dy_len = repeat_y*ny-1;
const int dz_len = repeat_z*nz-1;
int cnt = 0, percent = 0;
for (int dz=0; dz<=+dz_len; dz+=1) {
for (int dy=0; dy<=+dy_len; dy+=1) {
for (int dx=0; dx<=+dx_len; dx+=1) {
computeEntry(N_acc, dx, dy, dz, lx, ly, lz, ex, ey, ez);
}
cnt += 1;
if (100.0 * cnt / ((dy_len+1)*(dz_len+1)) > percent) {
LOG_INFO << " " << percent << "%";
percent += 5;
}
}
}
LOG_INFO << "Done.";
return N;
}
void MarginalCovarianceCholesky::computeCovariance(double** covBlocks, const std::vector<int>& blockIndices)
{
_map.clear();
int base = 0;
vector<MatrixElem> elemsToCompute;
for (size_t i = 0; i < blockIndices.size(); ++i) {
int nbase = blockIndices[i];
int vdim = nbase - base;
for (int rr = 0; rr < vdim; ++rr)
for (int cc = rr; cc < vdim; ++cc) {
int r = _perm ? _perm[rr + base] : rr + base; // apply permutation
int c = _perm ? _perm[cc + base] : cc + base;
if (r > c) // make sure it's still upper triangular after applying the permutation
swap(r, c);
elemsToCompute.push_back(MatrixElem(r, c));
}
base = nbase;
}
// sort the elems to reduce the recursive calls
sort(elemsToCompute.begin(), elemsToCompute.end());
// compute the inverse elements we need
for (size_t i = 0; i < elemsToCompute.size(); ++i) {
const MatrixElem& me = elemsToCompute[i];
computeEntry(me.r, me.c);
}
// set the marginal covariance for the vertices, by writing to the blocks memory
base = 0;
for (size_t i = 0; i < blockIndices.size(); ++i) {
int nbase = blockIndices[i];
int vdim = nbase - base;
double* cov = covBlocks[i];
for (int rr = 0; rr < vdim; ++rr)
for (int cc = rr; cc < vdim; ++cc) {
int r = _perm ? _perm[rr + base] : rr + base; // apply permutation
int c = _perm ? _perm[cc + base] : cc + base;
if (r > c) // upper triangle
swap(r, c);
int idx = computeIndex(r, c);
LookupMap::const_iterator foundIt = _map.find(idx);
assert(foundIt != _map.end());
cov[rr*vdim + cc] = foundIt->second;
if (rr != cc)
cov[cc*vdim + rr] = foundIt->second;
}
base = nbase;
}
}
void SmithWatermanDP::computeMatrix() {
// if enabled init the backtrack matrix
if (this->btEnabled) {
// init or reset backtrack matrix
if (this->btMatrix == NULL) {
this->initBtMatrix();
} else {
this->resetBtMatrix();
}
}
// compute the score matrix
for (size_t i = 1; i < n; i++ ) {
for (size_t j = 1; j < m; j++ ) {
computeEntry(i,j);
// IMPORTANT: this operation must be performed AFTER computeEntry()
if (this->btEnabled) {
this->btMatrix[i][j] = getBtForPosition(i,j);
}
}
}
}
void MarginalCovarianceCholesky::computeCovariance(SparseBlockMatrix<MatrixXD>& spinv, const std::vector<int>& rowBlockIndices, const std::vector< std::pair<int, int> >& blockIndices)
{
// allocate the sparse
spinv = SparseBlockMatrix<MatrixXD>(&rowBlockIndices[0],
&rowBlockIndices[0],
rowBlockIndices.size(),
rowBlockIndices.size(), true);
_map.clear();
vector<MatrixElem> elemsToCompute;
for (size_t i = 0; i < blockIndices.size(); ++i) {
int blockRow=blockIndices[i].first;
int blockCol=blockIndices[i].second;
assert(blockRow>=0);
assert(blockRow < (int)rowBlockIndices.size());
assert(blockCol>=0);
assert(blockCol < (int)rowBlockIndices.size());
int rowBase=spinv.rowBaseOfBlock(blockRow);
int colBase=spinv.colBaseOfBlock(blockCol);
MatrixXD *block=spinv.block(blockRow, blockCol, true);
assert(block);
for (int iRow=0; iRow<block->rows(); ++iRow)
for (int iCol=0; iCol<block->cols(); ++iCol){
int rr=rowBase+iRow;
int cc=colBase+iCol;
int r = _perm ? _perm[rr] : rr; // apply permutation
int c = _perm ? _perm[cc] : cc;
if (r > c)
swap(r, c);
elemsToCompute.push_back(MatrixElem(r, c));
}
}
// sort the elems to reduce the number of recursive calls
sort(elemsToCompute.begin(), elemsToCompute.end());
// compute the inverse elements we need
for (size_t i = 0; i < elemsToCompute.size(); ++i) {
const MatrixElem& me = elemsToCompute[i];
computeEntry(me.r, me.c);
}
// set the marginal covariance
for (size_t i = 0; i < blockIndices.size(); ++i) {
int blockRow=blockIndices[i].first;
int blockCol=blockIndices[i].second;
int rowBase=spinv.rowBaseOfBlock(blockRow);
int colBase=spinv.colBaseOfBlock(blockCol);
MatrixXD *block=spinv.block(blockRow, blockCol);
assert(block);
for (int iRow=0; iRow<block->rows(); ++iRow)
for (int iCol=0; iCol<block->cols(); ++iCol){
int rr=rowBase+iRow;
int cc=colBase+iCol;
int r = _perm ? _perm[rr] : rr; // apply permutation
int c = _perm ? _perm[cc] : cc;
if (r > c)
swap(r, c);
int idx = computeIndex(r, c);
LookupMap::const_iterator foundIt = _map.find(idx);
assert(foundIt != _map.end());
(*block)(iRow, iCol) = foundIt->second;
}
}
}
