A BlockOperator represents a linear operator that is partitioned into multiple blocks. More...

#include <ginkgo/core/base/block_operator.hpp>

Inheritance diagram for gko::BlockOperator:

Collaboration diagram for gko::BlockOperator:

Public Member Functions
dim< 2 >	get_block_size () const
	Get the block dimension of this, i.e. More...

const LinOp *	block_at (size_type i, size_type j) const
	Const access to a specific block. More...

	BlockOperator (const BlockOperator &other)
	Copy constructs a BlockOperator. More...

	BlockOperator (BlockOperator &&other) noexcept
	Move constructs a BlockOperator. More...

BlockOperator &	operator= (const BlockOperator &other)
	Copy assigns a BlockOperator. More...

BlockOperator &	operator= (BlockOperator &&other)
	Move assigns a BlockOperator. More...

Public Member Functions inherited from gko::EnableLinOp< BlockOperator >
const BlockOperator *	apply (ptr_param< const LinOp > b, ptr_param< LinOp > x) const

BlockOperator *	apply (ptr_param< const LinOp > b, ptr_param< LinOp > x)

const BlockOperator *	apply (ptr_param< const LinOp > alpha, ptr_param< const LinOp > b, ptr_param< const LinOp > beta, ptr_param< LinOp > x) const

BlockOperator *	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< BlockOperator, LinOp >
std::unique_ptr< BlockOperator >	create_default (std::shared_ptr< const Executor > exec) const

std::unique_ptr< BlockOperator >	create_default () const

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

std::unique_ptr< BlockOperator >	clone () const

BlockOperator *	copy_from (const PolymorphicObject *other)

std::enable_if_t< std::is_base_of< PolymorphicObject, std::decay_t< Derived > >::value, BlockOperator > *	copy_from (std::unique_ptr< Derived > &&other)

std::enable_if_t< std::is_base_of< PolymorphicObject, std::decay_t< Derived > >::value, BlockOperator > *	copy_from (const std::unique_ptr< Derived > &other)

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

BlockOperator *	move_from (ptr_param< PolymorphicObject > other)

BlockOperator *	clear ()

Public Member Functions inherited from gko::LinOp
LinOp *	apply (ptr_param< const LinOp > b, ptr_param< LinOp > x)
	Applies a linear operator to a vector (or a sequence of vectors). More...

const LinOp *	apply (ptr_param< const LinOp > b, ptr_param< LinOp > x) const

LinOp *	apply (ptr_param< const LinOp > alpha, ptr_param< const LinOp > b, ptr_param< const LinOp > beta, ptr_param< LinOp > x)
	Performs the operation x = alpha * op(b) + beta * x. More...

const LinOp *	apply (ptr_param< const LinOp > alpha, ptr_param< const LinOp > b, ptr_param< const LinOp > beta, ptr_param< LinOp > x) const

const dim< 2 > &	get_size () const noexcept
	Returns the size of the operator. More...

virtual bool	apply_uses_initial_guess () const
	Returns true if the linear operator uses the data given in x as an initial guess. More...

LinOp &	operator= (const LinOp &)=default
	Copy-assigns a LinOp. More...

LinOp &	operator= (LinOp &&other)
	Move-assigns a LinOp. More...

	LinOp (const LinOp &)=default
	Copy-constructs a LinOp. More...

	LinOp (LinOp &&other)
	Move-constructs a LinOp. More...

Public Member Functions inherited from gko::EnableAbstractPolymorphicObject< LinOp >
std::unique_ptr< LinOp >	create_default (std::shared_ptr< const Executor > exec) const

std::unique_ptr< LinOp >	create_default () const

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

std::unique_ptr< LinOp >	clone () const

LinOp *	copy_from (const PolymorphicObject *other)

std::enable_if_t< std::is_base_of< PolymorphicObject, std::decay_t< Derived > >::value, LinOp > *	copy_from (std::unique_ptr< Derived > &&other)

std::enable_if_t< std::is_base_of< PolymorphicObject, std::decay_t< Derived > >::value, LinOp > *	copy_from (const std::unique_ptr< Derived > &other)

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

LinOp *	move_from (ptr_param< PolymorphicObject > other)

LinOp *	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
	Creates a new "default" object of the same dynamic type as this object. More...

std::unique_ptr< PolymorphicObject >	create_default () const
	Creates a new "default" object of the same dynamic type as this object. More...

std::unique_ptr< PolymorphicObject >	clone (std::shared_ptr< const Executor > exec) const
	Creates a clone of the object. More...

std::unique_ptr< PolymorphicObject >	clone () const
	Creates a clone of the object. More...

PolymorphicObject *	copy_from (const PolymorphicObject *other)
	Copies another object into this object. More...

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. More...

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. More...

PolymorphicObject *	copy_from (const std::shared_ptr< const PolymorphicObject > &other)
	Copies another object into this object. More...

PolymorphicObject *	move_from (ptr_param< PolymorphicObject > other)
	Moves another object into this object. More...

PolymorphicObject *	clear ()
	Transforms the object into its default state. More...

std::shared_ptr< const Executor >	get_executor () const noexcept
	Returns the Executor of the object. More...

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< BlockOperator >
void	convert_to (result_type *result) const override
	Converts the implementer to an object of type result_type. More...

void	move_to (result_type *result) override
	Converts the implementer to an object of type result_type by moving data from this object. More...

Public Member Functions inherited from gko::ConvertibleTo< BlockOperator >
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< BlockOperator >	create (std::shared_ptr< const Executor > exec)
	Create empty BlockOperator. More...

static std::unique_ptr< BlockOperator >	create (std::shared_ptr< const Executor > exec, std::vector< std::vector< std::shared_ptr< const LinOp >>> blocks)
	Create BlockOperator from the given blocks. More...

Friends
class	EnablePolymorphicObject< BlockOperator, LinOp >

Additional Inherited Members
Public Types inherited from gko::EnablePolymorphicAssignment< BlockOperator >
using	result_type = BlockOperator

Public Types inherited from gko::ConvertibleTo< BlockOperator >
using	result_type = BlockOperator

Detailed Description

A BlockOperator represents a linear operator that is partitioned into multiple blocks.

For example, a BlockOperator can be used to define the operator:

| A B |

| C D |

where A, B, C, D itself are matrices of compatible size. This can be created with:

 {c++}
std::shared_ptr<LinOp> A = ...;
std::shared_ptr<LinOp> B = ...;
std::shared_ptr<LinOp> C = ...;
std::shared_ptr<LinOp> D = ...;
auto bop = BlockOperator::create(exec, {{A, B}, {C, D}});

The requirements on the individual blocks passed to the create method are:

In each block-row, all blocks have the same number of rows
In each block-column, all blocks have the same number of columns
Each block-row must have the same number of blocks It is possible to set blocks to zero, by passing in a nullptr. But every block-row and block-column must contain at least one non-nullptr block.

The constructor will store all passed in blocks on the same executor as the BlockOperator, which will requires copying any block that is associated with a different executor.

Constructor & Destructor Documentation

◆ BlockOperator() [1/2]

gko::BlockOperator::BlockOperator ( const BlockOperator & other )

Copy constructs a BlockOperator.

The executor of other is used for this. The blocks of other are deep-copied into this, using clone.

◆ BlockOperator() [2/2]

gko::BlockOperator::BlockOperator ( BlockOperator && other )

noexcept

Move constructs a BlockOperator.

The executor of other is used for this. All remaining data of other is moved into this. After this operation, other will be empty.

Member Function Documentation

◆ block_at()

const LinOp* gko::BlockOperator::block_at	(	size_type	i,
		size_type	j
	)		const

inline

Const access to a specific block.

Parameters

i	block row.
j	block column.

Returns: the block stored at (i, j).

◆ create() [1/2]

static std::unique_ptr<BlockOperator> gko::BlockOperator::create ( std::shared_ptr< const Executor > exec )

static

Create empty BlockOperator.

Parameters

exec	the executor of this.

Returns: empty BlockOperator.

◆ create() [2/2]

static std::unique_ptr<BlockOperator> gko::BlockOperator::create	(	std::shared_ptr< const Executor >	exec,
		std::vector< std::vector< std::shared_ptr< const LinOp >>>	blocks
	)

static

Create BlockOperator from the given blocks.

Parameters

exec	the executor of this.
blocks	the blocks of this operator. The blocks will be used in a row-major form.

Returns: BlockOperator with the given blocks.

◆ get_block_size()

dim<2> gko::BlockOperator::get_block_size ( ) const

inline

Get the block dimension of this, i.e.

the number of blocks per row and column.

Returns: The block dimension of this.

◆ operator=() [1/2]

BlockOperator& gko::BlockOperator::operator= ( BlockOperator && other )

Move assigns a BlockOperator.

The executor of this is not modified. All data of other (except its executor) is moved into this. If the executor of this and other differ, the blocks will be copied to the executor of this. After this operation, other will be empty.

◆ operator=() [2/2]

BlockOperator& gko::BlockOperator::operator= ( const BlockOperator & other )

Copy assigns a BlockOperator.

The executor of this is not modified. The blocks of other are deep-copied into this, using clone.

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

ginkgo/core/base/block_operator.hpp

Public Member Functions

Static Public Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ BlockOperator() [1/2]

◆ BlockOperator() [2/2]

Member Function Documentation

◆ block_at()

◆ create() [1/2]

◆ create() [2/2]

◆ get_block_size()

◆ operator=() [1/2]

◆ operator=() [2/2]