Ginkgo: gko::batch::MultiVector< ValueType > Class Template 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::batch::MultiVector< ValueType > Class Template Reference

MultiVector stores multiple vectors in a batched fashion and is useful for batched operations. More...

`#include <ginkgo/core/base/batch_multi_vector.hpp>`

Inheritance diagram for gko::batch::MultiVector< ValueType >:
[legend]
Collaboration diagram for gko::batch::MultiVector< ValueType >:
[legend]

## Public Types
using | value_type = ValueType
using | index_type = int32
using | unbatch_type = gko::matrix::Dense<ValueType>
using | absolute_type = remove_complex<MultiVector<ValueType>>
using | complex_type = to_complex<MultiVector<ValueType>>
Public Types inherited from gko::EnablePolymorphicAssignment< MultiVector< default_precision > >
using | result_type

## Public Member Functions
void | convert_to (MultiVector< next_precision< ValueType > > *result) const override
void | move_to (MultiVector< next_precision< ValueType > > *result) override
std::unique_ptr< unbatch_type > | create_view_for_item (size_type item_id)
| Creates a mutable view (of matrix::Dense type) of one item of the Batch MultiVector object.
std::unique_ptr< const unbatch_type > | create_const_view_for_item (size_type item_id) const
| Creates a mutable view (of matrix::Dense type) of one item of the Batch MultiVector object.
batch_dim< 2 > | get_size () const
| Returns the batch size.
size_type | get_num_batch_items () const
| Returns the number of batch items.
dim< 2 > | get_common_size () const
| Returns the common size of the batch items.
value_type * | get_values () noexcept
| Returns a pointer to the array of values of the multi-vector.
const value_type * | get_const_values () const noexcept
| Returns a pointer to the array of values of the multi-vector.
value_type * | get_values_for_item (size_type batch_id) noexcept
| Returns a pointer to the array of values of the multi-vector for a specific batch item.
const value_type * | get_const_values_for_item (size_type batch_id) const noexcept
| Returns a pointer to the array of values of the multi-vector for a specific batch item.
size_type | get_num_stored_elements () const noexcept
| Returns the number of elements explicitly stored in the batch matrix, cumulative across all the batch items.
size_type | get_cumulative_offset (size_type batch_id) const
| Get the cumulative storage size offset.
value_type & | at (size_type batch_id, size_type row, size_type col)
| Returns a single element for a particular batch item.
value_type | at (size_type batch_id, size_type row, size_type col) const
| Returns a single element for a particular batch item.
ValueType & | at (size_type batch_id, size_type idx) noexcept
| Returns a single element for a particular batch item.
ValueType | at (size_type batch_id, size_type idx) const noexcept
| Returns a single element for a particular batch item.
void | scale (ptr_param< const MultiVector< ValueType > > alpha)
| Scales the vector with a scalar (aka: BLAS scal).
void | add_scaled (ptr_param< const MultiVector< ValueType > > alpha, ptr_param< const MultiVector< ValueType > > b)
| Adds b scaled by alpha to the vector (aka: BLAS axpy).
void | compute_dot (ptr_param< const MultiVector< ValueType > > b, ptr_param< MultiVector< ValueType > > result) const
| Computes the column-wise dot product of each multi-vector in this batch and its corresponding entry in b.
void | compute_conj_dot (ptr_param< const MultiVector< ValueType > > b, ptr_param< MultiVector< ValueType > > result) const
| Computes the column-wise conjugate dot product of each multi-vector in this batch and its corresponding entry in b.
void | compute_norm2 (ptr_param< MultiVector< remove_complex< ValueType > > > result) const
| Computes the Euclidean (L^2) norm of each multi-vector in this batch.
void | fill (ValueType value)
| Fills the input MultiVector with a given value.
Public Member Functions inherited from gko::EnablePolymorphicAssignment< MultiVector< default_precision > >
void | convert_to (result_type *result) const override
void | move_to (result_type *result) override

## Static Public Member Functions
static std::unique_ptr< MultiVector > | create_with_config_of (ptr_param< const MultiVector > other)
| Creates a MultiVector with the configuration of another MultiVector.
static std::unique_ptr< MultiVector > | create (std::shared_ptr< const Executor > exec, const batch_dim< 2 > &size=batch_dim< 2 >{})
| Creates an uninitialized multi-vector of the specified size.
static std::unique_ptr< MultiVector > | create (std::shared_ptr< const Executor > exec, const batch_dim< 2 > &size, array< value_type > values)
| Creates a MultiVector from an already allocated (and initialized) array.
template<typename InputValueType>
static std::unique_ptr< MultiVector > | create (std::shared_ptr< const Executor > exec, const batch_dim< 2 > &size, std::initializer_list< InputValueType > values)
| create(std::shared_ptr<constExecutor>, const batch_dim<2>&, array<value_type>)
static std::unique_ptr< const MultiVector > | create_const (std::shared_ptr< const Executor > exec, const batch_dim< 2 > &sizes, gko::detail::const_array_view< ValueType > &&values)
| Creates a constant (immutable) batch multi-vector from a constant array.

## Friends
class | EnablePolymorphicObject< MultiVector >
class | MultiVector< to_complex< ValueType > >
class | MultiVector< previous_precision< ValueType > >

## Detailed Description

template<typename ValueType = default_precision>
class gko::batch::MultiVector< ValueType >

MultiVector stores multiple vectors in a batched fashion and is useful for batched operations.

For example, if you want to store two batch items with multi-vectors of size (3 x 2) given below:

[1 2 ; 3 4 1 2 ; 3 4 1 2 ; 3 4]

In memory, they would be stored as a single array: [1 2 1 2 1 2 3 4 3 4 3 4].

Access functions @at can help access individual item if necessary.

The values of the different batch items are stored consecutively and in each batch item, the multi-vectors are stored in a row-major fashion.

Template Parameters

  ValueType | precision of multi-vector elements

## Member Function Documentation

## ◆ add_scaled()

template<typename ValueType = default_precision>

void gko::batch::MultiVector< ValueType >::add_scaled | ( | ptr_param< const MultiVector< ValueType > > | alpha,
|  | ptr_param< const MultiVector< ValueType > > | b )

Adds b scaled by alpha to the vector (aka: BLAS axpy).

Parameters

  alpha | the scalar
  b | a multi-vector of the same dimension as this

Note
  If alpha is 1x1 MultiVector matrix, the entire multi-vector (all batches) is scaled by alpha. If it is a MultiVector row vector of values, then i-th column of the vector is scaled with the i-th element of alpha (the number of columns of alpha has to match the number of columns of the multi-vector).

## ◆ at() [1/4]

template<typename ValueType = default_precision>

ValueType gko::batch::MultiVector< ValueType >::at | ( | size_type | batch_id,
|  | size_type | idx ) const
| inlinenoexcept

Returns a single element for a particular batch item.

Parameters

  batch_id | the batch item index to be queried
  row | the row of the requested element
  col | the column of the requested element

Note
  the method has to be called on the same Executor the vector is stored at (e.g. trying to call this method on a GPU multi-vector from the OMP results in a runtime error)

## ◆ at() [2/4]

template<typename ValueType = default_precision>

ValueType & gko::batch::MultiVector< ValueType >::at | ( | size_type | batch_id,
|  | size_type | idx )
| inlinenoexcept

Returns a single element for a particular batch item.

Useful for iterating across all elements of the vector. However, it is less efficient than the two-parameter variant of this method.

Parameters

  batch_id | the batch item index to be queried
  idx | a linear index of the requested element

Note
  the method has to be called on the same Executor the vector is stored at (e.g. trying to call this method on a GPU multi-vector from the OMP results in a runtime error)

## ◆ at() [3/4]

template<typename ValueType = default_precision>

value_type & gko::batch::MultiVector< ValueType >::at | ( | size_type | batch_id,
|  | size_type | row,
|  | size_type | col )
| inline

Returns a single element for a particular batch item.

Parameters

  batch_id | the batch item index to be queried
  row | the row of the requested element
  col | the column of the requested element

Note
  the method has to be called on the same Executor the vector is stored at (e.g. trying to call this method on a GPU multi-vector from the OMP results in a runtime error)

References get_num_batch_items().

## ◆ at() [4/4]

template<typename ValueType = default_precision>

value_type gko::batch::MultiVector< ValueType >::at | ( | size_type | batch_id,
|  | size_type | row,
|  | size_type | col ) const
| inline

Returns a single element for a particular batch item.

Parameters

  batch_id | the batch item index to be queried
  row | the row of the requested element
  col | the column of the requested element

Note
  the method has to be called on the same Executor the vector is stored at (e.g. trying to call this method on a GPU multi-vector from the OMP results in a runtime error)

References get_num_batch_items().

## ◆ compute_conj_dot()

template<typename ValueType = default_precision>

void gko::batch::MultiVector< ValueType >::compute_conj_dot | ( | ptr_param< const MultiVector< ValueType > > | b,
|  | ptr_param< MultiVector< ValueType > > | result ) const

Computes the column-wise conjugate dot product of each multi-vector in this batch and its corresponding entry in b.

If the vector has complex value_type, then the conjugate of this is taken.

Parameters

  b | a MultiVector of same dimension as this
  result | a MultiVector row vector, used to store the dot product (the number of column in the vector must match the number of columns of this)

## ◆ compute_dot()

template<typename ValueType = default_precision>

void gko::batch::MultiVector< ValueType >::compute_dot | ( | ptr_param< const MultiVector< ValueType > > | b,
|  | ptr_param< MultiVector< ValueType > > | result ) const

Computes the column-wise dot product of each multi-vector in this batch and its corresponding entry in b.

Parameters

  b | a MultiVector of same dimension as this
  result | a MultiVector row vector, used to store the dot product

## ◆ compute_norm2()

template<typename ValueType = default_precision>

void gko::batch::MultiVector< ValueType >::compute_norm2 | ( | ptr_param< MultiVector< remove_complex< ValueType > > > | result | ) | const

Computes the Euclidean (L^2) norm of each multi-vector in this batch.

Parameters

  result | a MultiVector, used to store the norm (the number of columns in the vector must match the number of columns of this)

## ◆ create() [1/3]

template<typename ValueType = default_precision>

std::unique_ptr< MultiVector > gko::batch::MultiVector< ValueType >::create | ( | std::shared_ptr< const Executor > | exec,
|  | const batch_dim< 2 > & | size,
|  | array< value_type > | values )
| static

Creates a MultiVector from an already allocated (and initialized) array.

Parameters

  exec | Executor associated to the vector
  size | sizes of the batch matrices in a batch_dim object
  values | array of values

Note
  If values is not an rvalue, not an array of ValueType, or is on the wrong executor, an internal copy will be created, and the original array data will not be used in the vector.

## ◆ create() [2/3]

template<typename ValueType = default_precision>
template<typename InputValueType>

std::unique_ptr< MultiVector > gko::batch::MultiVector< ValueType >::create | ( | std::shared_ptr< const Executor > | exec,
|  | const batch_dim< 2 > & | size,
|  | std::initializer_list< InputValueType > | values )
| inlinestatic

create(std::shared_ptr<constExecutor>, const batch_dim<2>&, array<value_type>)

create(std::shared_ptr<constExecutor>, const batch_dim<2>&, array<value_type>)

References create().

## ◆ create() [3/3]

template<typename ValueType = default_precision>

std::unique_ptr< MultiVector > gko::batch::MultiVector< ValueType >::create | ( | std::shared_ptr< const Executor > | exec,
|  | const batch_dim< 2 > & | size = batch_dim< 2 >{} )
| static

Creates an uninitialized multi-vector of the specified size.

Parameters

  exec | Executor associated to the vector
  size | size of the batch multi vector

Returns
  A smart pointer to the newly created matrix.

Referenced by create().

## ◆ create_const()

template<typename ValueType = default_precision>

std::unique_ptr< const MultiVector > gko::batch::MultiVector< ValueType >::create_const | ( | std::shared_ptr< const Executor > | exec,
|  | const batch_dim< 2 > & | sizes,
|  | gko::detail::const_array_view< ValueType > && | values )
| static

Creates a constant (immutable) batch multi-vector from a constant array.

Parameters

  exec | the executor to create the vector on
  size | the dimensions of the vector
  values | the value array of the vector
  stride | the row-stride of the vector

Returns
  A smart pointer to the constant multi-vector wrapping the input array (if it resides on the same executor as the vector) or a copy of the array on the correct executor.

## ◆ create_const_view_for_item()

template<typename ValueType = default_precision>

std::unique_ptr< const unbatch_type > gko::batch::MultiVector< ValueType >::create_const_view_for_item | ( | size_type | item_id | ) | const

Creates a mutable view (of matrix::Dense type) of one item of the Batch MultiVector object.

Does not perform any deep copies, but only returns a view of the data.

Parameters

  item_id | The index of the batch item

Returns
  a matrix::Dense object with the data from the batch item at the given index.

## ◆ create_view_for_item()

template<typename ValueType = default_precision>

std::unique_ptr< unbatch_type > gko::batch::MultiVector< ValueType >::create_view_for_item | ( | size_type | item_id | ) |

Creates a mutable view (of matrix::Dense type) of one item of the Batch MultiVector object.

Does not perform any deep copies, but only returns a view of the data.

Parameters

  item_id | The index of the batch item

Returns
  a matrix::Dense object with the data from the batch item at the given index.

## ◆ create_with_config_of()

template<typename ValueType = default_precision>

std::unique_ptr< MultiVector > gko::batch::MultiVector< ValueType >::create_with_config_of | ( | ptr_param< const MultiVector< ValueType > > | other | ) |
| static

Creates a MultiVector with the configuration of another MultiVector.

Parameters

  other | The other multi-vector whose configuration needs to copied.

## ◆ fill()

template<typename ValueType = default_precision>

void gko::batch::MultiVector< ValueType >::fill | ( | ValueType | value | ) |

Fills the input MultiVector with a given value.

Parameters

  value | the value to be filled

## ◆ get_common_size()

template<typename ValueType = default_precision>

dim< 2 > gko::batch::MultiVector< ValueType >::get_common_size | ( |  | ) | const
| inline

Returns the common size of the batch items.

Returns
  the common size stored

Referenced by get_cumulative_offset(), gko::batch::BatchLinOp::validate_application_parameters(), and gko::batch::BatchLinOp::validate_application_parameters().

## ◆ get_const_values()

template<typename ValueType = default_precision>

const value_type * gko::batch::MultiVector< ValueType >::get_const_values | ( |  | ) | const
| inlinenoexcept

Returns a pointer to the array of values of the multi-vector.

Returns
  the pointer to the array of values

Note
  This is the constant version of the function, which can be significantly more memory efficient than the non-constant version, so always prefer this version.

## ◆ get_const_values_for_item()

template<typename ValueType = default_precision>

const value_type * gko::batch::MultiVector< ValueType >::get_const_values_for_item | ( | size_type | batch_id | ) | const
| inlinenoexcept

Returns a pointer to the array of values of the multi-vector for a specific batch item.

Parameters

  batch_id | the id of the batch item.

Returns
  the pointer to the array of values

Note
  This is the constant version of the function, which can be significantly more memory efficient than the non-constant version, so always prefer this version.

References get_cumulative_offset(), and get_num_batch_items().

## ◆ get_cumulative_offset()

template<typename ValueType = default_precision>

size_type gko::batch::MultiVector< ValueType >::get_cumulative_offset | ( | size_type | batch_id | ) | const
| inline

Get the cumulative storage size offset.

Parameters

  batch_id | the batch id

Returns
  the cumulative offset

References get_common_size().

Referenced by get_const_values_for_item(), and get_values_for_item().

## ◆ get_num_batch_items()

template<typename ValueType = default_precision>

size_type gko::batch::MultiVector< ValueType >::get_num_batch_items | ( |  | ) | const
| inline

Returns the number of batch items.

Returns
  the number of batch items

Referenced by at(), at(), get_const_values_for_item(), get_values_for_item(), gko::batch::BatchLinOp::validate_application_parameters(), and gko::batch::BatchLinOp::validate_application_parameters().

## ◆ get_num_stored_elements()

template<typename ValueType = default_precision>

size_type gko::batch::MultiVector< ValueType >::get_num_stored_elements | ( |  | ) | const
| inlinenoexcept

Returns the number of elements explicitly stored in the batch matrix, cumulative across all the batch items.

Returns
  the number of elements explicitly stored in the vector, cumulative across all the batch items

## ◆ get_size()

template<typename ValueType = default_precision>

batch_dim< 2 > gko::batch::MultiVector< ValueType >::get_size | ( |  | ) | const
| inline

Returns the batch size.

Returns
  the batch size

## ◆ get_values()

template<typename ValueType = default_precision>

value_type * gko::batch::MultiVector< ValueType >::get_values | ( |  | ) |
| inlinenoexcept

Returns a pointer to the array of values of the multi-vector.

Returns
  the pointer to the array of values

## ◆ get_values_for_item()

template<typename ValueType = default_precision>

value_type * gko::batch::MultiVector< ValueType >::get_values_for_item | ( | size_type | batch_id | ) |
| inlinenoexcept

Returns a pointer to the array of values of the multi-vector for a specific batch item.

Parameters

  batch_id | the id of the batch item.

Returns
  the pointer to the array of values

References get_cumulative_offset(), and get_num_batch_items().

## ◆ scale()

template<typename ValueType = default_precision>

void gko::batch::MultiVector< ValueType >::scale | ( | ptr_param< const MultiVector< ValueType > > | alpha | ) |

Scales the vector with a scalar (aka: BLAS scal).

Parameters

  alpha | the scalar

Note
  If alpha is 1x1 MultiVector matrix, the entire multi-vector (all batches) is scaled by alpha. If it is a MultiVector row vector of values, then i-th column of the vector is scaled with the i-th element of alpha (the number of columns of alpha has to match the number of columns of the multi-vector). If it is a MultiVector of the same size as this, then an element wise scaling is performed.

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

- ginkgo/core/base/batch_multi_vector.hpp