Ginkgo: gko::experimental::factorization::Factorization< ValueType, 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::experimental::factorization::Factorization< ValueType, IndexType > Class Template Reference

Represents a generic factorization consisting of two triangular factors (upper and lower) and an optional diagonal scaling matrix. More...

`#include <ginkgo/core/factorization/factorization.hpp>`

Inheritance diagram for gko::experimental::factorization::Factorization< ValueType, IndexType >:
[legend]
Collaboration diagram for gko::experimental::factorization::Factorization< ValueType, IndexType >:
[legend]

## Public Types
using | value_type = ValueType
using | index_type = IndexType
using | matrix_type = matrix::Csr<ValueType, IndexType>
using | diag_type = matrix::Diagonal<ValueType>
using | composition_type = Composition<ValueType>
Public Types inherited from gko::EnablePolymorphicAssignment< Factorization< ValueType, IndexType > >
using | result_type

## Public Member 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.
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.
Factorization & | operator= (const Factorization &)
Factorization & | operator= (Factorization &&)
Public Member Functions inherited from gko::EnableLinOp< Factorization< ValueType, IndexType > >
const Factorization< ValueType, IndexType > * | apply (ptr_param< const LinOp > b, ptr_param< LinOp > x) const
Public Member Functions inherited from gko::EnablePolymorphicAssignment< Factorization< ValueType, IndexType > >
void | convert_to (result_type *result) const override
void | move_to (result_type *result) override

## Static Public Member Functions
static std::unique_ptr< Factorization > | create_from_composition (std::unique_ptr< composition_type > composition)
| Creates a Factorization from an existing composition.
static std::unique_ptr< Factorization > | create_from_symm_composition (std::unique_ptr< composition_type > composition)
| Creates a Factorization from an existing symmetric 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.
static std::unique_ptr< Factorization > | create_from_combined_ldu (std::unique_ptr< matrix_type > matrix)
static std::unique_ptr< Factorization > | create_from_combined_cholesky (std::unique_ptr< matrix_type > matrix)
static std::unique_ptr< Factorization > | create_from_combined_ldl (std::unique_ptr< matrix_type > matrix)

## Friends
class | EnablePolymorphicObject< Factorization, LinOp >

## Detailed Description

template<typename ValueType, typename IndexType>
class gko::experimental::factorization::Factorization< ValueType, IndexType >

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

## Member Function Documentation

## ◆ create_from_combined_lu()

template<typename ValueType, typename IndexType>

std::unique_ptr< Factorization > gko::experimental::factorization::Factorization< ValueType, IndexType >::create_from_combined_lu | ( | std::unique_ptr< matrix_type > | matrix | ) |
| static

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.

## ◆ create_from_composition()

template<typename ValueType, typename IndexType>

std::unique_ptr< Factorization > gko::experimental::factorization::Factorization< ValueType, IndexType >::create_from_composition | ( | std::unique_ptr< composition_type > | composition | ) |
| static

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.

## ◆ create_from_symm_composition()

template<typename ValueType, typename IndexType>

std::unique_ptr< Factorization > gko::experimental::factorization::Factorization< ValueType, IndexType >::create_from_symm_composition | ( | std::unique_ptr< composition_type > | composition | ) |
| static

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.

## ◆ unpack()

template<typename ValueType, typename IndexType>

std::unique_ptr< Factorization > gko::experimental::factorization::Factorization< ValueType, IndexType >::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.

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

- ginkgo/core/factorization/factorization.hpp