Ginkgo Generated from branch based on main. Ginkgo version 1.10.0
A numerical linear algebra library targeting many-core architectures
Loading...
Searching...
No Matches
gko::factorization::Ic< ValueType, IndexType >::parameters_type Struct Reference
Inheritance diagram for gko::factorization::Ic< ValueType, IndexType >::parameters_type:
[legend]
Collaboration diagram for gko::factorization::Ic< ValueType, IndexType >::parameters_type:
[legend]

Public Member Functions

template<typename... Args>
auto with_l_strategy (Args &&... _value) -> std::decay_t< decltype(*(this->self()))> &
template<typename... Args>
auto with_skip_sorting (Args &&... _value) -> std::decay_t< decltype(*(this->self()))> &
template<typename... Args>
auto with_both_factors (Args &&... _value) -> std::decay_t< decltype(*(this->self()))> &
template<typename... Args>
auto with_algorithm (Args &&... _value) -> std::decay_t< decltype(*(this->self()))> &
Public Member Functions inherited from gko::enable_parameters_type< parameters_type, Factory >
parameters_type & with_loggers (Args &&... _value)
 Provides the loggers to be added to the factory and its generated objects in a fluent interface.
std::unique_ptr< Factory > on (std::shared_ptr< const Executor > exec) const
 Creates a new factory on the specified executor.

Public Attributes

std::shared_ptr< typename matrix_type::strategy_type > l_strategy {nullptr}
 Strategy which will be used by the L matrix.
bool skip_sorting {false}
 The system_matrix, which will be given to this factory, must be sorted (first by row, then by column) in order for the algorithm to work.
bool both_factors {true}
 true will generate both L and L^H, false will only generate the L factor, resulting in a Composition of only a single LinOp.
incomplete_algorithm algorithm {incomplete_algorithm::sparselib}
 Select the implementation which is supposed to be used for the incomplete factorization.

Additional Inherited Members

Public Types inherited from gko::enable_parameters_type< parameters_type, Factory >
using factory

Member Data Documentation

◆ algorithm

template<typename ValueType = gko::default_precision, typename IndexType = gko::int32>
incomplete_algorithm gko::factorization::Ic< ValueType, IndexType >::parameters_type::algorithm {incomplete_algorithm::sparselib}

Select the implementation which is supposed to be used for the incomplete factorization.

This only matters for the CUDA/HIP/REFERENCE executor where the choice is between the Ginkgo (syncfree) and the cuSPARSE/hipSPARSE/reference (sparselib) implementation. Default is sparselib.

◆ both_factors

template<typename ValueType = gko::default_precision, typename IndexType = gko::int32>
bool gko::factorization::Ic< ValueType, IndexType >::parameters_type::both_factors {true}

true will generate both L and L^H, false will only generate the L factor, resulting in a Composition of only a single LinOp.

This can be used to avoid the transposition operation.

◆ l_strategy

template<typename ValueType = gko::default_precision, typename IndexType = gko::int32>
std::shared_ptr<typename matrix_type::strategy_type> gko::factorization::Ic< ValueType, IndexType >::parameters_type::l_strategy {nullptr}

Strategy which will be used by the L matrix.

The default value nullptr will result in the strategy classical.

◆ skip_sorting

template<typename ValueType = gko::default_precision, typename IndexType = gko::int32>
bool gko::factorization::Ic< ValueType, IndexType >::parameters_type::skip_sorting {false}

The system_matrix, which will be given to this factory, must be sorted (first by row, then by column) in order for the algorithm to work.

If it is known that the matrix will be sorted, this parameter can be set to true to skip the sorting (therefore, shortening the runtime). However, if it is unknown or if the matrix is known to be not sorted, it must remain false, otherwise, this factorization might be incorrect.


The documentation for this struct was generated from the following file:
  • ginkgo/core/factorization/ic.hpp