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++);
}
/**
* @param A coefficient matrix
* @param A_QR Householder QR decomposition of coefficient matrix
* @param b right-hand side
* @param[out] x solution of the linear system
* @return whether all went well (false if errors occurred)
*/
bool solveInternal(const EigenMatrix& A, const ::Eigen::HouseholderQR<EigenMatrix>& A_QR,
base::DataVector& b, base::DataVector& x) {
const SGPP::float_t tolerance =
#if USE_DOUBLE_PRECISION
1e-12;
#else
1e-4;
#endif
// solve system
EigenVector bEigen = EigenVector::Map(b.getPointer(), b.getSize());
EigenVector xEigen = A_QR.solve(bEigen);
// check solution
if ((A * xEigen).isApprox(bEigen, tolerance)) {
x = base::DataVector(xEigen.data(), xEigen.size());
return true;
} else {
return false;
}
}
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;
}