Ginkgo: gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType > Class Template Reference

| Ginkgo Generated from branch based on main. Ginkgo version 1.11.0 A numerical linear algebra library targeting many-core architectures

Loading...
Searching...
No Matches
gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType > Class Template Reference
Linear Operators » Preconditioners | Linear Operators

The Incomplete Cholesky (IC) preconditioner solves the equation 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< LSolverTypeOrValueType, IndexType >:
[legend]
Collaboration diagram for gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >:
[legend]

## Classes
struct | parameters_type
class | Factory

## Public Types
using | l_solver_type
using | value_type = gko::detail::get_value_type<LSolverTypeOrValueType>
using | lh_solver_type = gko::detail::transposed_type<l_solver_type>
using | index_type = IndexType
using | transposed_type = Ic<LSolverTypeOrValueType, IndexType>
Public Types inherited from gko::EnablePolymorphicAssignment< Ic< solver::LowerTrs<>, int32 > >
using | result_type

## Public Member Functions
const parameters_type & | get_parameters () const
std::shared_ptr< const l_solver_type > | get_l_solver () const
| Returns the solver which is used for the provided L matrix.
std::shared_ptr< const lh_solver_type > | get_lh_solver () const
| Returns the solver which is used for the L^H matrix.
std::unique_ptr< LinOp > | transpose () const override
| Returns a LinOp representing the transpose of the Transposable object.
std::unique_ptr< LinOp > | conj_transpose () const override
| Returns a LinOp representing the conjugate transpose of the Transposable object.
Ic & | operator= (const Ic &other)
| Copy-assigns an IC preconditioner.
Ic & | operator= (Ic &&other)
| Move-assigns an IC preconditioner.
| Ic (const Ic &other)
| Copy-constructs an IC preconditioner.
| Ic (Ic &&other)
| Move-constructs an IC preconditioner.
Public Member Functions inherited from gko::EnableLinOp< Ic< solver::LowerTrs<>, int32 > >
const Ic< solver::LowerTrs<>, int32 > * | apply (ptr_param< const LinOp > b, ptr_param< LinOp > x) const
Public Member Functions inherited from gko::EnablePolymorphicAssignment< Ic< solver::LowerTrs<>, int32 > >
void | convert_to (result_type *result) const override
void | move_to (result_type *result) override

## 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.

## Friends
class | EnableLinOp< Ic >
class | EnablePolymorphicObject< Ic, LinOp >

## Detailed Description

template<typename LSolverTypeOrValueType = solver::LowerTrs<>, typename IndexType = int32>
class gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >

The Incomplete Cholesky (IC) preconditioner solves the equation for a given lower triangular matrix L and the right hand side b (can contain multiple right hand sides).

It allows to set both 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. The default parameters for an iterative triangluar solver are:

- reduction factor = 1e-4
- max iteration = <number of rows of the matrix given to the solver> Solvers without such criteria can also be used, in which case none are set.

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

  LSolverTypeOrValueType | type of the solver or the value type used for the L matrix. Defaults to solver::LowerTrs
  IndexType | type of the indices when ParIc is used to generate the L and L^H factors. Irrelevant otherwise.

## Member Typedef Documentation

## ◆ l_solver_type

template<typename LSolverTypeOrValueType = solver::LowerTrs<>, typename IndexType = int32>

using gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >::l_solver_type

Initial value:
std::conditional_t<gko::detail::is_ginkgo_linop<LSolverTypeOrValueType>,
LSolverTypeOrValueType, LinOp>
gko::LinOp
Definition lin_op.hpp:117

## Constructor & Destructor Documentation

## ◆ Ic() [1/2]

template<typename LSolverTypeOrValueType = solver::LowerTrs<>, typename IndexType = int32>

gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >::Ic | ( | const Ic< LSolverTypeOrValueType, IndexType > & | other | ) |
| inline

Copy-constructs an IC preconditioner.

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

## ◆ Ic() [2/2]

template<typename LSolverTypeOrValueType = solver::LowerTrs<>, typename IndexType = int32>

gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >::Ic | ( | Ic< LSolverTypeOrValueType, IndexType > && | other | ) |
| inline

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 LSolverTypeOrValueType = solver::LowerTrs<>, typename IndexType = int32>

std::unique_ptr< LinOp > gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >::conj_transpose | ( |  | ) | const
| inlineoverridevirtual

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

Returns
  a pointer to the new conjugate transposed object

Implements gko::Transposable.

Referenced by conj_transpose().

## ◆ get_l_solver()

template<typename LSolverTypeOrValueType = solver::LowerTrs<>, typename IndexType = int32>

std::shared_ptr< const l_solver_type > gko::preconditioner::Ic< LSolverTypeOrValueType, 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

Referenced by conj_transpose(), and transpose().

## ◆ get_lh_solver()

template<typename LSolverTypeOrValueType = solver::LowerTrs<>, typename IndexType = int32>

std::shared_ptr< const lh_solver_type > gko::preconditioner::Ic< LSolverTypeOrValueType, 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

Referenced by conj_transpose(), and transpose().

## ◆ operator=() [1/2]

template<typename LSolverTypeOrValueType = solver::LowerTrs<>, typename IndexType = int32>

Ic & gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >::operator= | ( | const Ic< LSolverTypeOrValueType, IndexType > & | other | ) |
| inline

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 LSolverTypeOrValueType = solver::LowerTrs<>, typename IndexType = int32>

Ic & gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >::operator= | ( | Ic< LSolverTypeOrValueType, IndexType > && | other | ) |
| inline

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 LSolverTypeOrValueType = solver::LowerTrs<>, typename IndexType = int32>

parameters_type gko::preconditioner::Ic< LSolverTypeOrValueType, 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>() )
| inlinestatic

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 LSolverTypeOrValueType = solver::LowerTrs<>, typename IndexType = int32>

std::unique_ptr< LinOp > gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >::transpose | ( |  | ) | const
| inlineoverridevirtual

Returns a LinOp representing the transpose of the Transposable object.

Returns
  a pointer to the new transposed object

Implements gko::Transposable.

Referenced by transpose().

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

- ginkgo/core/preconditioner/ic.hpp