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

Inheritance diagram for gko::experimental::factorization::Factorization< ValueType, IndexType >:

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< Factorization >	unpack () const

storage_type	get_storage_type () const

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

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

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

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

	Factorization (const Factorization &)

	Factorization (Factorization &&)

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

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< AbstractObject >	create_default (std::shared_ptr< const Executor > exec) const

std::unique_ptr< AbstractObject >	create_default () const

std::unique_ptr< AbstractObject >	clone (std::shared_ptr< const Executor > exec) const

std::unique_ptr< AbstractObject >	clone () const

AbstractObject *	copy_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)

AbstractObject *	copy_from (const std::shared_ptr< const PolymorphicObject > &other)

AbstractObject *	move_from (ptr_param< PolymorphicObject > other)

AbstractObject *	clear ()

Public Member Functions inherited from gko::PolymorphicObject
PolymorphicObject &	operator= (const PolymorphicObject &)

std::unique_ptr< PolymorphicObject >	create_default (std::shared_ptr< const Executor > exec) const

std::unique_ptr< PolymorphicObject >	create_default () const

std::unique_ptr< PolymorphicObject >	clone (std::shared_ptr< const Executor > exec) const

std::unique_ptr< PolymorphicObject >	clone () const

PolymorphicObject *	copy_from (const PolymorphicObject *other)

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)

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)

PolymorphicObject *	copy_from (const std::shared_ptr< const PolymorphicObject > &other)

PolymorphicObject *	move_from (ptr_param< PolymorphicObject > other)

PolymorphicObject *	clear ()

std::shared_ptr< const Executor >	get_executor () const noexcept

Public Member Functions inherited from gko::log::EnableLogging< PolymorphicObject >
void	add_logger (std::shared_ptr< const Logger > logger) override

void	remove_logger (const Logger *logger) override

void	remove_logger (ptr_param< const Logger > logger)

const std::vector< std::shared_ptr< const Logger > > &	get_loggers () const override

void	clear_loggers () override

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

void	move_to (result_type *result) override

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< Factorization >	create_from_composition (std::unique_ptr< composition_type > composition)

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

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

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)

Protected Member Functions
	Factorization (std::shared_ptr< const Executor > exec)

	Factorization (std::unique_ptr< Composition< ValueType > > factors, storage_type type)

void	apply_impl (const LinOp b, LinOp x) const override

void	apply_impl (const LinOp alpha, const LinOp b, const LinOp beta, LinOp x) const override

Protected Member Functions inherited from gko::EnableLinOp< Factorization< ValueType, IndexType > >
Factorization< ValueType, IndexType > *	self () noexcept

const Factorization< ValueType, IndexType > *	self () const noexcept

Protected Member Functions inherited from gko::EnablePolymorphicObject< ConcreteObject, PolymorphicBase >
std::unique_ptr< PolymorphicObject >	create_default_impl (std::shared_ptr< const Executor > exec) const override

PolymorphicObject *	copy_from_impl (const PolymorphicObject *other) override

PolymorphicObject *	copy_from_impl (std::unique_ptr< PolymorphicObject > other) override

PolymorphicObject *	move_from_impl (PolymorphicObject *other) override

PolymorphicObject *	move_from_impl (std::unique_ptr< PolymorphicObject > other) override

PolymorphicObject *	clear_impl () override

Protected Member Functions inherited from gko::PolymorphicObject
	PolymorphicObject (std::shared_ptr< const Executor > exec)

	PolymorphicObject (const PolymorphicObject &other)

Protected Member Functions inherited from gko::log::EnableLogging< PolymorphicObject >
void	log (Params &&... params) const

Friends
class	EnablePolymorphicObject< Factorization, LinOp >

Additional Inherited Members
Protected Attributes inherited from gko::log::EnableLogging< PolymorphicObject >
std::vector< std::shared_ptr< const Logger > >	loggers_

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

Constructor & Destructor Documentation

◆ Factorization() [1/2]

template<typename ValueType , typename IndexType >

gko::experimental::factorization::Factorization< ValueType, IndexType >::Factorization ( const Factorization< ValueType, IndexType > & )

Creates a deep copy of the factorization.

◆ Factorization() [2/2]

template<typename ValueType , typename IndexType >

gko::experimental::factorization::Factorization< ValueType, IndexType >::Factorization ( Factorization< ValueType, IndexType > && )

Moves from the given factorization, leaving it empty.

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

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 >

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

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 >

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

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.

◆ get_combined()

template<typename ValueType , typename IndexType >

std::shared_ptr< const matrix_type > gko::experimental::factorization::Factorization< ValueType, IndexType >::get_combined ( ) const

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

◆ get_diagonal()

template<typename ValueType , typename IndexType >

std::shared_ptr< const diag_type > gko::experimental::factorization::Factorization< ValueType, IndexType >::get_diagonal ( ) const

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

◆ get_lower_factor()

template<typename ValueType , typename IndexType >

std::shared_ptr< const matrix_type > gko::experimental::factorization::Factorization< ValueType, IndexType >::get_lower_factor ( ) const

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

◆ get_storage_type()

template<typename ValueType , typename IndexType >

storage_type gko::experimental::factorization::Factorization< ValueType, IndexType >::get_storage_type ( ) const

Returns the storage type used by this factorization.

◆ get_upper_factor()

template<typename ValueType , typename IndexType >

std::shared_ptr< const matrix_type > gko::experimental::factorization::Factorization< ValueType, IndexType >::get_upper_factor ( ) const

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

◆ 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

Factorization< ValueType, IndexType > Class Template Reference

Factorization< ValueType, IndexType > Class Template Reference#

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ Factorization() [1/2]

◆ Factorization() [2/2]

Member Function Documentation

◆ create_from_combined_lu()

◆ create_from_composition()

◆ create_from_symm_composition()

◆ get_combined()

◆ get_diagonal()

◆ get_lower_factor()

◆ get_storage_type()

◆ get_upper_factor()

◆ unpack()

Factorization< ValueType, IndexType > Class Template Reference

Factorization&lt; ValueType, IndexType &gt; Class Template Reference#

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ Factorization() [1/2]

◆ Factorization() [2/2]

Member Function Documentation

◆ create_from_combined_lu()

◆ create_from_composition()

◆ create_from_symm_composition()

◆ get_combined()

◆ get_diagonal()

◆ get_lower_factor()

◆ get_storage_type()

◆ get_upper_factor()

◆ unpack()

Factorization< ValueType, IndexType > Class Template Reference#