Ginkgo Generated from develop branch based on develop. Ginkgo version 1.8.0
A numerical linear algebra library targeting many-core architectures
Loading...
Searching...
No Matches
Public Member Functions | Static Public Member Functions | Friends | List of all members
gko::BlockOperator Class Referencefinal

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:
[legend]
Collaboration diagram for gko::BlockOperator:
[legend]

Public Member Functions

dim< 2 > get_block_size () const
 Get the block dimension of this, i.e.
 
const LinOpblock_at (size_type i, size_type j) const
 Const access to a specific block.
 
 BlockOperator (const BlockOperator &other)
 Copy constructs a BlockOperator.
 
 BlockOperator (BlockOperator &&other) noexcept
 Move constructs a BlockOperator.
 
BlockOperatoroperator= (const BlockOperator &other)
 Copy assigns a BlockOperator.
 
BlockOperatoroperator= (BlockOperator &&other)
 Move assigns a BlockOperator.
 
- Public Member Functions inherited from gko::EnableLinOp< BlockOperator >
const BlockOperatorapply (ptr_param< const LinOp > b, ptr_param< LinOp > x) const
 
BlockOperatorapply (ptr_param< const LinOp > b, ptr_param< LinOp > x)
 
const BlockOperatorapply (ptr_param< const LinOp > alpha, ptr_param< const LinOp > b, ptr_param< const LinOp > beta, ptr_param< LinOp > x) const
 
BlockOperatorapply (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< BlockOperatorcreate (std::shared_ptr< const Executor > exec)
 Create empty BlockOperator.
 
static std::unique_ptr< BlockOperatorcreate (std::shared_ptr< const Executor > exec, std::vector< std::vector< std::shared_ptr< const LinOp > > > blocks)
 Create BlockOperator from the given blocks.
 

Friends

class EnablePolymorphicObject< BlockOperator, LinOp >
 

Additional Inherited Members

- Public Types inherited from gko::EnablePolymorphicAssignment< ConcreteType, ResultType >
using result_type = ResultType
 
- Public Types inherited from gko::ConvertibleTo< ResultType >
using result_type = ResultType
 

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 |
constexpr T one()
Returns the multiplicative identity for T.
Definition math.hpp:775

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

++
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}});
static std::unique_ptr< BlockOperator > create(std::shared_ptr< const Executor > exec)
Create empty BlockOperator.

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

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
iblock row.
jblock column.
Returns
the block stored at (i, j).

References gko::one().

◆ create() [1/2]

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

Create empty BlockOperator.

Parameters
execthe 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
execthe executor of this.
blocksthe 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: