Feel++  0.91.4
Protected Attributes | List of all members
Feel::Backend< T > Class Template Referenceabstract

base class for all linear algebra backends More...

#include <backend.hpp>

Inheritance diagram for Feel::Backend< T >:
Feel::BackendGmm< T >

Public Types

Typedefs
typedef T value_type
 
typedef type_traits< T >::real_type real_type
 
typedef Vector< value_type > vector_type
 
typedef boost::shared_ptr
< vector_type
vector_ptrtype
 
typedef MatrixSparse< value_type > sparse_matrix_type
 
typedef boost::shared_ptr
< sparse_matrix_type
sparse_matrix_ptrtype
 
typedef
sparse_matrix_type::graph_type 
graph_type
 
typedef
sparse_matrix_type::graph_ptrtype 
graph_ptrtype
 
typedef Backend< value_type > backend_type
 
typedef boost::shared_ptr
< backend_type
backend_ptrtype
 
typedef SolverNonLinear
< value_type > 
solvernonlinear_type
 
typedef boost::shared_ptr
< solvernonlinear_type
solvernonlinear_ptrtype
 
typedef boost::tuple< bool,
size_type, value_type > 
solve_return_type
 
typedef boost::tuple< bool,
size_type, value_type > 
nl_solve_return_type
 

Public Member Functions

Accessors
std::string kspType () const
 
std::string pcType () const
 
bool hasConstantNullSpace () const
 
std::string fieldsplitType () const
 
PreconditionerType pcEnumType () const
 
SolverType kspEnumType () const
 
FieldSplitType fieldSplitEnumType () const
 
std::string pcFactorMatSolverPackageType () const
 
MatSolverPackageType matSolverPackageEnumType () const
 
MatrixStructure precMatrixStructure () const
 
value_type rTolerance () const
 
value_type dTolerance () const
 
value_type aTolerance () const
 
size_type maxIterations () const
 
bool converged () const
 
size_type nIterations () const
 
bool transpose () const
 
mpi::communicator const & comm () const
 
Mutators
 BOOST_PARAMETER_MEMBER_FUNCTION ((void), setTolerances, tag,(required(rtolerance,(double)))(optional(maxit,(size_type), 1000)(atolerance,(double), 1e-50)(dtolerance,(double), 1e5)))
 
 BOOST_PARAMETER_MEMBER_FUNCTION ((void), setSolverType, tag,(required(ksp,(std::string)))(optional(pc,(std::string),"lu")(constant_null_space,(bool), false)(pcfactormatsolverpackage,(std::string),"petsc")))
 
void setPrecMatrixStructure (MatrixStructure mstruct)
 
solvernonlinear_ptrtype nlSolver ()
 
void setTranspose (bool transpose)
 
Methods
virtual real_type dot (vector_type const &x, vector_type const &y) const
 
real_type dot (vector_ptrtype const &x, vector_ptrtype const &y) const
 
virtual void prod (sparse_matrix_type const &A, vector_type const &x, vector_type &y) const =0
 
void prod (sparse_matrix_ptrtype const &A, vector_ptrtype const &x, vector_ptrtype &y) const
 
 BOOST_PARAMETER_MEMBER_FUNCTION ((solve_return_type), solve, tag,(required(matrix,(sparse_matrix_ptrtype))(in_out(solution),*(mpl::or_< boost::is_convertible< mpl::_, vector_type & >, boost::is_convertible< mpl::_, vector_ptrtype > >))(rhs,(vector_ptrtype)))(optional(prec,(preconditioner_ptrtype), preconditioner(_matrix=matrix, _pc=LU_PRECOND, _backend=BACKEND_PETSC))(maxit,(size_type), M_maxit)(rtolerance,(double), M_rtolerance)(atolerance,(double), M_atolerance)(dtolerance,(double), M_dtolerance)(reuse_prec,(bool), M_reuse_prec)(transpose,(bool), false)(constant_null_space,(bool), false)(pc,(std::string), M_pc)(ksp,(std::string), M_ksp)(pcfactormatsolverpackage,(std::string), M_pcFactorMatSolverPackage)))
 
virtual solve_return_type solve (sparse_matrix_ptrtype const &A, sparse_matrix_ptrtype const &P, vector_ptrtype &x, vector_ptrtype const &b)=0
 
solve_return_type solve (sparse_matrix_ptrtype const &A, sparse_matrix_ptrtype const &P, vector_ptrtype &x, vector_ptrtype const &b, bool reuse_prec)
 
 BOOST_PARAMETER_MEMBER_FUNCTION ((nl_solve_return_type), nlSolve, tag,(required(in_out(solution),*(mpl::or_< boost::is_convertible< mpl::_, vector_type & >, boost::is_convertible< mpl::_, vector_ptrtype > >)))(optional(jacobian,(sparse_matrix_ptrtype), sparse_matrix_ptrtype())(residual,(vector_ptrtype), vector_ptrtype())(prec,(preconditioner_ptrtype), preconditioner(_pc=LU_PRECOND, _backend=BACKEND_PETSC))(maxit,(size_type), M_maxit)(rtolerance,(double), M_rtolerance)(atolerance,(double), M_atolerance)(dtolerance,(double), M_dtolerance)(reuse_prec,(bool), M_reuse_prec)(reuse_jac,(bool), M_reuse_jac)(transpose,(bool), false)(pc,(std::string), M_pc)(ksp,(std::string), M_ksp)(pcfactormatsolverpackage,(std::string), M_pcFactorMatSolverPackage)))
 
virtual nl_solve_return_type nlSolve (sparse_matrix_ptrtype &A, vector_ptrtype &x, vector_ptrtype &b, const double, const int)
 
virtual nl_solve_return_type nlSolve (sparse_matrix_ptrtype &A, vector_ptrtype &x, vector_ptrtype &b, const double, const int, bool reusePC, bool reuseJAC)
 
void attachPreconditioner (preconditioner_ptrtype preconditioner)
 

Protected Attributes

preconditioner_ptrtype M_preconditioner
 

Constructors, destructor

 Backend ()
 
 Backend (po::variables_map const &vm, std::string const &prefix="")
 
 Backend (Backend const &)
 
virtual ~Backend ()
 
virtual sparse_matrix_ptrtype newMatrix (const size_type m, const size_type n, const size_type m_l, const size_type n_l, const size_type nnz=30, const size_type noz=10, size_type prop=NON_HERMITIAN)=0
 
virtual sparse_matrix_ptrtype newMatrix (const size_type m, const size_type n, const size_type m_l, const size_type n_l, graph_ptrtype const &graph, size_type matrix_properties=NON_HERMITIAN)=0
 
sparse_matrix_ptrtype newMatrix (const size_type m, const size_type n, const size_type m_l, const size_type n_l, graph_ptrtype const &graph, std::vector< std::vector< int > > indexSplit, size_type matrix_properties=NON_HERMITIAN)
 
virtual sparse_matrix_ptrtype newMatrix (DataMap const &dm1, DataMap const &dm2, size_type prop=NON_HERMITIAN, bool init=true)=0
 
virtual sparse_matrix_ptrtype newZeroMatrix (const size_type m, const size_type n, const size_type m_l, const size_type n_l)=0
 
virtual sparse_matrix_ptrtype newZeroMatrix (DataMap const &dm1, DataMap const &dm2)=0
 
 BOOST_PARAMETER_MEMBER_FUNCTION ((sparse_matrix_ptrtype), newMatrix, tag,(required(trial,*(boost::is_convertible< mpl::_, boost::shared_ptr< FunctionSpaceBase > >))(test,*(boost::is_convertible< mpl::_, boost::shared_ptr< FunctionSpaceBase > >)))(optional(pattern,(size_type), Pattern::COUPLED)(properties,(size_type), NON_HERMITIAN)(buildGraphWithTranspose,(bool), false)(pattern_block,*,(vf::Blocks< 1, 1, size_type >(size_type(Pattern::HAS_NO_BLOCK_PATTERN))))(diag_is_nonzero,*(boost::is_integral< mpl::_ >), true)(verbose,(int), 0)))
 
template<typename DomainSpace , typename ImageSpace >
sparse_matrix_ptrtype newMatrix (DomainSpace const &dm, ImageSpace const &im, sparse_matrix_ptrtype const &M, size_type prop=NON_HERMITIAN)
 
template<int NR, int NC, typename BlockType = sparse_matrix_ptrtype>
sparse_matrix_ptrtype newBlockMatrixImpl (vf::Blocks< NR, NC, BlockType > const &b, bool copy_values=true, bool diag_is_nonzero=true)
 
 BOOST_PARAMETER_MEMBER_FUNCTION ((sparse_matrix_ptrtype), newBlockMatrix, tag,(required(block,*))(optional(copy_values,*(boost::is_integral< mpl::_ >), true)(diag_is_nonzero,*(boost::is_integral< mpl::_ >), true)))
 
template<int NR, typename BlockType = vector_ptrtype>
vector_ptrtype newBlockVectorImpl (vf::Blocks< NR, 1, BlockType > const &b, bool copy_values=true)
 
 BOOST_PARAMETER_MEMBER_FUNCTION ((vector_ptrtype), newBlockVector, tag,(required(block,*))(optional(copy_values,*(boost::is_integral< mpl::_ >), true)))
 
 BOOST_PARAMETER_MEMBER_FUNCTION ((sparse_matrix_ptrtype), newZeroMatrix, tag,(required(test,*)(trial,*)))
 
virtual vector_ptrtype newVector (DataMap const &dm)=0
 
virtual vector_ptrtype newVector (const size_type n, const size_type n_local)=0
 
template<typename DomainSpace >
vector_ptrtype newVector (DomainSpace const &dm)
 
static backend_ptrtype build (BackendType=BACKEND_GMM)
 
static backend_ptrtype build (po::variables_map const &vm, std::string const &prefix="")
 

Detailed Description

template<typename T>
class Feel::Backend< T >

base class for all linear algebra backends

Author
Christophe Prud'homme
See Also

Member Function Documentation

template<typename T>
value_type Feel::Backend< T >::aTolerance ( ) const
inline
Returns
the absolute tolerance
template<typename T>
void Feel::Backend< T >::attachPreconditioner ( preconditioner_ptrtype  preconditioner)
inline

Attaches a Preconditioner object to be used by the solver

Referenced by Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION().

template<typename T>
Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION ( (sparse_matrix_ptrtype)  ,
newMatrix  ,
tag  ,
(required(trial,*(boost::is_convertible< mpl::_, boost::shared_ptr< FunctionSpaceBase > >))(test,*(boost::is_convertible< mpl::_, boost::shared_ptr< FunctionSpaceBase > >)))(optional(pattern,(size_type), Pattern::COUPLED)(properties,(size_type), NON_HERMITIAN)(buildGraphWithTranspose,(bool), false)(pattern_block,*,(vf::Blocks< 1, 1, size_type >(size_type(Pattern::HAS_NO_BLOCK_PATTERN))))(diag_is_nonzero,*(boost::is_integral< mpl::_ >), true)(verbose,(int), 0))   
)
inline

helper function

References Feel::Backend< T >::newMatrix().

template<typename T>
Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION ( (sparse_matrix_ptrtype)  ,
newBlockMatrix  ,
tag  ,
(required(block,*))(optional(copy_values,*(boost::is_integral< mpl::_ >), true)(diag_is_nonzero,*(boost::is_integral< mpl::_ >), true))   
)
inline

instantiate a new block matrix sparse

References Feel::Backend< T >::newBlockMatrixImpl().

template<typename T>
Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION ( (vector_ptrtype)  ,
newBlockVector  ,
tag  ,
(required(block,*))(optional(copy_values,*(boost::is_integral< mpl::_ >), true))   
)
inline

instantiate a new block matrix sparse

References Feel::Backend< T >::newBlockVectorImpl().

template<typename T>
Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION ( (sparse_matrix_ptrtype)  ,
newZeroMatrix  ,
tag  ,
(required(test,*)(trial,*))   
)
inline

instantiate a new zero matrix

References Feel::Backend< T >::newZeroMatrix().

template<typename T>
Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION ( (void)  ,
setTolerances  ,
tag  ,
(required(rtolerance,(double)))(optional(maxit,(size_type), 1000)(atolerance,(double),1e-50)(dtolerance,(double),1e5))   
)
inline

set tolerances: relative tolerance rtol, divergence tolerance dtol and absolute tolerance atol

template<typename T>
Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION ( (void)  ,
setSolverType  ,
tag  ,
(required(ksp,(std::string)))(optional(pc,(std::string),"lu")(constant_null_space,(bool), false)(pcfactormatsolverpackage,(std::string),"petsc"))   
)
inline

set solver: krylov subspace method and preconditioners

template<typename T>
Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION ( (solve_return_type)  ,
solve  ,
tag  ,
(required(matrix,(sparse_matrix_ptrtype))(in_out(solution),*(mpl::or_< boost::is_convertible< mpl::_, vector_type & >,boost::is_convertible< mpl::_, vector_ptrtype > >))(rhs,(vector_ptrtype)))(optional(prec,(preconditioner_ptrtype), preconditioner(_matrix=matrix, _pc=LU_PRECOND, _backend=BACKEND_PETSC))(maxit,(size_type), M_maxit)(rtolerance,(double), M_rtolerance)(atolerance,(double), M_atolerance)(dtolerance,(double), M_dtolerance)(reuse_prec,(bool), M_reuse_prec)(transpose,(bool), false)(constant_null_space,(bool), false)(pc,(std::string), M_pc)(ksp,(std::string), M_ksp)(pcfactormatsolverpackage,(std::string), M_pcFactorMatSolverPackage))   
)
inline

solve for $P A x = P b$ where $P$ is an approximation of the inverse of $A$. this interface uses the boost.parameter library to ease the function usage

Parameters
Amatrix to inverse
rhsright hand side vector
solutionsolution of the system
Ppreconditioner
maxitmaximum number of iterations
tolerancetolerance on the residual
reuse_precif true use adaptive preconditioning strategy
transposeif true solve the transpose problem
Warning
some parameter may not be meaningful for all backends

References Feel::Backend< T >::attachPreconditioner(), Feel::Backend< T >::newVector(), Feel::Backend< T >::setPrecMatrixStructure(), and Feel::Backend< T >::solve().

template<typename T>
Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION ( (nl_solve_return_type)  ,
nlSolve  ,
tag  ,
(required(in_out(solution),*(mpl::or_< boost::is_convertible< mpl::_, vector_type & >,boost::is_convertible< mpl::_, vector_ptrtype > >)))(optional(jacobian,(sparse_matrix_ptrtype), sparse_matrix_ptrtype())(residual,(vector_ptrtype), vector_ptrtype())(prec,(preconditioner_ptrtype), preconditioner(_pc=LU_PRECOND, _backend=BACKEND_PETSC))(maxit,(size_type), M_maxit)(rtolerance,(double), M_rtolerance)(atolerance,(double), M_atolerance)(dtolerance,(double), M_dtolerance)(reuse_prec,(bool), M_reuse_prec)(reuse_jac,(bool), M_reuse_jac)(transpose,(bool), false)(pc,(std::string), M_pc)(ksp,(std::string), M_ksp)(pcfactormatsolverpackage,(std::string), M_pcFactorMatSolverPackage))   
)
inline
template<typename T >
Backend< T >::backend_ptrtype Feel::Backend< T >::build ( BackendType  bt = BACKEND_GMM)
static

Builds a Backend, if Petsc is available, use Petsc by default, otherwise use GMM which is distributed with feel

template<typename T >
Backend< T >::backend_ptrtype Feel::Backend< T >::build ( po::variables_map const &  vm,
std::string const &  prefix = "" 
)
static

Builds a Backend

template<typename T>
mpi::communicator const& Feel::Backend< T >::comm ( ) const
inline
Returns
the communicator
template<typename T >
Backend< T >::real_type Feel::Backend< T >::dot ( vector_type const &  x,
vector_type const &  y 
) const
virtual

clean up

Returns
$ r = x^T * y $

References Feel::Vector< T >::localSize().

Referenced by Feel::Backend< T >::dot().

template<typename T>
real_type Feel::Backend< T >::dot ( vector_ptrtype const &  x,
vector_ptrtype const &  y 
) const
inline
Returns
$ r = x^T * y $

References Feel::Backend< T >::dot().

template<typename T>
value_type Feel::Backend< T >::dTolerance ( ) const
inline
Returns
the divergence tolerance
template<typename T >
FieldSplitType Feel::Backend< T >::fieldSplitEnumType ( ) const
Returns
enum fieldsplit type from options
template<typename T>
std::string Feel::Backend< T >::fieldsplitType ( ) const
inline
Returns
the type of fieldsplitType
template<typename T>
bool Feel::Backend< T >::hasConstantNullSpace ( ) const
inline

return true if the null space is the constant values, false otherwise

template<typename T >
SolverType Feel::Backend< T >::kspEnumType ( ) const
Returns
enum solver type from options
template<typename T>
std::string Feel::Backend< T >::kspType ( ) const
inline
Returns
the type of linear solver
template<typename T >
MatSolverPackageType Feel::Backend< T >::matSolverPackageEnumType ( ) const
Returns
enum MatSolverPackage type from options
template<typename T>
size_type Feel::Backend< T >::maxIterations ( ) const
inline
Returns
the maximum number of iterations
template<typename T>
template<int NR, int NC, typename BlockType = sparse_matrix_ptrtype>
sparse_matrix_ptrtype Feel::Backend< T >::newBlockMatrixImpl ( vf::Blocks< NR, NC, BlockType > const &  b,
bool  copy_values = true,
bool  diag_is_nonzero = true 
)
inline

instantiate a new block matrix sparse

Referenced by Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION().

template<typename T>
template<int NR, typename BlockType = vector_ptrtype>
vector_ptrtype Feel::Backend< T >::newBlockVectorImpl ( vf::Blocks< NR, 1, BlockType > const &  b,
bool  copy_values = true 
)
inline

instantiate a new block matrix sparse

Referenced by Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION().

template<typename T>
virtual sparse_matrix_ptrtype Feel::Backend< T >::newMatrix ( const size_type  m,
const size_type  n,
const size_type  m_l,
const size_type  n_l,
const size_type  nnz = 30,
const size_type  noz = 10,
size_type  prop = NON_HERMITIAN 
)
pure virtual

instantiate a new sparse vector

Implemented in Feel::BackendGmm< T >.

Referenced by Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION(), and Feel::Backend< T >::newMatrix().

template<typename T>
virtual sparse_matrix_ptrtype Feel::Backend< T >::newMatrix ( const size_type  m,
const size_type  n,
const size_type  m_l,
const size_type  n_l,
graph_ptrtype const &  graph,
size_type  matrix_properties = NON_HERMITIAN 
)
pure virtual

instantiate a new sparse vector

Implemented in Feel::BackendGmm< T >.

template<typename T>
sparse_matrix_ptrtype Feel::Backend< T >::newMatrix ( const size_type  m,
const size_type  n,
const size_type  m_l,
const size_type  n_l,
graph_ptrtype const &  graph,
std::vector< std::vector< int > >  indexSplit,
size_type  matrix_properties = NON_HERMITIAN 
)
inline

instantiate a new sparse vector

References Feel::Backend< T >::newMatrix().

template<typename T>
virtual sparse_matrix_ptrtype Feel::Backend< T >::newMatrix ( DataMap const &  dm1,
DataMap const &  dm2,
size_type  prop = NON_HERMITIAN,
bool  init = true 
)
pure virtual

instantiate a new sparse vector

Implemented in Feel::BackendGmm< T >.

template<typename T>
virtual vector_ptrtype Feel::Backend< T >::newVector ( DataMap const &  dm)
pure virtual
template<typename T>
virtual vector_ptrtype Feel::Backend< T >::newVector ( const size_type  n,
const size_type  n_local 
)
pure virtual

instantiate a new vector

Implemented in Feel::BackendGmm< T >.

template<typename T>
template<typename DomainSpace >
vector_ptrtype Feel::Backend< T >::newVector ( DomainSpace const &  dm)
inline

helper function

References Feel::Backend< T >::newVector().

template<typename T>
virtual sparse_matrix_ptrtype Feel::Backend< T >::newZeroMatrix ( const size_type  m,
const size_type  n,
const size_type  m_l,
const size_type  n_l 
)
pure virtual

instantiate a new sparse vector

Implemented in Feel::BackendGmm< T >.

Referenced by Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION().

template<typename T >
Backend< T >::nl_solve_return_type Feel::Backend< T >::nlSolve ( sparse_matrix_ptrtype &  A,
vector_ptrtype &  x,
vector_ptrtype &  b,
const double  tol,
const int  its 
)
virtual

solve for the nonlinear problem $F( u ) = 0$

Referenced by Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION().

template<typename T >
Backend< T >::nl_solve_return_type Feel::Backend< T >::nlSolve ( sparse_matrix_ptrtype &  A,
vector_ptrtype &  x,
vector_ptrtype &  b,
const double  tol,
const int  its,
bool  reusePC,
bool  reuseJAC 
)
virtual

solve for the nonlinear problem $F( u ) = 0$ with an adaptive strategy to reuse the preconditioner

template<typename T>
solvernonlinear_ptrtype Feel::Backend< T >::nlSolver ( )
inline
Returns
the non linear solver

Referenced by Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION().

template<typename T >
PreconditionerType Feel::Backend< T >::pcEnumType ( ) const
Returns
enum pc type from options
template<typename T>
std::string Feel::Backend< T >::pcFactorMatSolverPackageType ( ) const
inline
Returns
the type of pcFactorMatSolverPackageType
template<typename T>
std::string Feel::Backend< T >::pcType ( ) const
inline
Returns
the type of preconditioner
template<typename T>
MatrixStructure Feel::Backend< T >::precMatrixStructure ( ) const
inline
Returns
the type of preconditioner associated to the matrix
template<typename T>
virtual void Feel::Backend< T >::prod ( sparse_matrix_type const &  A,
vector_type const &  x,
vector_type y 
) const
pure virtual
Returns
$ y = A * x $

Implemented in Feel::BackendGmm< T >.

Referenced by Feel::Backend< T >::prod().

template<typename T>
void Feel::Backend< T >::prod ( sparse_matrix_ptrtype const &  A,
vector_ptrtype const &  x,
vector_ptrtype &  y 
) const
inline
Returns
$ y = A * x $

References Feel::Backend< T >::prod().

template<typename T>
value_type Feel::Backend< T >::rTolerance ( ) const
inline
Returns
the relative tolerance
template<typename T>
void Feel::Backend< T >::setPrecMatrixStructure ( MatrixStructure  mstruct)
inline

set the type of preconditioner associated to the matrix

Referenced by Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION().

template<typename T>
virtual solve_return_type Feel::Backend< T >::solve ( sparse_matrix_ptrtype const &  A,
sparse_matrix_ptrtype const &  P,
vector_ptrtype &  x,
vector_ptrtype const &  b 
)
pure virtual

solve for $P A x = P b$ where $P$ is an approximation of the inverse of $A$.

Parameters
Amatrix to inverse
rhsright hand side vector
solutionsolution of the system
Ppreconditioner
maxitmaximum number of iterations
tolerancetolerance on the residual
transposeif true solve the transpose problem
Warning
some parameter may not be meaningful for all backends

Implemented in Feel::BackendGmm< T >.

Referenced by Feel::Backend< T >::BOOST_PARAMETER_MEMBER_FUNCTION().

template<typename T >
Backend< T >::solve_return_type Feel::Backend< T >::solve ( sparse_matrix_ptrtype const &  A,
sparse_matrix_ptrtype const &  P,
vector_ptrtype &  x,
vector_ptrtype const &  b,
bool  reuse_prec 
)

solve for $P A x = P b$ where $P$ is an approximation of the inverse of $A$ using an adaptive preconditioning strategy.

Parameters
Amatrix to inverse
rhsright hand side vector
solutionsolution of the system
Ppreconditioner
maxitmaximum number of iterations
tolerancetolerance on the residual
transposeif true solve the transpose problem
Warning
some parameter may not be meaningful for all backends