bool EigenLisLinearSolver::solve(EigenMatrix &A_, EigenVector& b_,
EigenVector &x_)
{
static_assert(EigenMatrix::RawMatrixType::IsRowMajor,
"Sparse matrix is required to be in row major storage.");
auto &A = A_.getRawMatrix();
auto &b = b_.getRawVector();
auto &x = x_.getRawVector();
if (!A.isCompressed())
A.makeCompressed();
int nnz = A.nonZeros();
int* ptr = A.outerIndexPtr();
int* col = A.innerIndexPtr();
double* data = A.valuePtr();
LisMatrix lisA(A_.getNumberOfRows(), nnz, ptr, col, data);
LisVector lisb(b.rows(), b.data());
LisVector lisx(x.rows(), x.data());
LisLinearSolver lissol; // TODO not always creat Lis solver here
lissol.setOption(_lis_option);
lissol.solve(lisA, lisb, lisx);
for (std::size_t i=0; i<lisx.size(); i++)
x[i] = lisx[i];
return true; // TODO implement checks
}
void EigenLinearSolver::solve(EigenVector &b, EigenVector &x)
{
INFO("------------------------------------------------------------------");
INFO("*** Eigen solver computation");
_solver->solve(b.getRawVector(), x.getRawVector(), _option);
INFO("------------------------------------------------------------------");
}
void setVector(EigenVector& v_,
std::initializer_list<double> values)
{
auto& v(v_.getRawVector());
assert((std::size_t)v.size() == values.size());
auto it = values.begin();
for (std::size_t i = 0; i < values.size(); ++i)
v[i] = *(it++);
}
bool EigenLinearSolver::solve(EigenMatrix &A, EigenVector& b, EigenVector &x)
{
INFO("------------------------------------------------------------------");
INFO("*** Eigen solver computation");
#ifdef USE_EIGEN_UNSUPPORTED
std::unique_ptr<Eigen::IterScaling<EigenMatrix::RawMatrixType>> scal;
if (_option.scaling)
{
INFO("-> scale");
scal.reset(new Eigen::IterScaling<EigenMatrix::RawMatrixType>());
scal->computeRef(A.getRawMatrix());
b.getRawVector() = scal->LeftScaling().cwiseProduct(b.getRawVector());
}
#endif
auto const success = _solver->solve(A.getRawMatrix(), b.getRawVector(),
x.getRawVector(), _option);
#ifdef USE_EIGEN_UNSUPPORTED
if (scal)
x.getRawVector() = scal->RightScaling().cwiseProduct(x.getRawVector());
#endif
INFO("------------------------------------------------------------------");
return success;
}
void EigenLisLinearSolver::solve(EigenVector &b_, EigenVector &x_)
{
auto &A = _A.getRawMatrix();
auto &b = b_.getRawVector();
auto &x = x_.getRawVector();
if (!A.isCompressed())
A.makeCompressed();
int nnz = A.nonZeros();
int* ptr = A.outerIndexPtr();
int* col = A.innerIndexPtr();
double* data = A.valuePtr();
LisMatrix lisA(_A.getNRows(), nnz, ptr, col, data);
LisVector lisb(b.rows(), b.data());
LisVector lisx(x.rows(), x.data());
LisLinearSolver lissol(lisA);
lissol.setOption(_option);
lissol.solve(lisb, lisx);
for (std::size_t i=0; i<lisx.size(); i++)
x[i] = lisx[i];
}
void setVector(EigenVector& v, MatrixVectorTraits<EigenVector>::Index const index,
double const value)
{
v.getRawVector()[index] = value;
}