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; } } }