Ginkgo: gko::BlockOperator Class 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::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 LinOp * | block_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.
BlockOperator & | operator= (const BlockOperator &other)
| Copy assigns a BlockOperator.
BlockOperator & | operator= (BlockOperator &&other)
| Move assigns a BlockOperator.
Public Member Functions inherited from gko::EnableLinOp< BlockOperator >
const BlockOperator * | apply (ptr_param< const LinOp > b, ptr_param< LinOp > x) const
Public Member Functions inherited from gko::EnablePolymorphicAssignment< BlockOperator >
void | convert_to (result_type *result) const override
void | move_to (result_type *result) override

## Static Public Member Functions
static std::unique_ptr< BlockOperator > | create (std::shared_ptr< const Executor > exec)
| Create empty BlockOperator.
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.

## Friends
class | EnablePolymorphicObject< BlockOperator, LinOp >

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

## 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:

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}});
gko::BlockOperator::create
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:

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

References BlockOperator().

Referenced by BlockOperator(), BlockOperator(), operator=(), and operator=().

## ◆ 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.

References BlockOperator().

## 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]

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]

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.

References BlockOperator().

## ◆ 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.

References BlockOperator().

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

- ginkgo/core/base/block_operator.hpp