#include <batmat/matrix/view.hpp>

Detailed Description

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>
struct batmat::matrix::View< T, I, S, D, L, O >

Non-owning view of a batch of matrices.

Template Parameters

T	Element value type (possibly const-qualified).
I	Index and size type. Usually std::ptrdiff_t or int.
S	Inner stride type (batch size). Usually std::integral_constant<I, N> for some N.
D	Batch depth type. Usually equal to `S` for a single batch, or `I` for a dynamic depth.
L	Layer stride type. Usually DefaultStride (which implies that the layer stride is equal to outer_stride() * outer_size()), or `I` for a dynamic layer stride. Dynamic strides are used for subviews of views with a larger outer_size().
O	Storage order (column or row major).

Definition at line 32 of file view.hpp.

Batch-wise slicing
batch_view_type	batch (index_type b) const
	Access a batch of batch_size() layers, starting at batch index `b` (i.e.
View< T, I, S, I, L, O >	batch_dyn (index_type b) const
	Same as batch(), but returns a view with a dynamic batch size.
template<class N>
View< T, I, S, N, L, O >	first_layers (N n) const
	Get a view of the first `n` layers. Note that `n` can be a compile-time constant.
template<class N>
View< T, I, S, N, L, O >	middle_layers (index_type l, N n) const
	Get a view of `n` layers starting at layer `l`.

Iterators and buffer access
T *	data () const
	Get a pointer to the first element of the first layer.
linear_iterator	begin () const
	Iterate linearly (in storage order) over all elements of the view.
std::default_sentinel_t	end () const
	Sentinel for begin().

Dimensions and strides
constexpr index_type	size () const
	Total number of elements in the view (excluding padding).
constexpr index_type	padded_size () const
	Total number of elements in the view (including all padding).
constexpr depth_type	depth () const
	Number of layers in the view (i.e. depth).
constexpr index_type	ceil_depth () const
	The depth rounded up to a multiple of the batch size.
constexpr index_type	num_batches () const
	Number of batches in the view, i.e. ceil_depth() / batch_size().
constexpr index_type	rows () const
	Number of rows of the matrices.
constexpr index_type	cols () const
	Number of columns of the matrices.
constexpr index_type	outer_stride () const
	Outer stride of the matrices (leading dimension in BLAS parlance).
constexpr index_type	outer_size () const
	The size of the outer dimension, i.e.
constexpr index_type	inner_size () const
	The size of the inner dimension, i.e.
constexpr index_type	inner_stride () const
	The inner stride of the matrices.
constexpr batch_size_type	batch_size () const
	The batch size, i.e. the number of layers in each batch. Equals the inner stride.
constexpr index_type	layer_stride () const
	The layer stride, i.e.
constexpr bool	has_full_layer_stride () const
	Whether the layer_stride() == outer_stride() * outer_size().
constexpr bool	has_full_outer_stride () const
	Whether the outer_stride() == inner_stride() * inner_size().
constexpr bool	has_full_inner_stride () const
	Whether the inner_stride() == 1. Always true.

Reshaping and slicing
general_slice_view_type	reshaped (index_type rows, index_type cols) const
	Reshape the view to the given dimensions. The total size should not change.
row_slice_view_type	top_rows (index_type n) const
	Get a view of the first `n` rows.
col_slice_view_type	left_cols (index_type n) const
	Get a view of the first `n` columns.
row_slice_view_type	bottom_rows (index_type n) const
	Get a view of the last `n` rows.
col_slice_view_type	right_cols (index_type n) const
	Get a view of the last `n` columns.
row_slice_view_type	middle_rows (index_type r, index_type n) const
	Get a view of `n` rows starting at row `r`.
col_slice_view_type	middle_cols (index_type c, index_type n) const
	Get a view of `n` columns starting at column `c`.
general_slice_view_type	top_left (index_type nr, index_type nc) const
	Get a view of the top-left `nr` by `nc` block of the matrices.
general_slice_view_type	top_right (index_type nr, index_type nc) const
	Get a view of the top-right `nr` by `nc` block of the matrices.
general_slice_view_type	bottom_left (index_type nr, index_type nc) const
	Get a view of the bottom-left `nr` by `nc` block of the matrices.
general_slice_view_type	bottom_right (index_type nr, index_type nc) const
	Get a view of the bottom-right `nr` by `nc` block of the matrices.
general_slice_view_type	block (index_type r, index_type c, index_type nr, index_type nc) const
	Get a view of the `nr` by `nc` block of the matrices starting at row `r` and column `c`.
auto	transposed () const
	Get a transposed view of the matrices.
static View	as_column (std::span< T > v)
	Get a view of the given span as a column vector.

Value manipulation
void	add_to_diagonal (const value_type &t)
void	set_constant (value_type t)
void	negate ()
template<class Other>
void	copy_values (const Other &other) const
View &	operator= (const View &other)
	Copy assignment copies the values from another view with the same layout to this view.
template<class U, class J, class R, class E, class M>
View &	operator= (View< U, J, R, E, M, O > other)
	Copy values from another view with a compatible value type and the same layout to this view.
template<class U, class J, class R, class E, class M>
View &	operator+= (View< U, J, R, E, M, O > other)

Classes
struct	PlainBatchedMatrixView
	POD helper struct to enable designated initializers during construction. More...
struct	linear_iterator
	Iterator over all elements of a view. More...

Public Types
using	layout_type = Layout<I, S, D, L, O>
using	value_type = T
using	index_type = typename layout_type::index_type
using	batch_size_type = typename layout_type::batch_size_type
using	depth_type = typename layout_type::depth_type
using	layer_stride_type = typename layout_type::layer_stride_type
using	standard_stride_type = typename layout_type::standard_stride_type
using	const_view_type = View<const T, I, S, D, L, O>
using	batch_view_type = View<T, I, S, S, DefaultStride, O>
	When extracing a single batch, the depth equals the batch size, and the layer stride is no longer relevant.
using	general_slice_view_type
	When slicing along the outer dimension, the layer stride stays the same, but the outer size may be smaller, which means that even if the original view has a default layer stride, the sliced view may require a dynamic layer stride.
using	col_slice_view_type = std::conditional_t<is_row_major, View, general_slice_view_type>
	View with the correct layer stride when slicing along the column dimension.
using	row_slice_view_type = std::conditional_t<is_column_major, View, general_slice_view_type>
	View with the correct layer stride when slicing along the row dimension.

Public Member Functions
constexpr	View (PlainBatchedMatrixView p={})
	Create a new view.
constexpr	View (std::span< T > data, layout_type layout)
	Create a new view with the given layout, using the given buffer.
constexpr	View (value_type *data, layout_type layout)
	Create a new view with the given layout, using the given buffer.
	View (const View &)=default
	Copy a view. No data is copied.
	operator const_view_type () const
	Non-const views implicitly convert to const views.
const_view_type	as_const () const
	Explicit conversion to a const view.
	operator guanaqo::MatrixView< T, I, standard_stride_type, O > () const
	If we have a single layer at compile time, we can implicitly convert to a non-batched view.
guanaqo::MatrixView< T, I, standard_stride_type, O >	operator() (index_type l) const
	Access a single layer `l` as a non-batched view.
value_type &	operator() (index_type l, index_type r, index_type c) const
	Access a single element at layer `l`, row `r` and column `c`.
View &	reassign (View other)
	Reassign the buffer and layout of this view to those of another view. No data is copied.
	operator View< T, I, S, integral_value_type_t< D >, L, O > () const
	Implicit conversion to a view with a dynamic depth.
	operator View< const T, I, S, integral_value_type_t< D >, L, O > () const
	Implicit conversion to a view with a dynamic depth, going from non-const to const.
	operator View< T, I, S, D, I, O > () const
	Implicit conversion to a view with a dynamic layer stride.
	operator View< const T, I, S, D, I, O > () const
	Implicit conversion to a view with a dynamic layer stride, going from non-const to const.

Public Attributes
value_type *	data_ptr
	Pointer to the first element of the first layer.
layout_type	layout
	Layout describing the dimensions and strides of the view.

Static Public Attributes
static constexpr StorageOrder	storage_order = layout_type::storage_order
static constexpr bool	is_column_major = layout_type::is_column_major
static constexpr bool	is_row_major = layout_type::is_row_major
static constexpr bool	has_single_batch_at_compile_time
	True if batch_size() and depth() are compile-time constants and are equal.
static constexpr bool	has_single_layer_at_compile_time = requires { D::value; } && D{} == 1
	True if depth() is a compile-time constant and is equal to one.

Private Member Functions
template<class V>
constexpr auto	get_layer_stride_for () const

Class Documentation

◆ batmat::matrix::View::PlainBatchedMatrixView

struct batmat::matrix::View::PlainBatchedMatrixView

Class Members
value_type *	data = nullptr
depth_type	depth = guanaqo::default_stride<depth_type>::value
index_type	rows = 0
index_type	cols = rows == 0 ? 0 : 1
index_type	outer_stride = is_row_major ? cols : rows
batch_size_type	batch_size
layer_stride_type	layer_stride

Member Typedef Documentation

◆ layout_type

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

using batmat::matrix::View< T, I, S, D, L, O >::layout_type = Layout<I, S, D, L, O>

Definition at line 33 of file view.hpp.

◆ value_type

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

using batmat::matrix::View< T, I, S, D, L, O >::value_type = T

Definition at line 34 of file view.hpp.

◆ index_type

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

using batmat::matrix::View< T, I, S, D, L, O >::index_type = typename layout_type::index_type

Definition at line 35 of file view.hpp.

◆ batch_size_type

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

using batmat::matrix::View< T, I, S, D, L, O >::batch_size_type = typename layout_type::batch_size_type

Definition at line 36 of file view.hpp.

◆ depth_type

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

using batmat::matrix::View< T, I, S, D, L, O >::depth_type = typename layout_type::depth_type

Definition at line 37 of file view.hpp.

◆ layer_stride_type

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

using batmat::matrix::View< T, I, S, D, L, O >::layer_stride_type = typename layout_type::layer_stride_type

Definition at line 38 of file view.hpp.

◆ standard_stride_type

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

using batmat::matrix::View< T, I, S, D, L, O >::standard_stride_type = typename layout_type::standard_stride_type

Definition at line 39 of file view.hpp.

◆ const_view_type

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

using batmat::matrix::View< T, I, S, D, L, O >::const_view_type = View<const T, I, S, D, L, O>

Definition at line 40 of file view.hpp.

◆ batch_view_type

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

using batmat::matrix::View< T, I, S, D, L, O >::batch_view_type = View<T, I, S, S, DefaultStride, O>

When extracing a single batch, the depth equals the batch size, and the layer stride is no longer relevant.

Definition at line 56 of file view.hpp.

◆ general_slice_view_type

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

using batmat::matrix::View< T, I, S, D, L, O >::general_slice_view_type

Initial value:

std::conditional_t<has_single_batch_at_compile_time, View, View<T, I, S, D, I, O>>

When slicing along the outer dimension, the layer stride stays the same, but the outer size may be smaller, which means that even if the original view has a default layer stride, the sliced view may require a dynamic layer stride.

For a single batch, the layer stride is not relevant, so it is preserved.

Definition at line 61 of file view.hpp.

◆ col_slice_view_type

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

using batmat::matrix::View< T, I, S, D, L, O >::col_slice_view_type = std::conditional_t<is_row_major, View, general_slice_view_type>

View with the correct layer stride when slicing along the column dimension.

For row-major storage, slicing along columns does not change the outer size, in which case the layer stride is still correct. For column-major storage, slicing along columns does change the outer size, in which case we need a dynamic layer stride.

Definition at line 67 of file view.hpp.

◆ row_slice_view_type

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

using batmat::matrix::View< T, I, S, D, L, O >::row_slice_view_type = std::conditional_t<is_column_major, View, general_slice_view_type>

View with the correct layer stride when slicing along the row dimension.

See also: col_slice_view_type

Definition at line 70 of file view.hpp.

Constructor & Destructor Documentation

◆ View() [1/4]

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

batmat::matrix::View< T, I, S, D, L, O >::View ( PlainBatchedMatrixView< T, I, S, D, L, O > p = {} )

inlineconstexpr

Create a new view.

Note: It is recommended to use designated initializers for the arguments to avoid mistakes.

Definition at line 92 of file view.hpp.

◆ View() [2/4]

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

batmat::matrix::View< T, I, S, D, L, O >::View	(	std::span< T >	data,
		layout_type	layout )

inlineconstexpr

Create a new view with the given layout, using the given buffer.

Definition at line 100 of file view.hpp.

◆ View() [3/4]

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

batmat::matrix::View< T, I, S, D, L, O >::View	(	value_type *	data,
		layout_type	layout )

inlineconstexpr

Create a new view with the given layout, using the given buffer.

Definition at line 104 of file view.hpp.

◆ View() [4/4]

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

batmat::matrix::View< T, I, S, D, L, O >::View ( const View< T, I, S, D, L, O > & )

default

Copy a view. No data is copied.

Member Function Documentation

◆ operator const_view_type()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

batmat::matrix::View< T, I, S, D, L, O >::operator const_view_type ( ) const

inline

Non-const views implicitly convert to const views.

Definition at line 110 of file view.hpp.

◆ as_const()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

const_view_type batmat::matrix::View< T, I, S, D, L, O >::as_const ( ) const

inlinenodiscard

Explicit conversion to a const view.

Definition at line 116 of file view.hpp.

◆ operator guanaqo::MatrixView< T, I, standard_stride_type, O >()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

batmat::matrix::View< T, I, S, D, L, O >::operator guanaqo::MatrixView< T, I, standard_stride_type, O > ( ) const

inline

If we have a single layer at compile time, we can implicitly convert to a non-batched view.

Definition at line 119 of file view.hpp.

◆ operator()() [1/2]

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

guanaqo::MatrixView< T, I, standard_stride_type, O > batmat::matrix::View< T, I, S, D, L, O >::operator() ( index_type l ) const

inlinenodiscard

Access a single layer l as a non-batched view.

Note: The inner stride of the returned view is equal to the batch size of this view, so it cannot be used directly with functions that require unit inner stride (e.g. BLAS).

Definition at line 129 of file view.hpp.

◆ operator()() [2/2]

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

value_type & batmat::matrix::View< T, I, S, D, L, O >::operator()	(	index_type	l,
		index_type	r,
		index_type	c ) const

inlinenodiscard

Access a single element at layer l, row r and column c.

Definition at line 134 of file view.hpp.

◆ batch()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

batch_view_type batmat::matrix::View< T, I, S, D, L, O >::batch ( index_type b ) const

inlinenodiscard

Access a batch of batch_size() layers, starting at batch index b (i.e.

starting at layer b * batch_size()).

Definition at line 143 of file view.hpp.

◆ batch_dyn()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

View< T, I, S, I, L, O > batmat::matrix::View< T, I, S, D, L, O >::batch_dyn ( index_type b ) const

inlinenodiscard

Same as batch(), but returns a view with a dynamic batch size.

If the total depth is not a multiple of the batch size, the last batch will have a smaller size.

Definition at line 155 of file view.hpp.

◆ first_layers()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

template<class N>

View< T, I, S, N, L, O > batmat::matrix::View< T, I, S, D, L, O >::first_layers ( N n ) const

inlinenodiscard

Get a view of the first n layers. Note that n can be a compile-time constant.

Definition at line 170 of file view.hpp.

◆ middle_layers()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

template<class N>

View< T, I, S, N, L, O > batmat::matrix::View< T, I, S, D, L, O >::middle_layers	(	index_type	l,
		N	n ) const

inlinenodiscard

Get a view of n layers starting at layer l.

Note that n can be a compile-time constant.

Precondition: l % batch_size() == 0 (i.e. the starting layer must be at the start of a batch).

Definition at line 185 of file view.hpp.

◆ data()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

T * batmat::matrix::View< T, I, S, D, L, O >::data ( ) const

inline

Get a pointer to the first element of the first layer.

Definition at line 203 of file view.hpp.

◆ begin()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

linear_iterator batmat::matrix::View< T, I, S, D, L, O >::begin ( ) const

inlinenodiscard

Iterate linearly (in storage order) over all elements of the view.

Precondition: has_full_outer_stride() (i.e. no padding within layers).; has_full_layer_stride() (i.e. no padding between batches).

Definition at line 236 of file view.hpp.

◆ end()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

std::default_sentinel_t batmat::matrix::View< T, I, S, D, L, O >::end ( ) const

inlinenodiscard

Sentinel for begin().

Definition at line 263 of file view.hpp.

◆ size()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

index_type batmat::matrix::View< T, I, S, D, L, O >::size ( ) const

inlinenodiscardconstexpr

Total number of elements in the view (excluding padding).

Definition at line 269 of file view.hpp.

◆ padded_size()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

index_type batmat::matrix::View< T, I, S, D, L, O >::padded_size ( ) const

inlinenodiscardconstexpr

Total number of elements in the view (including all padding).

Definition at line 271 of file view.hpp.

◆ depth()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

depth_type batmat::matrix::View< T, I, S, D, L, O >::depth ( ) const

inlinenodiscardconstexpr

Number of layers in the view (i.e. depth).

Definition at line 274 of file view.hpp.

◆ ceil_depth()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

index_type batmat::matrix::View< T, I, S, D, L, O >::ceil_depth ( ) const

inlinenodiscardconstexpr

The depth rounded up to a multiple of the batch size.

Definition at line 276 of file view.hpp.

◆ num_batches()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

index_type batmat::matrix::View< T, I, S, D, L, O >::num_batches ( ) const

inlinenodiscardconstexpr

Number of batches in the view, i.e. ceil_depth() / batch_size().

Definition at line 280 of file view.hpp.

◆ rows()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

index_type batmat::matrix::View< T, I, S, D, L, O >::rows ( ) const

inlinenodiscardconstexpr

Number of rows of the matrices.

Definition at line 284 of file view.hpp.

◆ cols()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

index_type batmat::matrix::View< T, I, S, D, L, O >::cols ( ) const

inlinenodiscardconstexpr

Number of columns of the matrices.

Definition at line 286 of file view.hpp.

◆ outer_stride()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

index_type batmat::matrix::View< T, I, S, D, L, O >::outer_stride ( ) const

inlinenodiscardconstexpr

Outer stride of the matrices (leading dimension in BLAS parlance).

Should be multiplied by the batch size to get the actual number of elements.

Definition at line 289 of file view.hpp.

◆ outer_size()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

index_type batmat::matrix::View< T, I, S, D, L, O >::outer_size ( ) const

inlinenodiscardconstexpr

The size of the outer dimension, i.e.

the number of columns for column-major storage, or the number of rows for row-major storage.

Definition at line 294 of file view.hpp.

◆ inner_size()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

index_type batmat::matrix::View< T, I, S, D, L, O >::inner_size ( ) const

inlinenodiscardconstexpr

The size of the inner dimension, i.e.

the number of rows for column-major storage, or the number of columns for row-major storage.

Definition at line 299 of file view.hpp.

◆ inner_stride()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

index_type batmat::matrix::View< T, I, S, D, L, O >::inner_stride ( ) const

inlinenodiscardconstexpr

The inner stride of the matrices.

Should be multiplied by the batch size to get the actual number of elements.

Definition at line 304 of file view.hpp.

◆ batch_size()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

batch_size_type batmat::matrix::View< T, I, S, D, L, O >::batch_size ( ) const

inlinenodiscardconstexpr

The batch size, i.e. the number of layers in each batch. Equals the inner stride.

Definition at line 306 of file view.hpp.

◆ layer_stride()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

index_type batmat::matrix::View< T, I, S, D, L, O >::layer_stride ( ) const

inlinenodiscardconstexpr

The layer stride, i.e.

the distance between the first layer of one batch and the first layer of the next batch. Should be multiplied by the batch size to get the actual number of elements.

Definition at line 312 of file view.hpp.

◆ has_full_layer_stride()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

bool batmat::matrix::View< T, I, S, D, L, O >::has_full_layer_stride ( ) const

inlinenodiscardconstexpr

Whether the layer_stride() == outer_stride() * outer_size().

Definition at line 316 of file view.hpp.

◆ has_full_outer_stride()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

bool batmat::matrix::View< T, I, S, D, L, O >::has_full_outer_stride ( ) const

inlinenodiscardconstexpr

Whether the outer_stride() == inner_stride() * inner_size().

Definition at line 320 of file view.hpp.

◆ has_full_inner_stride()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

bool batmat::matrix::View< T, I, S, D, L, O >::has_full_inner_stride ( ) const

inlinenodiscardconstexpr

Whether the inner_stride() == 1. Always true.

Definition at line 324 of file view.hpp.

◆ get_layer_stride_for()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

template<class V>

auto batmat::matrix::View< T, I, S, D, L, O >::get_layer_stride_for ( ) const

inlineconstexprprivate

Definition at line 332 of file view.hpp.

◆ reshaped()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

general_slice_view_type batmat::matrix::View< T, I, S, D, L, O >::reshaped	(	index_type	rows,
		index_type	cols ) const

inlinenodiscard

Reshape the view to the given dimensions. The total size should not change.

Definition at line 344 of file view.hpp.

◆ top_rows()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

row_slice_view_type batmat::matrix::View< T, I, S, D, L, O >::top_rows ( index_type n ) const

inlinenodiscard

Get a view of the first n rows.

Definition at line 358 of file view.hpp.

◆ left_cols()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

col_slice_view_type batmat::matrix::View< T, I, S, D, L, O >::left_cols ( index_type n ) const

inlinenodiscard

Get a view of the first n columns.

Definition at line 371 of file view.hpp.

◆ bottom_rows()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

row_slice_view_type batmat::matrix::View< T, I, S, D, L, O >::bottom_rows ( index_type n ) const

inlinenodiscard

Get a view of the last n rows.

Definition at line 384 of file view.hpp.

◆ right_cols()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

col_slice_view_type batmat::matrix::View< T, I, S, D, L, O >::right_cols ( index_type n ) const

inlinenodiscard

Get a view of the last n columns.

Definition at line 399 of file view.hpp.

◆ middle_rows()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

row_slice_view_type batmat::matrix::View< T, I, S, D, L, O >::middle_rows	(	index_type	r,
		index_type	n ) const

inlinenodiscard

Get a view of n rows starting at row r.

Definition at line 414 of file view.hpp.

◆ middle_cols()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

col_slice_view_type batmat::matrix::View< T, I, S, D, L, O >::middle_cols	(	index_type	c,
		index_type	n ) const

inlinenodiscard

Get a view of n columns starting at column c.

Definition at line 419 of file view.hpp.

◆ top_left()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

general_slice_view_type batmat::matrix::View< T, I, S, D, L, O >::top_left	(	index_type	nr,
		index_type	nc ) const

inlinenodiscard

Get a view of the top-left nr by nc block of the matrices.

Definition at line 424 of file view.hpp.

◆ top_right()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

general_slice_view_type batmat::matrix::View< T, I, S, D, L, O >::top_right	(	index_type	nr,
		index_type	nc ) const

inlinenodiscard

Get a view of the top-right nr by nc block of the matrices.

Definition at line 429 of file view.hpp.

◆ bottom_left()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

general_slice_view_type batmat::matrix::View< T, I, S, D, L, O >::bottom_left	(	index_type	nr,
		index_type	nc ) const

inlinenodiscard

Get a view of the bottom-left nr by nc block of the matrices.

Definition at line 434 of file view.hpp.

◆ bottom_right()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

general_slice_view_type batmat::matrix::View< T, I, S, D, L, O >::bottom_right	(	index_type	nr,
		index_type	nc ) const

inlinenodiscard

Get a view of the bottom-right nr by nc block of the matrices.

Definition at line 439 of file view.hpp.

◆ block()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

general_slice_view_type batmat::matrix::View< T, I, S, D, L, O >::block	(	index_type	r,
		index_type	c,
		index_type	nr,
		index_type	nc ) const

inlinenodiscard

Get a view of the nr by nc block of the matrices starting at row r and column c.

Definition at line 444 of file view.hpp.

◆ as_column()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

View batmat::matrix::View< T, I, S, D, L, O >::as_column ( std::span< T > v )

inlinestaticnodiscard

Get a view of the given span as a column vector.

Definition at line 450 of file view.hpp.

◆ transposed()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

auto batmat::matrix::View< T, I, S, D, L, O >::transposed ( ) const

inlinenodiscard

Get a transposed view of the matrices.

Note that the data itself is not modified, the returned view simply accesses the same data with rows and column indices swapped.

Definition at line 456 of file view.hpp.

◆ add_to_diagonal()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

void batmat::matrix::View< T, I, S, D, L, O >::add_to_diagonal ( const value_type & t )

inline

Definition at line 472 of file view.hpp.

◆ set_constant()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

void batmat::matrix::View< T, I, S, D, L, O >::set_constant ( value_type t )

inline

Definition at line 485 of file view.hpp.

◆ negate()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

void batmat::matrix::View< T, I, S, D, L, O >::negate ( )

inline

Definition at line 499 of file view.hpp.

◆ copy_values()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

template<class Other>

void batmat::matrix::View< T, I, S, D, L, O >::copy_values ( const Other & other ) const

inline

Definition at line 514 of file view.hpp.

◆ operator=() [1/2]

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

View & batmat::matrix::View< T, I, S, D, L, O >::operator= ( const View< T, I, S, D, L, O > & other )

inline

Copy assignment copies the values from another view with the same layout to this view.

Definition at line 536 of file view.hpp.

◆ operator=() [2/2]

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

template<class U, class J, class R, class E, class M>

View & batmat::matrix::View< T, I, S, D, L, O >::operator= ( View< U, J, R, E, M, O > other )

inline

Copy values from another view with a compatible value type and the same layout to this view.

Definition at line 545 of file view.hpp.

◆ operator+=()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

template<class U, class J, class R, class E, class M>

View & batmat::matrix::View< T, I, S, D, L, O >::operator+= ( View< U, J, R, E, M, O > other )

inline

Definition at line 553 of file view.hpp.

◆ reassign()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

View & batmat::matrix::View< T, I, S, D, L, O >::reassign ( View< T, I, S, D, L, O > other )

inline

Reassign the buffer and layout of this view to those of another view. No data is copied.

Definition at line 577 of file view.hpp.

◆ operator View< T, I, S, integral_value_type_t< D >, L, O >()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

batmat::matrix::View< T, I, S, D, L, O >::operator View< T, I, S, integral_value_type_t< D >, L, O > ( ) const

inline

Implicit conversion to a view with a dynamic depth.

Definition at line 584 of file view.hpp.

◆ operator View< const T, I, S, integral_value_type_t< D >, L, O >()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

batmat::matrix::View< T, I, S, D, L, O >::operator View< const T, I, S, integral_value_type_t< D >, L, O > ( ) const

inline

Implicit conversion to a view with a dynamic depth, going from non-const to const.

Definition at line 597 of file view.hpp.

◆ operator View< T, I, S, D, I, O >()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

batmat::matrix::View< T, I, S, D, L, O >::operator View< T, I, S, D, I, O > ( ) const

inline

Implicit conversion to a view with a dynamic layer stride.

Definition at line 610 of file view.hpp.

◆ operator View< const T, I, S, D, I, O >()

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

batmat::matrix::View< T, I, S, D, L, O >::operator View< const T, I, S, D, I, O > ( ) const

inline

Implicit conversion to a view with a dynamic layer stride, going from non-const to const.

Definition at line 622 of file view.hpp.

Member Data Documentation

◆ storage_order

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

StorageOrder batmat::matrix::View< T, I, S, D, L, O >::storage_order = layout_type::storage_order

staticconstexpr

Definition at line 41 of file view.hpp.

◆ is_column_major

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

bool batmat::matrix::View< T, I, S, D, L, O >::is_column_major = layout_type::is_column_major

staticconstexpr

Definition at line 42 of file view.hpp.

◆ is_row_major

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

bool batmat::matrix::View< T, I, S, D, L, O >::is_row_major = layout_type::is_row_major

staticconstexpr

Definition at line 43 of file view.hpp.

◆ has_single_batch_at_compile_time

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

bool batmat::matrix::View< T, I, S, D, L, O >::has_single_batch_at_compile_time

staticconstexpr

Initial value:

                                                       = requires {
    S::value;
    D::value;
} && S{} == D{}

True if batch_size() and depth() are compile-time constants and are equal.

Note: Views with dynamic batch size and depth may still have a single batch at runtime, but this cannot be statically asserted.

Definition at line 48 of file view.hpp.

◆ has_single_layer_at_compile_time

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

bool batmat::matrix::View< T, I, S, D, L, O >::has_single_layer_at_compile_time = requires { D::value; } && D{} == 1

staticconstexpr

True if depth() is a compile-time constant and is equal to one.

Definition at line 53 of file view.hpp.

◆ data_ptr

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

value_type* batmat::matrix::View< T, I, S, D, L, O >::data_ptr

Pointer to the first element of the first layer.

Definition at line 73 of file view.hpp.

◆ layout

template<class T, class I = index_t, class S = std::integral_constant<I, 1>, class D = I, class L = DefaultStride, StorageOrder O = StorageOrder::ColMajor>

layout_type batmat::matrix::View< T, I, S, D, L, O >::layout

Layout describing the dimensions and strides of the view.

Definition at line 75 of file view.hpp.

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

batmat/include/batmat/matrix/view.hpp

Detailed Description

Batch-wise slicing

Iterators and buffer access

Dimensions and strides

Reshaping and slicing

Value manipulation

Classes

Public Types

Public Member Functions

Public Attributes

Static Public Attributes

Private Member Functions

Class Documentation

◆ batmat::matrix::View::PlainBatchedMatrixView

Member Typedef Documentation

◆ layout_type

◆ value_type

◆ index_type

◆ batch_size_type

◆ depth_type

◆ layer_stride_type

◆ standard_stride_type

◆ const_view_type

◆ batch_view_type

◆ general_slice_view_type

◆ col_slice_view_type

◆ row_slice_view_type

Constructor & Destructor Documentation

◆ View() [1/4]

◆ View() [2/4]

◆ View() [3/4]

◆ View() [4/4]

Member Function Documentation

◆ operator const_view_type()

◆ as_const()

◆ operator guanaqo::MatrixView< T, I, standard_stride_type, O >()

◆ operator()() [1/2]

◆ operator()() [2/2]

◆ batch()

◆ batch_dyn()

◆ first_layers()

◆ middle_layers()

◆ data()

◆ begin()

◆ end()

◆ size()

◆ padded_size()

◆ depth()

◆ ceil_depth()

◆ num_batches()

◆ rows()

◆ cols()

◆ outer_stride()

◆ outer_size()

◆ inner_size()

◆ inner_stride()

◆ batch_size()

◆ layer_stride()

◆ has_full_layer_stride()

◆ has_full_outer_stride()

◆ has_full_inner_stride()

◆ get_layer_stride_for()

◆ reshaped()

◆ top_rows()

◆ left_cols()

◆ bottom_rows()

◆ right_cols()

◆ middle_rows()

◆ middle_cols()

◆ top_left()

◆ top_right()

◆ bottom_left()

◆ bottom_right()

◆ block()

◆ as_column()

◆ transposed()

◆ add_to_diagonal()

◆ set_constant()

◆ negate()

◆ copy_values()