wrapper(size_t n, params prm = params(),
const backend_params &bprm = backend_params(),
const InnerProduct &inner_product = InnerProduct()
)
: s(prm.get("type", runtime::solver::bicgstab)), handle(0)
{
if (!prm.erase("type")) AMGCL_PARAM_MISSING("type");
switch(s) {
#define AMGCL_RUNTIME_SOLVER(type) \
case type: \
handle = static_cast<void*>(new amgcl::solver::type<Backend, InnerProduct>(n, prm, bprm, inner_product)); \
break
AMGCL_RUNTIME_SOLVER(cg);
AMGCL_RUNTIME_SOLVER(bicgstab);
AMGCL_RUNTIME_SOLVER(bicgstabl);
AMGCL_RUNTIME_SOLVER(gmres);
AMGCL_RUNTIME_SOLVER(lgmres);
AMGCL_RUNTIME_SOLVER(fgmres);
AMGCL_RUNTIME_SOLVER(idrs);
#undef AMGCL_RUNTIME_SOLVER
default:
throw std::invalid_argument("Unsupported solver type");
}
}
preconditioner(
const Matrix &A,
params prm = params(),
const backend_params &bprm = backend_params())
: _class(prm.get("class", runtime::precond_class::amg)),
handle(0)
{
if (!prm.erase("class")) AMGCL_PARAM_MISSING("class");
switch(_class) {
case precond_class::amg:
{
typedef
runtime::amg<Backend>
Precond;
handle = static_cast<void*>(new Precond(A, prm, bprm));
}
break;
case precond_class::relaxation:
{
typedef
runtime::relaxation::as_preconditioner<Backend>
Precond;
handle = static_cast<void*>(new Precond(A, prm, bprm));
}
break;
case precond_class::dummy:
{
typedef
amgcl::preconditioner::dummy<Backend>
Precond;
handle = static_cast<void*>(new Precond(A, prm, bprm));
}
break;
case precond_class::nested:
{
typedef
make_solver<
preconditioner,
runtime::iterative_solver<Backend>
>
Precond;
handle = static_cast<void*>(new Precond(A, prm, bprm));
}
break;
default:
throw std::invalid_argument("Unsupported preconditioner class");
}
}
wrapper(const amgcl::mpi::distributed_matrix<Backend> &A,
params prm, const backend_params &bprm = backend_params())
: r(prm.get("type", runtime::relaxation::spai0)), handle(0)
{
if (!prm.erase("type")) AMGCL_PARAM_MISSING("type");
switch(r) {
#define AMGCL_RELAX_DISTR(type) \
case runtime::relaxation::type: \
handle = static_cast<void*>(new amgcl::mpi::relaxation::type<Backend>(A, prm, bprm)); \
break
#define AMGCL_RELAX_LOCAL_DISTR(type) \
case runtime::relaxation::type: \
handle = call_constructor<amgcl::relaxation::type>(A, prm, bprm); \
break;
#define AMGCL_RELAX_LOCAL_LOCAL(type) \
case runtime::relaxation::type: \
handle = call_constructor<amgcl::relaxation::type>(*A.local(), prm, bprm); \
break;
AMGCL_RELAX_DISTR(spai0);
AMGCL_RELAX_LOCAL_DISTR(chebyshev);
AMGCL_RELAX_LOCAL_LOCAL(damped_jacobi);
AMGCL_RELAX_LOCAL_LOCAL(ilu0);
AMGCL_RELAX_LOCAL_LOCAL(iluk);
AMGCL_RELAX_LOCAL_LOCAL(ilut);
AMGCL_RELAX_LOCAL_LOCAL(spai1);
AMGCL_RELAX_LOCAL_LOCAL(gauss_seidel);
#undef AMGCL_RELAX_LOCAL_LOCAL
#undef AMGCL_RELAX_LOCAL_DISTR
#undef AMGCL_RELAX_DISTR
default:
throw std::invalid_argument("Unsupported relaxation type");
}
}