Lightweight wrapper that provides a view of a tensor. More...

#include <TensorView.h>

Public Member Functions
	TensorView (std::span< const T > data, std::vector< std::size_t > dims)
	Construct a new Tensor object.

TensorView &	reshape (std::vector< std::size_t > dims)
	Reshape the tensor to the new dimensions.

template<IsAnyOf< int, float, double, std::complex< double > > TT>
void	permute (TensorView< TT > &out, const std::vector< std::size_t > &permutation) const
	Permute the axes of the tensor.

template<IsAnyOf< int, float, double, std::complex< double > > TT, std::convertible_to< const std::size_t > I, class... Is>
void	permute (TensorView< TT > &out, I i, Is... is) const
	Permute the axes of the tensor.

template<std::convertible_to< const std::size_t > I, class... Is>
const T &	operator() (I i, Is... is) const
	Get the element in the tensor using the indices in each dimension.

template<std::convertible_to< const std::size_t > I, class... Is>
T &	operator() (I i, Is... is)
	Get the element in the tensor using the indices in each dimension.

template<template< class... > class Container, std::convertible_to< const std::size_t > I>
const T &	operator() (const Container< I > &indices) const
	Get the element in the tensor using the indices in each dimension.

template<template< class... > class Container, std::convertible_to< const std::size_t > I>
T &	operator() (const Container< I > &indices)
	Get the element in the tensor using the indices in each dimension.

template<std::convertible_to< const std::size_t > I>
const T &	operator[] (I i) const
	Get the element in the underlying data vector using its index.

std::size_t	size () const
	Get read-only access to the size of the tensor.

std::size_t	rank () const
	Get read-only access to the rank of the tensor.

const std::vector< std::size_t > &	axes () const
	Get read-only access to the axes of the tensor.

const std::vector< std::size_t > &	dimensions () const
	Get read-only access to the dimensions of the tensor.

const std::span< const T > &	data () const
	Get read-only access to the data of the tensor.

std::span< T >	m_data ()
	Get read-only access to the data of the tensor.

TensorIterator< T >	begin () const
	Get read-only access to the iterator pointing at the beginning of the tensor.

TensorIterator< T >	end () const
	Get read-only access to the iterator pointing at the end of the tensor.

void	fft (TensorView< std::complex< double > > &out, double coeff=std::numeric_limits< double >::quiet_NaN()) const
	Apply the Fast Fourier Transform to the tensor.

void	ifft (TensorView< double > &out, double coeff=std::numeric_limits< double >::quiet_NaN()) const
	Apply the Inverse Fast Fourier Transform to the tensor.

void	ifft (TensorView< std::complex< double > > &out, double coeff=std::numeric_limits< double >::quiet_NaN()) const
	Apply the Inverse Fast Fourier Transform to the tensor.

void	pad (TensorView< T > &out, const std::vector< std::pair< Index, Index > > &padding) const
	Pad the tensor with a value.

void	pad (TensorView< T > &out, const std::vector< Index > &padding, const std::vector< Index > &start_padding) const
	Pad the tensor with a value.

void	fft_upsample (TensorView< double > &out) const
	Use the Fast Fourier Transform to upsample the tensor.

template<IsAnyOf< int, float, double, std::complex< double > > TT>
void	copy (TensorView< TT > &out) const
	Copy the tensor to another tensor.

Private Member Functions
template<int Dim, std::convertible_to< const std::size_t > I, class... Is>
Index	index (I i, Is... is) const
	Get the linear index of an element in the data vector using the indices in each dimension.

template<std::convertible_to< const std::size_t > I>
std::size_t	index (std::span< const I > indices) const
	Get the linear index of an element in the data vector using the indices in each dimension.

Private Attributes
std::span< const T >	data_
	Data of the tensor.

std::vector< std::size_t >	dims_
	Shape of the tensor. Each element is the size of the corresponding dimension.

std::vector< std::size_t >	axes_
	Axes of the tensor. Goes from 0 to rank - 1.

std::vector< Index >	strides_
	Strides of the tensor. Used to calculate the index of an element.

Detailed Description

template<IsAnyOf< int, float, double, std::complex< double > > T>
class lucid::TensorView< T >

Lightweight wrapper that provides a view of a tensor.

It uses a strided vector to support any number of dimensions.

Note: Most methods in this class contain the implementation of methods in the Tensor class. Check its documentation for more information about the corresponding methods.

Warning: The data is not copied, so it must be kept alive and unchanged while the tensor is in use. If you need an owning data structure, use the Tensor class instead.

Template Parameters

T	type of the elements in the tensor

Constructor & Destructor Documentation

◆ TensorView()

template<IsAnyOf< int, float, double, std::complex< double > > T>

lucid::TensorView< T >::TensorView	(	std::span< const T >	data,
		std::vector< std::size_t >	dims )

Construct a new Tensor object.

The rank of the tensor is determined by the size of the dimensions vector.

Parameters

data	data of the tensor
dims	shape of the tensor. Each element is the size of the corresponding dimension

Member Function Documentation

◆ axes()

template<IsAnyOf< int, float, double, std::complex< double > > T>

const std::vector< std::size_t > & lucid::TensorView< T >::axes ( ) const

inlinenodiscard

Get read-only access to the axes of the tensor.

Returns: axes of the tensor

◆ begin()

template<IsAnyOf< int, float, double, std::complex< double > > T>

TensorIterator< T > lucid::TensorView< T >::begin ( ) const

nodiscard

Get read-only access to the iterator pointing at the beginning of the tensor.

Returns: iterator pointing at the beginning of the tensor

◆ copy()

template<IsAnyOf< int, float, double, std::complex< double > > T>

template<IsAnyOf< int, float, double, std::complex< double > > TT>

template void lucid::TensorView< T >::copy ( TensorView< TT > & out ) const

Copy the tensor to another tensor.

This method also allows to cast the tensor to another type.

Precondition: The out tensor must have enough space to accommodate the data

Parameters

out	permuted output tensor

◆ data()

template<IsAnyOf< int, float, double, std::complex< double > > T>

const std::span< const T > & lucid::TensorView< T >::data ( ) const

inlinenodiscard

Get read-only access to the data of the tensor.

Returns: data of the tensor

◆ dimensions()

template<IsAnyOf< int, float, double, std::complex< double > > T>

const std::vector< std::size_t > & lucid::TensorView< T >::dimensions ( ) const

inlinenodiscard

Get read-only access to the dimensions of the tensor.

Returns: dimensions of the tensor

◆ end()

template<IsAnyOf< int, float, double, std::complex< double > > T>

TensorIterator< T > lucid::TensorView< T >::end ( ) const

nodiscard

Get read-only access to the iterator pointing at the end of the tensor.

Returns: iterator pointing at the end of the tensor

◆ fft()

template<IsAnyOf< int, float, double, std::complex< double > > T>

void lucid::TensorView< T >::fft	(	TensorView< std::complex< double > > &	out,
		double	coeff = std::numeric_limits<double>::quiet_NaN() ) const

Apply the Fast Fourier Transform to the tensor.

It is just the application of the FFT to each dimension of the tensor.

Precondition: The output tensor must have the same shape as the input tensor

Parameters

[out]	out	tensor with the FFT applied to each dimension
	coeff	coefficient applied to the FFT. If NaN, the default coefficient, 1.0, is used

See also: ifft

◆ fft_upsample()

template<IsAnyOf< int, float, double, std::complex< double > > T>

void lucid::TensorView< T >::fft_upsample ( TensorView< double > & out ) const

Use the Fast Fourier Transform to upsample the tensor.

This procedure will interpolate the signal in the frequency domain and then apply the inverse FFT.

Precondition: The out tensor must have the same shape as the input tensor plus a non-negative padding

Warning: If the functions making up the signal are not periodic or their frequency is too high (> Nyquist frequency), the result will not be inaccurate.

Parameters

[out[ out upsampled tensor

See also: fft; ifft

◆ ifft() [1/2]

template<IsAnyOf< int, float, double, std::complex< double > > T>

void lucid::TensorView< T >::ifft	(	TensorView< double > &	out,
		double	coeff = std::numeric_limits<double>::quiet_NaN() ) const

Apply the Inverse Fast Fourier Transform to the tensor.

It is just the application of the IFFT to each dimension of the tensor.

Precondition: The output tensor must have the same shape as the input tensor

Parameters

[out]	out	tensor with the IFFT applied to each dimension
	coeff	coefficient applied to the FFT. If NaN, the default coefficient, 1.0 / size(), is used

See also: fft

◆ ifft() [2/2]

template<IsAnyOf< int, float, double, std::complex< double > > T>

void lucid::TensorView< T >::ifft	(	TensorView< std::complex< double > > &	out,
		double	coeff = std::numeric_limits<double>::quiet_NaN() ) const

Apply the Inverse Fast Fourier Transform to the tensor.

It is just the application of the IFFT to each dimension of the tensor.

Precondition: The output tensor must have the same shape as the input tensor

Parameters

[out]	out	tensor with the IFFT applied to each dimension
	coeff	coefficient applied to the FFT. If NaN, the default coefficient, 1.0 / size(), is used

See also: fft

◆ index() [1/2]

template<IsAnyOf< int, float, double, std::complex< double > > T>

template<int Dim, std::convertible_to< const std::size_t > I, class... Is>

Index lucid::TensorView< T >::index	(	I	i,
		Is...	is ) const

inlinenodiscardprivate

Get the linear index of an element in the data vector using the indices in each dimension.

Template Parameters

Dim	index of the current dimension
I	index type
Is	variadic index types

Parameters

i	index in the current dimension
is	indices in the remaining dimensions

Returns: linear index of the element in the data vector

◆ index() [2/2]

template<IsAnyOf< int, float, double, std::complex< double > > T>

template<std::convertible_to< const std::size_t > I>

std::size_t lucid::TensorView< T >::index ( std::span< const I > indices ) const

inlinenodiscardprivate

Get the linear index of an element in the data vector using the indices in each dimension.

Template Parameters

I	index type

Parameters

indices indices in each dimension

Returns: linear index of the element in the data vector

◆ m_data()

template<IsAnyOf< int, float, double, std::complex< double > > T>

std::span< T > lucid::TensorView< T >::m_data ( )

inlinenodiscard

Get read-only access to the data of the tensor.

Returns: data of the tensor

◆ operator()() [1/4]

template<IsAnyOf< int, float, double, std::complex< double > > T>

template<template< class... > class Container, std::convertible_to< const std::size_t > I>

T & lucid::TensorView< T >::operator() ( const Container< I > & indices )

inline

Get the element in the tensor using the indices in each dimension.

Template Parameters

I	index type

Parameters

indices indices in each dimension

Returns: element in the tensor

◆ operator()() [2/4]

template<IsAnyOf< int, float, double, std::complex< double > > T>

template<template< class... > class Container, std::convertible_to< const std::size_t > I>

const T & lucid::TensorView< T >::operator() ( const Container< I > & indices ) const

inline

Get the element in the tensor using the indices in each dimension.

Template Parameters

I	index type

Parameters

indices indices in each dimension

Returns: element in the tensor

◆ operator()() [3/4]

template<IsAnyOf< int, float, double, std::complex< double > > T>

template<std::convertible_to< const std::size_t > I, class... Is>

T & lucid::TensorView< T >::operator()	(	I	i,
		Is...	is )

inline

Get the element in the tensor using the indices in each dimension.

Template Parameters

I	index type
Is	variadic index types

Parameters

i	index in the first dimension
is	indices in the remaining dimensions

Returns: element in the tensor

◆ operator()() [4/4]

template<IsAnyOf< int, float, double, std::complex< double > > T>

template<std::convertible_to< const std::size_t > I, class... Is>

const T & lucid::TensorView< T >::operator()	(	I	i,
		Is...	is ) const

inline

Get the element in the tensor using the indices in each dimension.

Template Parameters

I	index type
Is	variadic index types

Parameters

i	index in the first dimension
is	indices in the remaining dimensions

Returns: element in the tensor

◆ operator[]()

template<IsAnyOf< int, float, double, std::complex< double > > T>

template<std::convertible_to< const std::size_t > I>

const T & lucid::TensorView< T >::operator[] ( I i ) const

inline

Get the element in the underlying data vector using its index.

Note: This is not the same as the tensor index, rather the linearized index

Template Parameters

I	index type

Parameters

i	index in the data vector

Returns: element in the tensor

◆ pad() [1/2]

template<IsAnyOf< int, float, double, std::complex< double > > T>

void lucid::TensorView< T >::pad	(	TensorView< T > &	out,
		const std::vector< Index > &	padding,
		const std::vector< Index > &	start_padding ) const

Pad the tensor with a value.

The padding is applied to each dimension starting at the respective start_padding index. This allows the padding to be placed in the middle of the tensor.

Note: Setting start_padding to 0 (the size of that dimension) will place all the padding at the start (the end) of the dimension.

Precondition: The out tensor must have the same shape as the input tensor plus padding

Parameters

[out]	out	padded output tensor
	padding	padding for each dimension
	start_padding	the index where the padding starts for each dimension

◆ pad() [2/2]

template<IsAnyOf< int, float, double, std::complex< double > > T>

void lucid::TensorView< T >::pad	(	TensorView< T > &	out,
		const std::vector< std::pair< Index, Index > > &	padding ) const

Pad the tensor with a value.

The padding is applied to each dimension, and it is specified by a pair of indices, one for the beginning and one for the end of the dimension.

Precondition: The out tensor must have the same shape as the input tensor plus padding

Parameters

[out]	out	padded output tensor
	padding	padding for each dimension

◆ permute() [1/2]

template<IsAnyOf< int, float, double, std::complex< double > > T>

template<IsAnyOf< int, float, double, std::complex< double > > TT>

void lucid::TensorView< T >::permute	(	TensorView< TT > &	out,
		const std::vector< std::size_t > &	permutation ) const

Permute the axes of the tensor.

Namely, the axes are rearranged according to the permutation vector. If an axis is not specified, it will be left unchanged.

Precondition: All values in permutation must be in the range [0, rank() - 1]

Parameters

out	permuted output tensor
permutation	permutation of the axes

◆ permute() [2/2]

template<IsAnyOf< int, float, double, std::complex< double > > T>

template<IsAnyOf< int, float, double, std::complex< double > > TT, std::convertible_to< const std::size_t > I, class... Is>

void lucid::TensorView< T >::permute	(	TensorView< TT > &	out,
		I	i,
		Is...	is ) const

inline

Permute the axes of the tensor.

Namely, the axes are rearranged according to the permutation vector. If an axis is not specified, it will be left unchanged.

Precondition: All values in permutation must be in the range [0, rank() - 1]

Parameters

out	permuted output tensor

Template Parameters

I	axis to put in the first dimension type
Is	varadic remaining permuted axis types

Parameters

i	axis to put in the first dimension
is	remaining permuted axes

◆ rank()

template<IsAnyOf< int, float, double, std::complex< double > > T>

std::size_t lucid::TensorView< T >::rank ( ) const

inlinenodiscard

Get read-only access to the rank of the tensor.

Returns: rank of the tensor

◆ reshape()

template<IsAnyOf< int, float, double, std::complex< double > > T>

TensorView< T > & lucid::TensorView< T >::reshape ( std::vector< std::size_t > dims )

Reshape the tensor to the new dimensions.

Precondition: The number of elements must remain the same

Parameters

dims	new dimensions of the tensor

Returns: reference to this object

◆ size()

template<IsAnyOf< int, float, double, std::complex< double > > T>

std::size_t lucid::TensorView< T >::size ( ) const

inlinenodiscard

Get read-only access to the size of the tensor.

Returns: size of the tensor

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

lucid/util/TensorIterator.h
lucid/util/TensorView.h
lucid/util/TensorView.cpp

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TensorView()

Member Function Documentation

◆ axes()

◆ begin()

◆ copy()

◆ data()

◆ dimensions()

◆ end()

◆ fft()

◆ fft_upsample()

◆ ifft() [1/2]

◆ ifft() [2/2]

◆ index() [1/2]

◆ index() [2/2]

◆ m_data()

◆ operator()() [1/4]

◆ operator()() [2/4]

◆ operator()() [3/4]

◆ operator()() [4/4]

◆ operator[]()

◆ pad() [1/2]

◆ pad() [2/2]

◆ permute() [1/2]

◆ permute() [2/2]

◆ rank()

◆ reshape()

◆ size()