Ginkgo Generated from branch based on master. Ginkgo version 1.7.0
A numerical linear algebra library targeting many-core architectures
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | Friends | List of all members
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< ConcreteType, ResultType >
using result_type = ResultType
 
- Public Types inherited from gko::ConvertibleTo< ResultType >
using result_type = ResultType
 

Public Member Functions

std::unique_ptr< Factorizationunpack () 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_typeget_lower_factor () const
 Returns the lower triangular factor of the factorization, if available, nullptr otherwise.
 
std::shared_ptr< const diag_typeget_diagonal () const
 Returns the diagonal scaling matrix of the factorization, if available, nullptr otherwise.
 
std::shared_ptr< const matrix_typeget_upper_factor () const
 Returns the upper triangular factor of the factorization, if available, nullptr otherwise.
 
std::shared_ptr< const matrix_typeget_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.
 
Factorizationoperator= (const Factorization &)
 
Factorizationoperator= (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
 
Factorization< ValueType, IndexType > * apply (ptr_param< const LinOp > b, ptr_param< LinOp > x)
 
const Factorization< ValueType, IndexType > * apply (ptr_param< const LinOp > alpha, ptr_param< const LinOp > b, ptr_param< const LinOp > beta, ptr_param< LinOp > x) const
 
Factorization< ValueType, IndexType > * apply (ptr_param< const LinOp > alpha, ptr_param< const LinOp > b, ptr_param< const LinOp > beta, ptr_param< LinOp > x)
 
- Public Member Functions inherited from gko::EnableAbstractPolymorphicObject< AbstractObject, PolymorphicBase >
std::unique_ptr< AbstractObjectcreate_default (std::shared_ptr< const Executor > exec) const
 
std::unique_ptr< AbstractObjectcreate_default () const
 
std::unique_ptr< AbstractObjectclone (std::shared_ptr< const Executor > exec) const
 
std::unique_ptr< AbstractObjectclone () const
 
AbstractObjectcopy_from (const PolymorphicObject *other)
 
template<typename Derived >
std::enable_if_t< std::is_base_of< PolymorphicObject, std::decay_t< Derived > >::value, AbstractObject > * copy_from (std::unique_ptr< Derived > &&other)
 
template<typename Derived >
std::enable_if_t< std::is_base_of< PolymorphicObject, std::decay_t< Derived > >::value, AbstractObject > * copy_from (const std::unique_ptr< Derived > &other)
 
AbstractObjectcopy_from (const std::shared_ptr< const PolymorphicObject > &other)
 
AbstractObjectmove_from (ptr_param< PolymorphicObject > other)
 
AbstractObjectclear ()
 
- Public Member Functions inherited from gko::PolymorphicObject
PolymorphicObjectoperator= (const PolymorphicObject &)
 
std::unique_ptr< PolymorphicObjectcreate_default (std::shared_ptr< const Executor > exec) const
 Creates a new "default" object of the same dynamic type as this object.
 
std::unique_ptr< PolymorphicObjectcreate_default () const
 Creates a new "default" object of the same dynamic type as this object.
 
std::unique_ptr< PolymorphicObjectclone (std::shared_ptr< const Executor > exec) const
 Creates a clone of the object.
 
std::unique_ptr< PolymorphicObjectclone () const
 Creates a clone of the object.
 
PolymorphicObjectcopy_from (const PolymorphicObject *other)
 Copies another object into this object.
 
template<typename Derived , typename Deleter >
std::enable_if_t< std::is_base_of< PolymorphicObject, std::decay_t< Derived > >::value, PolymorphicObject > * copy_from (std::unique_ptr< Derived, Deleter > &&other)
 Moves another object into this object.
 
template<typename Derived , typename Deleter >
std::enable_if_t< std::is_base_of< PolymorphicObject, std::decay_t< Derived > >::value, PolymorphicObject > * copy_from (const std::unique_ptr< Derived, Deleter > &other)
 Copies another object into this object.
 
PolymorphicObjectcopy_from (const std::shared_ptr< const PolymorphicObject > &other)
 Copies another object into this object.
 
PolymorphicObjectmove_from (ptr_param< PolymorphicObject > other)
 Moves another object into this object.
 
PolymorphicObjectclear ()
 Transforms the object into its default state.
 
std::shared_ptr< const Executorget_executor () const noexcept
 Returns the Executor of the object.
 
- Public Member Functions inherited from gko::log::EnableLogging< PolymorphicObject >
void add_logger (std::shared_ptr< const Logger > logger) override
 Adds a new logger to the list of subscribed loggers.
 
void remove_logger (const Logger *logger) override
 Removes a logger from the list of subscribed loggers.
 
void remove_logger (ptr_param< const Logger > logger)
 
const std::vector< std::shared_ptr< const Logger > > & get_loggers () const override
 Returns the vector containing all loggers registered at this object.
 
void clear_loggers () override
 Remove all loggers registered at this object.
 
- Public Member Functions inherited from gko::log::Loggable
void remove_logger (ptr_param< const Logger > logger)
 
- Public Member Functions inherited from gko::EnablePolymorphicAssignment< ConcreteType, ResultType >
void convert_to (result_type *result) const override
 Converts the implementer to an object of type result_type.
 
void move_to (result_type *result) override
 Converts the implementer to an object of type result_type by moving data from this object.
 
- Public Member Functions inherited from gko::ConvertibleTo< ResultType >
void convert_to (ptr_param< result_type > result) const
 
void move_to (ptr_param< result_type > result)
 

Static Public Member Functions

static std::unique_ptr< Factorizationcreate_from_composition (std::unique_ptr< composition_type > composition)
 Creates a Factorization from an existing composition.
 
static std::unique_ptr< Factorizationcreate_from_symm_composition (std::unique_ptr< composition_type > composition)
 Creates a Factorization from an existing symmetric composition.
 
static std::unique_ptr< Factorizationcreate_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< Factorizationcreate_from_combined_ldu (std::unique_ptr< matrix_type > matrix)
 
static std::unique_ptr< Factorizationcreate_from_combined_cholesky (std::unique_ptr< matrix_type > matrix)
 
static std::unique_ptr< Factorizationcreate_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
ValueTypethe value type used to store the factorization entries
IndexTypethe index type used to represent the sparsity pattern

Member Function Documentation

◆ create_from_combined_lu()

template<typename ValueType , typename IndexType >
static 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
matrixthe 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 >
static 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
compositionthe 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 >
static 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
compositionthe 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: