Struct rten_tensor::TensorBase

pub struct TensorBase<T, S: AsRef<[T]>, L: MutLayout> { /* private fields */ }

The base type for multi-dimensional arrays. This consists of storage for elements, plus a layout which maps from a multi-dimensional array index to a storage offset. This base type is not normally used directly but instead through a type alias which selects the storage type and layout.

The storage can be owned (like a Vec<T>), borrowed (like &[T]) or mutably borrowed (like &mut [T]). The layout can have a dimension count that is determined statically (ie. forms part of the tensor’s type), see NdLayout or is only known at runtime, see DynLayout.

Implementations

impl<T, S: AsRef<[T]>, L: MutLayout> TensorBase<T, S, L>

pub fn from_data(shape: L::Index<'_>, data: S) -> TensorBase<T, S, L>

where for<'a> L::Index<'a>: Clone,

Construct a new tensor from a given shape and storage.

Panics if the data length does not match the product of shape.

pub fn try_from_data( shape: L::Index<'_>, data: S ) -> Result<TensorBase<T, S, L>, FromDataError>

Construct a new tensor from a given shape and storage.

This will fail if the data length does not match the product of shape.

pub fn from_data_with_strides( shape: L::Index<'_>, data: S, strides: L::Index<'_> ) -> Result<TensorBase<T, S, L>, FromDataError>

Construct a new tensor from a given shape and storage, and custom strides.

This will fail if the data length is incorrect for the shape and stride combination, or if the strides lead to overlap (see OverlapPolicy). See also TensorBase::from_slice_with_strides which is a similar method for immutable views that does allow overlapping strides.

pub fn into_dyn(self) -> TensorBase<T, S, DynLayout>

where L: Into<DynLayout>,

Convert the current tensor into a dynamic rank tensor without copying any data.

pub fn data_ptr(&self) -> *const T

Return a raw pointer to the tensor’s underlying data.

impl<T, S: AsRef<[T]> + AsMut<[T]>, L: MutLayout> TensorBase<T, S, L>

pub fn axis_iter_mut(&mut self, dim: usize) -> AxisIterMut<'_, T, L>

Return an iterator over mutable slices of this tensor along a given axis. Each view yielded has one dimension fewer than the current layout.

pub fn axis_chunks_mut( &mut self, dim: usize, chunk_size: usize ) -> AxisChunksMut<'_, T, L>

Return an iterator over mutable slices of this tensor along a given axis. Each view yielded has the same rank as this tensor, but the dimension dim will only have chunk_size entries.

pub fn apply<F: Fn(&T) -> T>(&mut self, f: F)

Replace each element in this tensor with the result of applying f to the element.

pub fn as_dyn_mut(&mut self) -> TensorBase<T, &mut [T], DynLayout>

Return a mutable view of this tensor with a dynamic dimension count.

pub fn copy_from<S2: AsRef<[T]>>(&mut self, other: &TensorBase<T, S2, L>)

where T: Clone, L: Clone,

Copy elements from another tensor into this tensor.

This tensor and other must have the same shape.

pub fn data_mut(&mut self) -> Option<&mut [T]>

Return the data in this tensor as a slice if it is contiguous.

pub fn data_mut_ptr(&mut self) -> *mut T

Return a raw pointer to the tensor’s underlying data.

pub fn fill(&mut self, value: T)

where T: Clone,

Replace all elements of this tensor with value.

pub fn get_mut<I: AsIndex<L>>(&mut self, index: I) -> Option<&mut T>

Return a mutable reference to the element at index, or None if the index is invalid.

pub unsafe fn get_unchecked_mut<I: AsIndex<L>>(&mut self, index: I) -> &mut T

Return the element at a given index, without performing any bounds- checking.

Safety

The caller must ensure that the index is valid for the tensor’s shape.

pub fn inner_iter_mut<const N: usize>(&mut self) -> InnerIterMut<'_, T, L, N>

Return a mutable iterator over the N innermost dimensions of this tensor.

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Return a mutable iterator over the elements of this tensor, in their logical order.

pub fn lanes_mut(&mut self, dim: usize) -> LanesMut<'_, T>

Return an iterator over mutable 1D slices of this tensor along a given dimension.

pub fn nd_view_mut<const N: usize>( &mut self ) -> TensorBase<T, &mut [T], NdLayout<N>>

Return a view of this tensor with a static dimension count.

Panics if self.ndim() != N.

pub fn permuted_mut( &mut self, order: L::Index<'_> ) -> TensorBase<T, &mut [T], L>

Permute the order of dimensions according to the given order.

See AsView::permuted.

pub fn reshaped_mut<SH: IntoLayout>( &mut self, shape: SH ) -> TensorBase<T, &mut [T], SH::Layout>

Change the layout of the tensor without moving any data.

See AsView::reshaped.

pub fn slice_mut<const M: usize, R: IntoSliceItems>( &mut self, range: R ) -> NdTensorViewMut<'_, T, M>

Slice this tensor and return a static-rank view with M dimensions.

Use AsView::slice_dyn instead if the number of dimensions in the returned view is unknown at compile time.

Panics if the dimension count is not M.

pub fn slice_mut_dyn<R: IntoSliceItems>( &mut self, range: R ) -> TensorViewMut<'_, T>

Slice this tensor and return a dynamic-rank view.

pub fn try_slice_mut<R: IntoSliceItems>( &mut self, range: R ) -> Result<TensorViewMut<'_, T>, SliceError>

Slice this tensor and return a dynamic-rank view.

Fails if the range has more dimensions than the view or is out of bounds for any dimension.

pub fn view_mut(&mut self) -> TensorBase<T, &mut [T], L>

where L: Clone,

Return a mutable view of this tensor.

pub fn weakly_checked_view_mut(&mut self) -> WeaklyCheckedView<T, &mut [T], L>

Return a mutable view that performs only “weak” checking when indexing, this is faster but can hide bugs. See WeaklyCheckedView.

impl<T, L: Clone + MutLayout> TensorBase<T, Vec<T>, L>

pub fn arange(start: T, end: T, step: Option<T>) -> TensorBase<T, Vec<T>, L>

where T: Copy + PartialOrd + From<bool> + Add<Output = T>, [usize; 1]: AsIndex<L>,

Create a new 1D tensor filled with an arithmetic sequence of values in the range [start, end) separated by step. If step is omitted, it defaults to 1.

pub fn from_vec(vec: Vec<T>) -> TensorBase<T, Vec<T>, L>

where [usize; 1]: AsIndex<L>,

Create a new 1D tensor from a Vec<T>.

pub fn clip_dim(&mut self, dim: usize, range: Range<usize>)

where T: Copy,

Clip dimension dim to [range.start, range.end). The new size for the dimension must be <= the old size.

This currently requires T: Copy to support efficiently moving data from the new start offset to the beginning of the element buffer.

pub fn into_data(self) -> Vec<T>

where T: Clone,

Consume self and return the underlying data as a contiguous tensor.

See also TensorBase::to_vec.

pub fn into_non_contiguous_data(self) -> Vec<T>

Consume self and return the underlying data in whatever order the elements are currently stored.

pub fn into_shape<S: IntoLayout>( self, shape: S ) -> TensorBase<T, Vec<T>, S::Layout>

where T: Clone,

Consume self and return a new contiguous tensor with the given shape.

This avoids copying the data if it is already contiguous.

pub fn from_fn<F: FnMut(L::Index<'_>) -> T, Idx>( shape: L::Index<'_>, f: F ) -> TensorBase<T, Vec<T>, L>

where L::Indices: Iterator<Item = Idx>, Idx: AsIndex<L>,

Create a new tensor with a given shape and values generated by calling f repeatedly.

Each call to f will receive an element index and should return the corresponding value. If the function does not need this index, use from_simple_fn instead, as it is faster.

pub fn from_simple_fn<F: FnMut() -> T>( shape: L::Index<'_>, f: F ) -> TensorBase<T, Vec<T>, L>

Create a new tensor with a given shape and values generated by calling f repeatedly.

pub fn from_scalar(value: T) -> TensorBase<T, Vec<T>, L>

where [usize; 0]: AsIndex<L>,

Create a new 0D tensor from a scalar value.

pub fn full(shape: L::Index<'_>, value: T) -> TensorBase<T, Vec<T>, L>

where T: Clone,

Create a new tensor with a given shape and all elements set to value.

pub fn full_in<A: Alloc>( alloc: A, shape: L::Index<'_>, value: T ) -> TensorBase<T, Vec<T>, L>

where T: Clone,

Variant of full which accepts an allocator.

pub fn make_contiguous(&mut self)

where T: Clone,

Make the underlying data in this tensor contiguous.

This means that after calling make_contiguous, the elements are guaranteed to be stored in the same order as the logical order in which iter yields elements. This method is cheap if the storage is already contiguous.

pub fn rand<R: RandomSource<T>>( shape: L::Index<'_>, rand_src: &mut R ) -> TensorBase<T, Vec<T>, L>

Create a new tensor with a given shape and elements populated using numbers generated by rand_src.

pub fn zeros(shape: L::Index<'_>) -> TensorBase<T, Vec<T>, L>

where T: Clone + Default,

Create a new tensor with a given shape, with all elements set to their default value (ie. zero for numeric types).

pub fn zeros_in<A: Alloc>( alloc: A, shape: L::Index<'_> ) -> TensorBase<T, Vec<T>, L>

where T: Clone + Default,

Variant of zeros which accepts an allocator.

pub fn uninit( shape: L::Index<'_> ) -> TensorBase<MaybeUninit<T>, Vec<MaybeUninit<T>>, L>

where MaybeUninit<T>: Clone,

Return a new tensor containing uninitialized elements.

The caller must initialize elements and then call assume_init to convert to an initialized Tensor<T>.

pub fn uninit_in<A: Alloc>( alloc: A, shape: L::Index<'_> ) -> TensorBase<MaybeUninit<T>, Vec<MaybeUninit<T>>, L>

Variant of uninit which accepts an allocator.

impl<T, S: AsRef<[MaybeUninit<T>]> + AssumeInit, L: Clone + MutLayout> TensorBase<MaybeUninit<T>, S, L>

where <S as AssumeInit>::Output: AsRef<[T]>,

pub unsafe fn assume_init(self) -> TensorBase<T, <S as AssumeInit>::Output, L>

Convert a tensor of potentially uninitialized elements to one of initialized elements.

The tensor or view must be contiguous and this method will panic if it is not. This restriction avoids hazards with converting a view to initialized if it does not address all elements in the underlying storage.

See also MaybeUninit::assume_init.

Safety

The caller must guarantee that all elements in this tensor have been initialized before calling assume_init.

pub fn init_from<S2: AsRef<[T]>>( self, other: &TensorBase<T, S2, L> ) -> TensorBase<T, <S as AssumeInit>::Output, L>

where T: Copy, S: AsMut<[MaybeUninit<T>]>,

Initialize this tensor with data from another view.

This tensor and other must have the same shape.

impl<'a, T, L: Clone + MutLayout> TensorBase<T, &'a [T], L>

pub fn axis_iter(&self, dim: usize) -> AxisIter<'a, T, L>

pub fn axis_chunks(&self, dim: usize, chunk_size: usize) -> AxisChunks<'a, T, L>

pub fn as_dyn(&self) -> TensorBase<T, &'a [T], DynLayout>

Return a view of this tensor with a dynamic dimension count.

See AsView::as_dyn.

pub fn broadcast<S: IntoLayout>( &self, shape: S ) -> TensorBase<T, &'a [T], S::Layout>

where L: BroadcastLayout<S::Layout>,

Broadcast this view to another shape.

See AsView::broadcast.

pub fn broadcast_iter(&self, shape: &[usize]) -> BroadcastIter<'a, T>

Return an iterator over elements as if this tensor was broadcast to another shape.

See AsView::broadcast_iter.

pub fn data(&self) -> Option<&'a [T]>

Return the data in this tensor as a slice if it is contiguous, ie. the order of elements in the slice is the same as the logical order yielded by iter, and there are no gaps.

pub fn get<I: AsIndex<L>>(&self, index: I) -> Option<&'a T>

pub fn non_contiguous_data(&self) -> &'a [T]

Return this view’s underlying data as a slice.

Unlike the data method, this method does not check if the storage is contiguous in memory (ie. elements are stored in the same order as returned by iter, with no gaps).

Note there is no safe equivalent of this method for mutable views because this could lead to overlapping mutable slices.

pub fn from_slice_with_strides( shape: L::Index<'_>, data: &'a [T], strides: L::Index<'_> ) -> Result<TensorBase<T, &'a [T], L>, FromDataError>

Create a new view with a given shape and data slice, and custom strides.

If you do not need to specify custom strides, use TensorBase::from_data instead. This method is similar to TensorBase::from_data_with_strides, but allows strides that lead to internal overlap (see OverlapPolicy).

pub unsafe fn get_unchecked<I: AsIndex<L>>(&self, index: I) -> &'a T

Return the element at a given index, without performing any bounds- checking.

Safety

The caller must ensure that the index is valid for the tensor’s shape.

pub fn inner_iter<const N: usize>(&self) -> InnerIter<'a, T, L, N>

Return an iterator over the inner N dimensions of this tensor.

See AsView::inner_iter.

pub fn item(&self) -> Option<&'a T>

Return the scalar value in this tensor if it has one element.

pub fn iter(&self) -> Iter<'a, T>

Return an iterator over elements of this tensor in their logical order.

See AsView::iter.

pub fn lanes(&self, dim: usize) -> Lanes<'a, T>

Return an iterator over 1D slices of this tensor along a given dimension.

See AsView::lanes.

pub fn nd_view<const N: usize>(&self) -> TensorBase<T, &'a [T], NdLayout<N>>

Return a view of this tensor with a static dimension count.

Panics if self.ndim() != N.

pub fn permuted(&self, order: L::Index<'_>) -> TensorBase<T, &'a [T], L>

Permute the axes of this tensor according to order.

See AsView::permuted.

pub fn reshaped<S: IntoLayout>( &self, shape: S ) -> TensorBase<T, &'a [T], S::Layout>

Change the shape of this tensor without copying data.

See AsView::reshaped.

pub fn slice<const M: usize, R: IntoSliceItems>( &self, range: R ) -> NdTensorView<'a, T, M>

Slice this tensor and return a static-rank view. See AsView::slice.

pub fn slice_dyn<R: IntoSliceItems>(&self, range: R) -> TensorView<'a, T>

Slice this tensor and return a dynamic-rank view. See AsView::slice_dyn.

pub fn slice_iter(&self, range: &[SliceItem]) -> Iter<'a, T>

See AsView::slice_iter.

pub fn squeezed(&self) -> TensorView<'a, T>

Remove all size-one dimensions from this tensor.

See AsView::squeezed.

pub fn to_contiguous(&self) -> TensorBase<T, Cow<'a, [T]>, L>

where T: Clone,

Return a view of this tensor with elements stored in contiguous order.

If the data is already contiguous, no copy is made, otherwise the elements are copied into a new buffer in contiguous order.

pub fn to_slice(&self) -> Cow<'a, [T]>

where T: Clone,

Return the underlying data as a flat slice if the tensor is contiguous, or a copy of the data as a flat slice otherwise.

See AsView::to_slice.

pub fn transposed(&self) -> TensorBase<T, &'a [T], L>

Reverse the order of dimensions in this tensor. See AsView::transposed.

pub fn try_slice_dyn<R: IntoSliceItems>( &self, range: R ) -> Result<TensorView<'a, T>, SliceError>

pub fn view(&self) -> TensorBase<T, &'a [T], L>

Return a read-only view of this tensor. See AsView::view.

pub fn weakly_checked_view(&self) -> WeaklyCheckedView<T, &'a [T], L>

impl<T, S: AsRef<[T]>, const N: usize> TensorBase<T, S, NdLayout<N>>

pub fn get_array<const M: usize>(&self, base: [usize; N], dim: usize) -> [T; M]

where T: Copy + Default,

Load an array of M elements from successive entries of a tensor along the dim axis.

eg. If base is [0, 1, 2], dim=0 and M = 4 this will return an array with values from indices [0, 1, 2], [1, 1, 2] … [3, 1, 2].

Panics if any of the array indices are out of bounds.

impl<T> TensorBase<T, Vec<T>, DynLayout>

pub fn reshape(&mut self, shape: &[usize])

where T: Clone,

Reshape this tensor in place. This is cheap if the tensor is contiguous, as only the layout will be changed, but requires copying data otherwise.

pub fn reshape_in<A: Alloc>(&mut self, alloc: A, shape: &[usize])

where T: Clone,

Variant of reshape which takes an allocator as an argument.

impl<'a, T> TensorBase<T, &'a [T], DynLayout>

pub fn reshape(&mut self, shape: &[usize])

where T: Clone,

Reshape this view.

Panics if the view is not contiguous.

impl<'a, T> TensorBase<T, &'a mut [T], DynLayout>

pub fn reshape(&mut self, shape: &[usize])

where T: Clone,

Reshape this view.

Panics if the view is not contiguous.

impl<T, S: AsRef<[T]> + AsMut<[T]>, const N: usize> TensorBase<T, S, NdLayout<N>>

pub fn set_array<const M: usize>( &mut self, base: [usize; N], dim: usize, values: [T; M] )

where T: Copy,

Store an array of M elements into successive entries of a tensor along the dim axis.

See TensorBase::get_array for more details.

impl<T, S: AsRef<[T]>> TensorBase<T, S, NdLayout<1>>

pub fn to_array<const M: usize>(&self) -> [T; M]

where T: Copy + Default,

Convert this vector to a static array of length M.

Panics if the length of this vector is not M.

impl<T, S: AsRef<[T]> + AsMut<[T]>> TensorBase<T, S, NdLayout<1>>

pub fn assign_array<const M: usize>(&mut self, values: [T; M])

where T: Copy + Default,

Fill this vector with values from a static array of length M.

Panics if the length of this vector is not M.

Trait Implementations

impl<T, S: AsRef<[T]>, L: MutLayout + Clone> AsView for TensorBase<T, S, L>

type Elem = T

Type of element stored in this tensor.

type Layout = L

The underlying layout of this tensor. It must have the same index type (eg. [usize; N] or &[usize]) as this view.

fn iter(&self) -> Iter<'_, T>

Return an iterator over elements in this tensor in their logical order.

fn data(&self) -> Option<&[Self::Elem]>

Return the layout of this tensor as a slice, if it is contiguous.

fn insert_axis(&mut self, index: usize)

where L: ResizeLayout,

Insert a size-1 axis at the given index.

fn merge_axes(&mut self)

where L: ResizeLayout,

Merge consecutive dimensions to the extent possible without copying data or changing the iteration order.

fn layout(&self) -> &L

Return the layout of this tensor.

fn map<F, U>(&self, f: F) -> TensorBase<U, Vec<U>, L>

where F: Fn(&Self::Elem) -> U,

Return a new tensor with the same shape, formed by applying f to each element in this tensor.

fn map_in<A: Alloc, F, U>(&self, alloc: A, f: F) -> TensorBase<U, Vec<U>, L>

where F: Fn(&Self::Elem) -> U,

Variant of map which takes an output buffer as an argument.

fn move_axis(&mut self, from: usize, to: usize)

Re-order the axes of this tensor to move the axis at index from to to.

fn view(&self) -> TensorBase<T, &[T], L>

Return a borrowed view of this tensor.

fn get<I: AsIndex<L>>(&self, index: I) -> Option<&Self::Elem>

Return a reference to the element at a given index, or None if the index is invalid.

unsafe fn get_unchecked<I: AsIndex<L>>(&self, index: I) -> &T

Return a reference to the element at a given index, without performing bounds checks.

fn permute(&mut self, order: Self::Index<'_>)

Permute the dimensions of this tensor.

fn to_vec(&self) -> Vec<T>

where T: Clone,

Return a vector containing the elements of this tensor in their logical order, ie. as if the tensor were flattened into one dimension.

fn to_vec_in<A: Alloc>(&self, alloc: A) -> Vec<T>

where T: Clone,

Variant of to_vec which takes an output buffer as an argument.

fn to_shape<SH: IntoLayout>( &self, shape: SH ) -> TensorBase<Self::Elem, Vec<Self::Elem>, SH::Layout>

where T: Clone,

Return a copy of this tensor with a given shape.

fn transpose(&mut self)

Reverse the order of dimensions in this tensor.

fn as_dyn(&self) -> TensorBase<Self::Elem, &[Self::Elem], DynLayout>

Return a view of this tensor with a dynamic rank.

fn axis_chunks( &self, dim: usize, chunk_size: usize ) -> AxisChunks<'_, Self::Elem, Self::Layout>

Return an iterator over slices of this tensor along a given axis.

fn axis_iter(&self, dim: usize) -> AxisIter<'_, Self::Elem, Self::Layout>

Return an iterator over slices of this tensor along a given axis.

fn broadcast<S: IntoLayout>( &self, shape: S ) -> TensorBase<Self::Elem, &[Self::Elem], S::Layout>

where Self::Layout: BroadcastLayout<S::Layout>,

Broadcast this view to another shape.

fn broadcast_iter(&self, shape: &[usize]) -> BroadcastIter<'_, Self::Elem>

Return an iterator over elements of this tensor, broadcast to shape.

fn inner_iter<const N: usize>( &self ) -> InnerIter<'_, Self::Elem, Self::Layout, N>

Return an iterator over the innermost N dimensions.

fn item(&self) -> Option<&Self::Elem>

Return the scalar value in this tensor if it has 0 dimensions.

fn lanes(&self, dim: usize) -> Lanes<'_, Self::Elem>

Return an iterator over 1D slices of this tensor along a given axis.

fn nd_view<const N: usize>( &self ) -> TensorBase<Self::Elem, &[Self::Elem], NdLayout<N>>

Convert this tensor to one with the same shape but a static dimension count.

fn permuted( &self, order: Self::Index<'_> ) -> TensorBase<Self::Elem, &[Self::Elem], Self::Layout>

Return a view with dimensions permuted in the order given by dims.

fn reshaped<S: IntoLayout>( &self, shape: S ) -> TensorBase<Self::Elem, &[Self::Elem], S::Layout>

Return a view with a given shape, without copying any data. This requires that the tensor is contiguous.

fn transposed(&self) -> TensorBase<Self::Elem, &[Self::Elem], Self::Layout>

Return a view with the order of dimensions reversed.

fn try_slice_dyn<R: IntoSliceItems>( &self, range: R ) -> Result<TensorView<'_, Self::Elem>, SliceError>

Slice this tensor and return a dynamic-rank view.

fn slice<const M: usize, R: IntoSliceItems>( &self, range: R ) -> NdTensorView<'_, Self::Elem, M>

Slice this tensor and return a static-rank view with M dimensions.

fn slice_dyn<R: IntoSliceItems>(&self, range: R) -> TensorView<'_, Self::Elem>

Slice this tensor and return a dynamic-rank view.

fn slice_iter(&self, range: &[SliceItem]) -> Iter<'_, Self::Elem>

Return an iterator over a slice of this tensor.

fn squeezed(&self) -> TensorView<'_, Self::Elem>

Return a view of this tensor with all dimensions of size 1 removed.

fn weakly_checked_view( &self ) -> WeaklyCheckedView<Self::Elem, &[Self::Elem], Self::Layout>

Return a view which performs “weak” checking when indexing via view[<index>]. See WeaklyCheckedView for an explanation.

impl<T, S: AsRef<[T]> + Clone, L: MutLayout + Clone> Clone for TensorBase<T, S, L>

fn clone(&self) -> TensorBase<T, S, L>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug, S: Debug + AsRef<[T]>, L: Debug + MutLayout> Debug for TensorBase<T, S, L>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, T, L: Clone + MutLayout> From<&'a [T]> for TensorBase<T, &'a [T], L>

where [usize; 1]: AsIndex<L>,

fn from(slice: &'a [T]) -> Self

Create a 1D view from a slice.

impl<'a, T, L: Clone + MutLayout, const N: usize> From<&'a [T; N]> for TensorBase<T, &'a [T], L>

where [usize; 1]: AsIndex<L>,

fn from(slice: &'a [T; N]) -> Self

Create a 1D view from a slice of known length.

impl<T: Clone + Scalar, L: MutLayout, const D0: usize, const D1: usize, const D2: usize> From<[[[T; D2]; D1]; D0]> for TensorBase<T, Vec<T>, L>

where [usize; 3]: AsIndex<L>,

fn from(value: [[[T; D2]; D1]; D0]) -> Self

Construct a 3D tensor from a nested array.

impl<T: Clone + Scalar, L: MutLayout, const D0: usize, const D1: usize> From<[[T; D1]; D0]> for TensorBase<T, Vec<T>, L>

where [usize; 2]: AsIndex<L>,

fn from(value: [[T; D1]; D0]) -> Self

Construct a 2D tensor from a nested array.

impl<T: Clone + Scalar, L: MutLayout, const D0: usize> From<[T; D0]> for TensorBase<T, Vec<T>, L>

where [usize; 1]: AsIndex<L>,

fn from(value: [T; D0]) -> Self

Construct a 1D tensor from a 1D array.

impl<T, S: AsRef<[T]>, const N: usize> From<TensorBase<T, S, NdLayout<N>>> for TensorBase<T, S, DynLayout>

fn from(tensor: TensorBase<T, S, NdLayout<N>>) -> Self

Converts to this type from the input type.

impl<T, L: Clone + MutLayout> From<Vec<T>> for TensorBase<T, Vec<T>, L>

where [usize; 1]: AsIndex<L>,

fn from(vec: Vec<T>) -> Self

Create a 1D tensor from a vector.

impl<T, L: Clone + MutLayout> FromIterator<T> for TensorBase<T, Vec<T>, L>

where [usize; 1]: AsIndex<L>,

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> TensorBase<T, Vec<T>, L>

Create a new 1D tensor filled with an arithmetic sequence of values in the range [start, end) separated by step. If step is omitted, it defaults to 1.

impl<T, S: AsRef<[T]>, L: MutLayout, I: AsIndex<L>> Index<I> for TensorBase<T, S, L>

fn index(&self, index: I) -> &Self::Output

Return the element at a given index.

Panics if the index is out of bounds along any dimension.

type Output = T

The returned type after indexing.

impl<T, S: AsRef<[T]> + AsMut<[T]>, L: MutLayout, I: AsIndex<L>> IndexMut<I> for TensorBase<T, S, L>

fn index_mut(&mut self, index: I) -> &mut Self::Output

Return the element at a given index.

Panics if the index is out of bounds along any dimension.

impl<T, S: AsRef<[T]>, L: MutLayout> Layout for TensorBase<T, S, L>

type Index<'a> = <L as Layout>::Index<'a>

Type used to represent indices.

type Indices = <L as Layout>::Indices

Iterator over indices in this tensor.

fn ndim(&self) -> usize

Return the number of dimensions.

fn len(&self) -> usize

Returns the number of elements in the array.

fn is_empty(&self) -> bool

Returns true if the array has no elements.

fn shape(&self) -> Self::Index<'_>

Returns an array of the sizes of each dimension.

fn size(&self, dim: usize) -> usize

Returns the size of the dimension dim.

fn strides(&self) -> Self::Index<'_>

Returns an array of the strides of each dimension.

fn stride(&self, dim: usize) -> usize

Returns the offset between adjacent indices along dimension dim.

fn indices(&self) -> Self::Indices

Return an iterator over all valid indices in this tensor.

fn try_offset(&self, index: Self::Index<'_>) -> Option<usize>

Map an index to a storage offset, or return None if the index is out of bounds along any dimension.

fn offset(&self, index: Self::Index<'_>) -> usize

Map an index to a storage offset.

fn offset_unchecked(&self, index: Self::Index<'_>) -> usize

Map an index to a storage offset, without checking if it is valid for the tensor’s shape.

fn is_contiguous(&self) -> bool

Return true if this layout describes a contiguous tensor, where the logical order of elements matches the order in which they are stored.

fn is_broadcast(&self) -> bool

Return true if iterating over elements in this layout will visit elements multiple times.

fn can_broadcast_to(&self, target_shape: &[usize]) -> bool

Return true if this layout’s shape can be broadcast to the given shape.

fn can_broadcast_with(&self, shape: &[usize]) -> bool

Return true if the tensor/view can be broadcast with another tensor or view with a given shape as part of a binary operation.

fn min_data_len(&self) -> usize

Return the minimum length required for the element data buffer used with this layout.

impl<T, S: AsRef<[T]>, L: MutLayout + MatrixLayout> MatrixLayout for TensorBase<T, S, L>

fn rows(&self) -> usize

fn cols(&self) -> usize

fn row_stride(&self) -> usize

fn col_stride(&self) -> usize

impl<T: PartialEq, S: AsRef<[T]>, L: MutLayout, V: AsView<Elem = T>> PartialEq<V> for TensorBase<T, S, L>

fn eq(&self, other: &V) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, S1, S2: AsRef<[T]>, const N: usize> TryFrom<TensorBase<T, S1, DynLayout>> for TensorBase<T, S2, NdLayout<N>>

where S1: Into<S2> + AsRef<[T]>,

fn try_from(value: TensorBase<T, S1, DynLayout>) -> Result<Self, Self::Error>

Convert a tensor or view with dynamic rank into a static rank one.

Fails if value does not have N dimensions.

type Error = DimensionError

The type returned in the event of a conversion error.

impl<T, S: AsRef<[T]> + Copy, L: MutLayout + Copy> Copy for TensorBase<T, S, L>