Sparsity CSparseCholeskyInterface::linsol_cholesky_sparsity(void* mem, bool tr) const {
auto m = static_cast<CsparseCholMemory*>(mem);
casadi_assert(m->S);
int n = m->A.n;
int nzmax = m->S->cp[n];
std::vector< int > row(n+1);
std::copy(m->S->cp, m->S->cp+n+1, row.begin());
std::vector< int > colind(nzmax);
int *Li = &colind.front();
int *Lp = &row.front();
const cs* C;
C = m->S->pinv ? cs_symperm(&m->A, m->S->pinv, 1) : &m->A;
std::vector< int > temp(2*n);
int *c = &temp.front();
int *s = c+n;
for (int k = 0 ; k < n ; k++) c[k] = m->S->cp[k] ;
for (int k = 0 ; k < n ; k++) { /* compute L(k, :) for L*L' = C */
int top = cs_ereach(C, k, m->S->parent, s, c) ;
for ( ; top < n ; top++) { /* solve L(0:k-1, 0:k-1) * x = C(:, k) */
int i = s[top] ; /* s[top..n-1] is pattern of L(k, :) */
int p = c[i]++ ;
Li[p] = k ; /* store L(k, i) in row i */
}
int p = c[k]++ ;
Li[p] = k ;
}
Lp[n] = m->S->cp[n] ;
Sparsity ret(n, n, row, colind); // BUG?
return tr ? ret.T() : ret;
}
Sparsity CSparseCholeskyInternal::getFactorizationSparsity(bool transpose) const {
casadi_assert(S_);
int n = AT_.n;
int nzmax = S_->cp[n];
std::vector< int > row(n+1);
std::copy(S_->cp, S_->cp+n+1, row.begin());
std::vector< int > colind(nzmax);
int *Li = &colind.front();
int *Lp = &row.front();
const cs* C;
C = S_->pinv ? cs_symperm(&AT_, S_->pinv, 1) : &AT_;
std::vector< int > temp(2*n);
int *c = & temp.front();
int *s = c+n;
for (int k = 0 ; k < n ; k++) c[k] = S_->cp[k] ;
for (int k = 0 ; k < n ; k++) { /* compute L(k, :) for L*L' = C */
int top = cs_ereach(C, k, S_->parent, s, c) ;
for ( ; top < n ; top++) { /* solve L(0:k-1, 0:k-1) * x = C(:, k) */
int i = s[top] ; /* s[top..n-1] is pattern of L(k, :) */
int p = c[i]++ ;
Li[p] = k ; /* store L(k, i) in row i */
}
int p = c[k]++ ;
Li[p] = k ;
}
Lp[n] = S_->cp[n] ;
Sparsity ret(n, n, row, colind); // BUG?
return transpose? ret.T() : ret;
}
DM CSparseCholeskyInterface::linsol_cholesky(void* mem, bool tr) const {
auto m = static_cast<CsparseCholMemory*>(mem);
casadi_assert(m->L);
cs *L = m->L->L;
int nz = L->nzmax;
std::vector< int > colind(L->m+1);
std::copy(L->p, L->p+L->m+1, colind.begin());
std::vector< int > row(nz);
std::copy(L->i, L->i+nz, row.begin());
std::vector< double > data(nz);
std::copy(L->x, L->x+nz, data.begin());
DM ret(Sparsity(L->n, L->m, colind, row), data, false);
return tr ? ret.T() : ret;
}
DMatrix CSparseCholeskyInternal::getFactorization(bool transpose) const {
casadi_assert(L_);
cs *L = L_->L;
int nz = L->nzmax;
int m = L->m; // number of cols
int n = L->n; // number of rows
std::vector< int > colind(m+1);
std::copy(L->p, L->p+m+1, colind.begin());
std::vector< int > row(nz);
std::copy(L->i, L->i+nz, row.begin());
std::vector< double > data(nz);
std::copy(L->x, L->x+nz, data.begin());
DMatrix ret(Sparsity(n, m, colind, row), data, false);
return transpose? ret.T() : ret;
}
void CSparseCholeskyInterface::reset(void* mem, const int* sp) const {
LinsolInternal::reset(mem, sp);
auto m = static_cast<CsparseCholMemory*>(mem);
m->L = 0;
m->S = 0;
m->A.nzmax = m->nnz(); // maximum number of entries
m->A.m = m->nrow(); // number of columns
m->A.n = m->ncol(); // number of rows
m->A.p = const_cast<int*>(m->colind()); // row pointers (size n+1)
// or row indices (size nzmax)
m->A.i = const_cast<int*>(m->row()); // column indices, size nzmax
m->A.x = 0; // numerical values, size nzmax
m->A.nz = -1; // of entries in triplet matrix, -1 for compressed-row
// Temporary
m->temp.resize(m->A.n);
}
Sparsity blkdiag(const std::vector< Sparsity > &v) {
int n = 0;
int m = 0;
std::vector<int> colind(1,0);
std::vector<int> row;
int nz = 0;
for (int i=0;i<v.size();++i) {
const std::vector<int> &colind_ = v[i].colind();
const std::vector<int> &row_ = v[i].row();
for (int k=1;k<colind_.size();++k) {
colind.push_back(colind_[k]+nz);
}
for (int k=0;k<row_.size();++k) {
row.push_back(row_[k]+m);
}
n+= v[i].size2();
m+= v[i].size1();
nz+= v[i].size();
}
return Sparsity(m,n,colind,row);
}
/// Number of structural non-zeros
inline int nnz() const { return colind()[size2()];}
/** \brief Get row indices (see public class) */
inline const int* row() const { return colind()+size2()+1;}
