The Incomplete Cholesky (IC) preconditioner solves the equation $LL^H*x = b$ for a given lower triangular matrix L and the right hand side b (can contain multiple right hand sides). More...

#include <ginkgo/core/preconditioner/ic.hpp>

Inheritance diagram for gko::preconditioner::Ic< ValueType, IndexType >:

[legend]

Collaboration diagram for gko::preconditioner::Ic< ValueType, IndexType >:

[legend]

Classes
class	Factory

struct	parameters_type

Public Types
using	value_type = ValueType

using	index_type = IndexType

using	transposed_type = Ic

Public Member Functions
const parameters_type &	get_parameters () const

std::shared_ptr< const LinOp >	get_l_solver () const
	Returns the solver which is used for the provided L matrix. More...

std::shared_ptr< const LinOp >	get_lh_solver () const
	Returns the solver which is used for the L^H matrix. More...

std::unique_ptr< LinOp >	transpose () const override
	Returns a LinOp representing the transpose of the Transposable object. More...

std::unique_ptr< LinOp >	conj_transpose () const override
	Returns a LinOp representing the conjugate transpose of the Transposable object. More...

Ic &	operator= (const Ic &other)
	Copy-assigns an IC preconditioner. More...

Ic &	operator= (Ic &&other)
	Move-assigns an IC preconditioner. More...

	Ic (const Ic &other)
	Copy-constructs an IC preconditioner. More...

	Ic (Ic &&other)
	Move-constructs an IC preconditioner. More...

Public Member Functions inherited from gko::LinOp
void	apply (ptr_param< const LinOp > b, ptr_param< LinOp > x) const
	Applies a linear operator to a vector (or a sequence of vectors). More...

void	apply (ptr_param< const LinOp > alpha, ptr_param< const LinOp > b, ptr_param< const LinOp > beta, ptr_param< LinOp > x) const
	Performs the operation x = alpha * op(b) + beta * x. More...

const dim< 2 > &	get_size () const noexcept
	Returns the size of the operator. More...

virtual bool	apply_uses_initial_guess () const
	Returns true if the linear operator uses the data given in x as an initial guess. More...

LinOp &	operator= (const LinOp &)=default
	Copy-assigns a LinOp. More...

LinOp &	operator= (LinOp &&other)
	Move-assigns a LinOp. More...

	LinOp (const LinOp &)=default
	Copy-constructs a LinOp. More...

	LinOp (LinOp &&other)
	Move-constructs a LinOp. More...

Public Member Functions inherited from gko::PolymorphicObject
PolymorphicObject &	operator= (const PolymorphicObject &)

std::shared_ptr< const Executor >	get_executor () const noexcept
	Returns the Executor of the object. More...

Public Member Functions inherited from gko::log::EnableLogging< PolymorphicObject >
void	add_logger (std::shared_ptr< const Logger > logger) override

void	remove_logger (const Logger *logger) override

void	remove_logger (ptr_param< const Logger > logger)

const std::vector< std::shared_ptr< const Logger > > &	get_loggers () const override

void	clear_loggers () override

Public Member Functions inherited from gko::log::Loggable
void	remove_logger (ptr_param< const Logger > logger)

Static Public Member Functions
static auto	build () -> decltype(Factory ::create())

static parameters_type	parse (const config::pnode &config, const config::registry &context, const config::type_descriptor &td_for_child=config::make_type_descriptor< value_type, index_type >())
	Create the parameters from the property_tree. More...

Detailed Description

template<typename ValueType = default_precision, typename IndexType = int32>
class gko::preconditioner::Ic< ValueType, IndexType >

The Incomplete Cholesky (IC) preconditioner solves the equation $LL^H*x = b$ for a given lower triangular matrix L and the right hand side b (can contain multiple right hand sides).

It allows setting the solver for L, defaulting to solver::LowerTrs, which is a direct triangular solvers. The solver for L^H is the conjugate-transposed solver for L, ensuring that the preconditioner is symmetric and positive-definite. For this L solver, a factory can be provided (using with_l_solver) to have more control over their behavior. In particular, it is possible to use an iterative method for solving the triangular systems.

An object of this class can be created with a matrix or a gko::Composition containing two matrices. If created with a matrix, it is factorized before creating the solver. If a gko::Composition (containing two matrices) is used, the first operand will be taken as the L matrix, the second will be considered the L^H matrix, which helps to avoid the otherwise necessary transposition of L inside the solver. ParIc can be directly used, since it orders the factors in the correct way.

Note: When providing a gko::Composition, the first matrix must be the lower matrix ( ), and the second matrix must be its conjugate-transpose ( ). If they are swapped, solving might crash or return the wrong result.; Do not use symmetric solvers (like CG) for the L solver since both matrices (L and L^H) are, by design, not symmetric.; This class is not thread safe (even a const object is not) because it uses an internal cache to accelerate multiple (sequential) applies. Using it in parallel can lead to segmentation faults, wrong results and other unwanted behavior.; The default template during parse is <ValueType, IndexType> not <LowerTrs, IndexType>. Only the variants with ValueType are supported in parse.

Template Parameters

ValueType	the value type used for the L matrix.
IndexType	type of the indices when ParIc is used to generate the L and L^H factors. Irrelevant otherwise.

Constructor & Destructor Documentation

◆ Ic() [1/2]

template<typename ValueType = default_precision, typename IndexType = int32>

gko::preconditioner::Ic< ValueType, IndexType >::Ic ( const Ic< ValueType, IndexType > & other )

Copy-constructs an IC preconditioner.

Inherits the executor, shallow-copies the solvers and parameters.

◆ Ic() [2/2]

template<typename ValueType = default_precision, typename IndexType = int32>

gko::preconditioner::Ic< ValueType, IndexType >::Ic ( Ic< ValueType, IndexType > && other )

Move-constructs an IC preconditioner.

Inherits the executor, moves the solvers and parameters. The moved-from object is empty (0x0 with nullptr solvers and default parameters)

Member Function Documentation

◆ conj_transpose()

template<typename ValueType = default_precision, typename IndexType = int32>

std::unique_ptr<LinOp> gko::preconditioner::Ic< ValueType, IndexType >::conj_transpose ( ) const

overridevirtual

Returns a LinOp representing the conjugate transpose of the Transposable object.

Returns: a pointer to the new conjugate transposed object

Implements gko::Transposable.

◆ get_l_solver()

template<typename ValueType = default_precision, typename IndexType = int32>

std::shared_ptr<const LinOp> gko::preconditioner::Ic< ValueType, IndexType >::get_l_solver ( ) const

inline

Returns the solver which is used for the provided L matrix.

Returns: the solver which is used for the provided L matrix

◆ get_lh_solver()

template<typename ValueType = default_precision, typename IndexType = int32>

std::shared_ptr<const LinOp> gko::preconditioner::Ic< ValueType, IndexType >::get_lh_solver ( ) const

inline

Returns the solver which is used for the L^H matrix.

Returns: the solver which is used for the L^H matrix

◆ operator=() [1/2]

template<typename ValueType = default_precision, typename IndexType = int32>

Ic& gko::preconditioner::Ic< ValueType, IndexType >::operator= ( const Ic< ValueType, IndexType > & other )

Copy-assigns an IC preconditioner.

Preserves the executor, shallow-copies the solvers and parameters. Creates a clone of the solvers if they are on the wrong executor.

◆ operator=() [2/2]

template<typename ValueType = default_precision, typename IndexType = int32>

Ic& gko::preconditioner::Ic< ValueType, IndexType >::operator= ( Ic< ValueType, IndexType > && other )

Move-assigns an IC preconditioner.

Preserves the executor, moves the solvers and parameters. Creates a clone of the solvers if they are on the wrong executor. The moved-from object is empty (0x0 with nullptr solvers and default parameters)

◆ parse()

template<typename ValueType = default_precision, typename IndexType = int32>

static parameters_type gko::preconditioner::Ic< ValueType, IndexType >::parse	(	const config::pnode &	config,
		const config::registry &	context,
		const config::type_descriptor &	td_for_child = `config::make_type_descriptor< value_type, index_type >()`
	)

static

Create the parameters from the property_tree.

Because this is directly tied to the specific type, the value/index type settings within config are ignored and type_descriptor is only used for children configs.

Parameters

config	the property tree for setting
context	the registry
td_for_child	the type descriptor for children configs. The default uses the value/index type of this class. When l_solver_type uses LinOp not concrete type, it will use the default_precision in ginkgo.

Returns: parameters

Note: only support the following when using <ValueType, IndexType> not <LSolverType, IndexType> variants

◆ transpose()

template<typename ValueType = default_precision, typename IndexType = int32>

std::unique_ptr<LinOp> gko::preconditioner::Ic< ValueType, IndexType >::transpose ( ) const

overridevirtual

Returns a LinOp representing the transpose of the Transposable object.

Returns: a pointer to the new transposed object

Implements gko::Transposable.

The documentation for this class was generated from the following file:

ginkgo/core/preconditioner/ic.hpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Detailed Description

template<typename ValueType = default_precision, typename IndexType = int32> class gko::preconditioner::Ic< ValueType, IndexType >

Constructor & Destructor Documentation

◆ Ic() [1/2]

◆ Ic() [2/2]

Member Function Documentation

◆ conj_transpose()

◆ get_l_solver()

◆ get_lh_solver()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ parse()

◆ transpose()

template<typename ValueType = default_precision, typename IndexType = int32>
class gko::preconditioner::Ic< ValueType, IndexType >