gko::experimental::factorization::
Factorization#

The container produced by every factorisation in this namespace. Owns the computed factors and dispatches on apply: depending on the internal representation, applying the Factorization performs the appropriate combination of triangular solves and matrix multiplies that realises the action of \(A^{-1}\) (or its approximation).

Lives in the experimental namespace pending API stabilisation.

template<typename ValueType, typename IndexType>
class Factorization #

Inherits from

Represents a generic factorization consisting of two triangular factors (upper and lower) and an optional diagonal scaling matrix. This class is used to represent a wide range of different factorizations to be passed on to direct solvers and other similar operations. The storage_type represents how the individual factors are stored internally: They may be stored as separate matrices or in a single matrix, and be symmetric or unsymmetric, with the diagonal belonging to both factory, a single factor or being a separate scaling factor (Cholesky vs. LDL^H vs. LU vs. LDU).

Template Parameters:

  • ValueType – the value type used to store the factorization entries

  • IndexType – the index type used to represent the sparsity pattern

Public Functions

std::unique_ptr<Factorization> unpack() const#

Transforms the factorization from a compact representation suitable only for triangular solves to a composition representation that can also be used to access individual factors and multiply with the factorization.

Returns:

a new Factorization object containing this factorization represented as storage_type::composition.

storage_type get_storage_type() const#

Returns the storage type used by this factorization.

std::shared_ptr<const matrix_type> get_lower_factor() const#

Returns the lower triangular factor of the factorization, if available, nullptr otherwise.

std::shared_ptr<const diag_type> get_diagonal() const#

Returns the diagonal scaling matrix of the factorization, if available, nullptr otherwise.

std::shared_ptr<const matrix_type> get_upper_factor() const#

Returns the upper triangular factor of the factorization, if available, nullptr otherwise.

std::shared_ptr<const matrix_type> get_combined() const#

Returns the matrix storing a compact representation of the factorization, if available, nullptr otherwise.

Factorization(const Factorization&)#

Creates a deep copy of the factorization.

Factorization(Factorization&&)#

Moves from the given factorization, leaving it empty.

Public Static Functions

static std::unique_ptr<Factorization> create_from_composition(
std::unique_ptr<composition_type> composition,
)#

Creates a Factorization from an existing composition.

Parameters:

composition – the composition consisting of 2 or 3 elements. We expect the first entry to be a lower triangular matrix, and the last entry to be an upper triangular matrix. If the composition has 3 elements, we expect the middle entry to be a diagonal matrix.

Returns:

a Factorization storing the elements from the Composition.

static std::unique_ptr<Factorization> create_from_symm_composition(
std::unique_ptr<composition_type> composition,
)#

Creates a Factorization from an existing symmetric composition.

Parameters:

composition – the composition consisting of 2 or 3 elements. We expect the first entry to be a lower triangular matrix, and the last entry to be the transpose of the first entry. If the composition has 3 elements, we expect the middle entry to be a diagonal matrix.

Returns:

a symmetric Factorization storing the elements from the Composition.

static std::unique_ptr<Factorization> create_from_combined_lu(
std::unique_ptr<matrix_type> matrix,
)#

Creates a Factorization from an existing combined representation of an LU factorization.

Parameters:

matrix – the composition consisting of 2 or 3 elements. We expect the first entry to be a lower triangular matrix, and the last entry to be the transpose of the first entry. If the composition has 3 elements, we expect the middle entry to be a diagonal matrix.

Returns:

a symmetric Factorization storing the elements from the Composition.