Type Alias TensorAny

pub type TensorAny<R, T, B, D> = TensorBase<Storage<R, T, B>, D>;

Aliased Type

struct TensorAny<R, T, B, D> { /* private fields */ }

Implementations

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, B: DeviceAPI<T> + DeviceIndexSelectAPI<T, D> + DeviceCreationAnyAPI<T>,

pub fn index_select_f<I>( &self, axis: isize, indices: I, ) -> Result<Tensor<T, B, D>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn index_select<I>(&self, axis: isize, indices: I) -> Tensor<T, B, D>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

Returns a new tensor, which indexes the input tensor along dimension axis using the entries in indices.

See also

This function should be similar to PyTorch’s torch.index_select.

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, T: Clone, D: DimAPI, B: DeviceAPI<T> + DeviceCreationAnyAPI<T>,

pub fn full_like(&self, fill: T) -> Tensor<T, B, D>

pub fn full_like_f(&self, fill: T) -> Result<Tensor<T, B, D>>

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, D: DimAPI, T: Num, B: DeviceAPI<T> + DeviceCreationNumAPI<T>,

pub fn ones_like(&self) -> Tensor<T, B, D>

New tensor filled with ones and having the same shape as an input tensor.

See also

ones_like

pub fn ones_like_f(&self) -> Result<Tensor<T, B, D>>

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, D: DimAPI, T: Num, B: DeviceAPI<T> + DeviceCreationNumAPI<T>,

pub fn zeros_like(&self) -> Tensor<T, B, D>

New tensor filled with zeros and having the same shape as an input tensor.

See also

zeros_like

pub fn zeros_like_f(&self) -> Result<Tensor<T, B, D>>

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, B: DeviceAPI<T>, D: DimAPI,

pub fn into_slice_f<I>(self, index: I) -> Result<TensorAny<R, T, B, IxD>>

where I: TryInto<AxesIndex<Indexer>>, Error: From<I::Error>,

pub fn into_slice<I>(self, index: I) -> TensorAny<R, T, B, IxD>

where I: TryInto<AxesIndex<Indexer>>, Error: From<I::Error>,

pub fn slice_f<I>(&self, index: I) -> Result<TensorView<'_, T, B, IxD>>

where I: TryInto<AxesIndex<Indexer>>, Error: From<I::Error>,

pub fn slice<I>(&self, index: I) -> TensorView<'_, T, B, IxD>

where I: TryInto<AxesIndex<Indexer>>, Error: From<I::Error>,

pub fn i_f<I>(&self, index: I) -> Result<TensorView<'_, T, B, IxD>>

where I: TryInto<AxesIndex<Indexer>>, Error: From<I::Error>,

pub fn i<I>(&self, index: I) -> TensorView<'_, T, B, IxD>

where I: TryInto<AxesIndex<Indexer>>, Error: From<I::Error>,

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataMutAPI<Data = B::Raw>, B: DeviceAPI<T>, D: DimAPI,

pub fn slice_mut_f<I>(&mut self, index: I) -> Result<TensorMut<'_, T, B, IxD>>

where I: TryInto<AxesIndex<Indexer>>, Error: From<I::Error>,

pub fn slice_mut<I>(&mut self, index: I) -> TensorMut<'_, T, B, IxD>

where I: TryInto<AxesIndex<Indexer>>, Error: From<I::Error>,

pub fn i_mut_f<I>(&mut self, index: I) -> Result<TensorMut<'_, T, B, IxD>>

where I: TryInto<AxesIndex<Indexer>>, Error: From<I::Error>,

pub fn i_mut<I>(&mut self, index: I) -> TensorMut<'_, T, B, IxD>

where I: TryInto<AxesIndex<Indexer>>, Error: From<I::Error>,

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, B: DeviceAPI<T>, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI,

pub fn into_diagonal_f( self, diagonal_args: impl Into<DiagonalArgs>, ) -> Result<TensorAny<R, T, B, D::SmallerOne>>

pub fn into_diagonal( self, diagonal_args: impl Into<DiagonalArgs>, ) -> TensorAny<R, T, B, D::SmallerOne>

pub fn diagonal_f( &self, diagonal_args: impl Into<DiagonalArgs>, ) -> Result<TensorView<'_, T, B, D::SmallerOne>>

pub fn diagonal( &self, diagonal_args: impl Into<DiagonalArgs>, ) -> TensorView<'_, T, B, D::SmallerOne>

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataMutAPI<Data = B::Raw>, B: DeviceAPI<T>, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI,

pub fn into_diagonal_mut_f( self, diagonal_args: impl Into<DiagonalArgs>, ) -> Result<TensorAny<R, T, B, D::SmallerOne>>

pub fn into_diagonal_mut( self, diagonal_args: impl Into<DiagonalArgs>, ) -> TensorAny<R, T, B, D::SmallerOne>

pub fn diagonal_mut_f( &mut self, diagonal_args: impl Into<DiagonalArgs>, ) -> Result<TensorMut<'_, T, B, D::SmallerOne>>

pub fn diagonal_mut( &mut self, diagonal_args: impl Into<DiagonalArgs>, ) -> TensorMut<'_, T, B, D::SmallerOne>

impl<'a, R, T, B, D> TensorAny<R, T, B, D>

where T: Clone, R: DataCloneAPI<Data = B::Raw>, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>> + 'a,

pub fn axes_iter_with_order_f<I>( &self, axes: I, order: TensorIterOrder, ) -> Result<IterAxesView<'a, T, B>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn axes_iter_f<I>(&self, axes: I) -> Result<IterAxesView<'a, T, B>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn axes_iter_with_order<I>( &self, axes: I, order: TensorIterOrder, ) -> IterAxesView<'a, T, B>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn axes_iter<I>(&self, axes: I) -> IterAxesView<'a, T, B>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

impl<'a, R, T, B, D> TensorAny<R, T, B, D>

where T: Clone, R: DataMutAPI<Data = B::Raw>, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>> + 'a,

pub fn axes_iter_mut_with_order_f<I>( &'a mut self, axes: I, order: TensorIterOrder, ) -> Result<IterAxesMut<'a, T, B>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn axes_iter_mut_f<I>( &'a mut self, axes: I, ) -> Result<IterAxesMut<'a, T, B>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn axes_iter_mut_with_order<I>( &'a mut self, axes: I, order: TensorIterOrder, ) -> IterAxesMut<'a, T, B>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn axes_iter_mut<I>(&'a mut self, axes: I) -> IterAxesMut<'a, T, B>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

impl<'a, R, T, B, D> TensorAny<R, T, B, D>

where T: Clone, R: DataCloneAPI<Data = B::Raw>, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>> + 'a,

pub fn indexed_axes_iter_with_order_f<I>( &self, axes: I, order: TensorIterOrder, ) -> Result<IndexedIterAxesView<'a, T, B>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn indexed_axes_iter_f<I>( &self, axes: I, ) -> Result<IndexedIterAxesView<'a, T, B>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn indexed_axes_iter_with_order<I>( &self, axes: I, order: TensorIterOrder, ) -> IndexedIterAxesView<'a, T, B>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn indexed_axes_iter<I>(&self, axes: I) -> IndexedIterAxesView<'a, T, B>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

impl<'a, R, T, B, D> TensorAny<R, T, B, D>

where T: Clone, R: DataMutAPI<Data = B::Raw>, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>> + 'a,

pub fn indexed_axes_iter_mut_with_order_f<I>( &'a mut self, axes: I, order: TensorIterOrder, ) -> Result<IndexedIterAxesMut<'a, T, B>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn indexed_axes_iter_mut_f<I>( &'a mut self, axes: I, ) -> Result<IndexedIterAxesMut<'a, T, B>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn indexed_axes_iter_mut_with_order<I>( &'a mut self, axes: I, order: TensorIterOrder, ) -> IndexedIterAxesMut<'a, T, B>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn indexed_axes_iter_mut<I>( &'a mut self, axes: I, ) -> IndexedIterAxesMut<'a, T, B>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

impl<'a, R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>> + 'a,

pub fn iter_with_order_f( &self, order: TensorIterOrder, ) -> Result<IterVecView<'a, T, D>>

pub fn iter_with_order(&self, order: TensorIterOrder) -> IterVecView<'a, T, D>

pub fn iter_f(&self) -> Result<IterVecView<'a, T, D>>

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

impl<'a, R, T, B, D> TensorAny<R, T, B, D>

where R: DataMutAPI<Data = B::Raw>, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>> + 'a,

pub fn iter_mut_with_order_f( &'a mut self, order: TensorIterOrder, ) -> Result<IterVecMut<'a, T, D>>

pub fn iter_mut_with_order( &'a mut self, order: TensorIterOrder, ) -> IterVecMut<'a, T, D>

pub fn iter_mut_f(&'a mut self) -> Result<IterVecMut<'a, T, D>>

pub fn iter_mut(&'a mut self) -> IterVecMut<'a, T, D>

impl<'a, R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>> + 'a,

pub fn indexed_iter_with_order_f( &self, order: TensorIterOrder, ) -> Result<IndexedIterVecView<'a, T, D>>

pub fn indexed_iter_with_order( &self, order: TensorIterOrder, ) -> IndexedIterVecView<'a, T, D>

pub fn indexed_iter_f(&self) -> Result<IndexedIterVecView<'a, T, D>>

pub fn indexed_iter(&self) -> IndexedIterVecView<'a, T, D>

impl<'a, R, T, B, D> TensorAny<R, T, B, D>

where R: DataMutAPI<Data = B::Raw>, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>> + 'a,

pub fn indexed_iter_mut_with_order_f( &'a mut self, order: TensorIterOrder, ) -> Result<IndexedIterVecMut<'a, T, D>>

pub fn indexed_iter_mut_with_order( &'a mut self, order: TensorIterOrder, ) -> IndexedIterVecMut<'a, T, D>

pub fn indexed_iter_mut_f(&'a mut self) -> Result<IndexedIterVecMut<'a, T, D>>

pub fn indexed_iter_mut(&'a mut self) -> IndexedIterVecMut<'a, T, D>

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, B: DeviceAPI<T>, D: DimAPI,

pub fn to_broadcast<D2>(&self, shape: D2) -> TensorView<'_, T, B, D2>

where D2: DimAPI, D: DimMaxAPI<D2, Max = D2>,

Broadcasts an array to a specified shape.

See also

to_broadcast

pub fn to_broadcast_f<D2>(&self, shape: D2) -> Result<TensorView<'_, T, B, D2>>

where D2: DimAPI, D: DimMaxAPI<D2, Max = D2>,

pub fn into_broadcast<D2>(self, shape: D2) -> TensorAny<R, T, B, D2>

where D2: DimAPI, D: DimMaxAPI<D2, Max = D2>,

Broadcasts an array to a specified shape.

See also

to_broadcast

pub fn into_broadcast_f<D2>(self, shape: D2) -> Result<TensorAny<R, T, B, D2>>

where D2: DimAPI, D: DimMaxAPI<D2, Max = D2>,

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, B: DeviceAPI<T>, D: DimAPI,

pub fn expand_dims<I>(&self, axes: I) -> TensorView<'_, T, B, IxD>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

Expands the shape of an array by inserting a new axis (dimension) of size one at the position specified by axis.

See also

expand_dims

pub fn expand_dims_f<I>(&self, axes: I) -> Result<TensorView<'_, T, B, IxD>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn into_expand_dims<I>(self, axes: I) -> TensorAny<R, T, B, IxD>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

Expands the shape of an array by inserting a new axis (dimension) of size one at the position specified by axis.

See also

expand_dims

pub fn into_expand_dims_f<I>(self, axes: I) -> Result<TensorAny<R, T, B, IxD>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, B: DeviceAPI<T>, D: DimAPI,

pub fn flip<I>(&self, axis: I) -> TensorView<'_, T, B, D>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

Reverses the order of elements in an array along the given axis.

See also

flip

pub fn flip_f<I>(&self, axis: I) -> Result<TensorView<'_, T, B, D>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn into_flip<I>(self, axis: I) -> TensorAny<R, T, B, D>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

Reverses the order of elements in an array along the given axis.

See also

flip

pub fn into_flip_f<I>(self, axis: I) -> Result<TensorAny<R, T, B, D>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, B: DeviceAPI<T>, D: DimAPI,

pub fn transpose<I>(&self, axes: I) -> TensorView<'_, T, B, D>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

Permutes the axes (dimensions) of an array x.

See also

transpose

pub fn transpose_f<I>(&self, axes: I) -> Result<TensorView<'_, T, B, D>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn into_transpose<I>(self, axes: I) -> TensorAny<R, T, B, D>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

Permutes the axes (dimensions) of an array x.

See also

transpose

pub fn into_transpose_f<I>(self, axes: I) -> Result<TensorAny<R, T, B, D>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn permute_dims<I>(&self, axes: I) -> TensorView<'_, T, B, D>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

Permutes the axes (dimensions) of an array x.

See also

transpose

pub fn permute_dims_f<I>(&self, axes: I) -> Result<TensorView<'_, T, B, D>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn into_permute_dims<I>(self, axes: I) -> TensorAny<R, T, B, D>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

Permutes the axes (dimensions) of an array x.

See also

transpose

pub fn into_permute_dims_f<I>(self, axes: I) -> Result<TensorAny<R, T, B, D>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, B: DeviceAPI<T>, D: DimAPI,

pub fn reverse_axes(&self) -> TensorView<'_, T, B, D>

Reverse the order of elements in an array along the given axis.

See also

reverse_axes

pub fn into_reverse_axes(self) -> TensorAny<R, T, B, D>

Reverse the order of elements in an array along the given axis.

See also

reverse_axes

pub fn t(&self) -> TensorView<'_, T, B, D>

Reverse the order of elements in an array along the given axis.

See also

reverse_axes

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, B: DeviceAPI<T>, D: DimAPI,

pub fn swapaxes<I>(&self, axis1: I, axis2: I) -> TensorView<'_, T, B, D>

where I: TryInto<isize>,

Interchange two axes of an array.

See also

swapaxes

pub fn swapaxes_f<I>( &self, axis1: I, axis2: I, ) -> Result<TensorView<'_, T, B, D>>

where I: TryInto<isize>,

pub fn into_swapaxes<I>(self, axis1: I, axis2: I) -> TensorAny<R, T, B, D>

where I: TryInto<isize>,

Interchange two axes of an array.

See also

swapaxes

pub fn into_swapaxes_f<I>( self, axis1: I, axis2: I, ) -> Result<TensorAny<R, T, B, D>>

where I: TryInto<isize>,

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, B: DeviceAPI<T>, D: DimAPI,

pub fn squeeze<I>(&self, axis: I) -> TensorView<'_, T, B, IxD>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

Removes singleton dimensions (axes) from x.

See also

squeeze

pub fn squeeze_f<I>(&self, axis: I) -> Result<TensorView<'_, T, B, IxD>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn into_squeeze<I>(self, axis: I) -> TensorAny<R, T, B, IxD>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

Removes singleton dimensions (axes) from x.

See also

squeeze

pub fn into_squeeze_f<I>(self, axis: I) -> Result<TensorAny<R, T, B, IxD>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

impl<R, T, B, D> TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = B::Raw>, B: DeviceAPI<T>,

pub fn to_dim<D2>(&self) -> TensorView<'_, T, B, D2>

where D2: DimAPI, D: DimIntoAPI<D2>,

Convert layout to the other dimension.

This is mostly used when converting static dimension to dynamic dimension or vice versa.

See also

into_dim

pub fn to_dim_f<D2>(&self) -> Result<TensorView<'_, T, B, D2>>

where D2: DimAPI, D: DimIntoAPI<D2>,

pub fn into_dim<D2>(self) -> TensorAny<R, T, B, D2>

where D2: DimAPI, D: DimIntoAPI<D2>,

Convert layout to another dimension.

See also

into_dim

pub fn into_dim_f<D2>(self) -> Result<TensorAny<R, T, B, D2>>

where D2: DimAPI, D: DimIntoAPI<D2>,

pub fn to_dyn(&self) -> TensorView<'_, T, B, IxD>

Convert layout to dynamic dimension.

pub fn into_dyn(self) -> TensorAny<R, T, B, IxD>

Convert layout to dynamic dimension.

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, B: DeviceAPI<T>, D: DimAPI,

pub fn reshape_assume_contig<D2>(&self, shape: D2) -> TensorView<'_, T, B, D2>

where D2: DimAPI,

Assuming contiguous array, reshapes an array without changing its data.

See also

reshape_assume_contig

pub fn reshape_assume_contig_f<D2>( &self, shape: D2, ) -> Result<TensorView<'_, T, B, D2>>

where D2: DimAPI,

pub fn to_shape_assume_contig<D2>(&self, shape: D2) -> TensorView<'_, T, B, D2>

where D2: DimAPI,

pub fn to_shape_assume_contig_f<D2>( &self, shape: D2, ) -> Result<TensorView<'_, T, B, D2>>

where D2: DimAPI,

pub fn into_shape_assume_contig<D2>(self, shape: D2) -> TensorAny<R, T, B, D2>

where D2: DimAPI,

pub fn into_shape_assume_contig_f<D2>( self, shape: D2, ) -> Result<TensorAny<R, T, B, D2>>

where D2: DimAPI,

impl<'a, R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw> + DataIntoCowAPI<'a>, D: DimAPI, B: DeviceAPI<T> + DeviceCreationAnyAPI<T> + OpAssignArbitaryAPI<T, IxD, D> + OpAssignAPI<T, IxD>, T: Clone,

pub fn change_shape_f<I>(self, shape: I) -> Result<TensorCow<'a, T, B, IxD>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn change_shape<I>(self, shape: I) -> TensorCow<'a, T, B, IxD>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn into_shape_f<I>(self, shape: I) -> Result<Tensor<T, B, IxD>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>, B::Raw: Clone + 'a,

pub fn into_shape<I>(self, shape: I) -> Tensor<T, B, IxD>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>, B::Raw: Clone + 'a,

pub fn to_shape_f<I>(&'a self, shape: I) -> Result<TensorCow<'a, T, B, IxD>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn to_shape<I>(&'a self, shape: I) -> TensorCow<'a, T, B, IxD>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn reshape_f<I>(&'a self, shape: I) -> Result<TensorCow<'a, T, B, IxD>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn reshape<I>(&'a self, shape: I) -> TensorCow<'a, T, B, IxD>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

impl<'a, R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw> + DataIntoCowAPI<'a>, D: DimAPI, T: Clone, B: DeviceAPI<T> + DeviceCreationAnyAPI<T>,

pub fn to_layout<D2>(&self, layout: Layout<D2>) -> TensorCow<'_, T, B, D2>

where D2: DimAPI, B: OpAssignArbitaryAPI<T, D2, D>,

Convert tensor to the other layout.

See also

to_layout

pub fn to_layout_f<D2>( &self, layout: Layout<D2>, ) -> Result<TensorCow<'_, T, B, D2>>

where D2: DimAPI, B: OpAssignArbitaryAPI<T, D2, D>,

pub fn into_layout_f<D2>(self, layout: Layout<D2>) -> Result<Tensor<T, B, D2>>

where D2: DimAPI, B: OpAssignArbitaryAPI<T, D2, D> + OpAssignAPI<T, D2>, B::Raw: Clone + 'a,

pub fn into_layout<D2>(self, layout: Layout<D2>) -> Tensor<T, B, D2>

where D2: DimAPI, B: OpAssignArbitaryAPI<T, D2, D> + OpAssignAPI<T, D2>, B::Raw: Clone + 'a,

pub fn change_layout_f<D2>( self, layout: Layout<D2>, ) -> Result<TensorCow<'a, T, B, D2>>

where D2: DimAPI, B: OpAssignArbitaryAPI<T, D2, D>,

pub fn change_layout<D2>(self, layout: Layout<D2>) -> TensorCow<'a, T, B, D2>

where D2: DimAPI, B: OpAssignArbitaryAPI<T, D2, D>,

impl<'a, R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw> + DataIntoCowAPI<'a>, D: DimAPI, T: Clone, B: DeviceAPI<T> + DeviceCreationAnyAPI<T>,

pub fn to_contig(&self, order: FlagOrder) -> TensorCow<'_, T, B, D>

where B: OpAssignArbitaryAPI<T, D, D>,

Convert tensor to contiguous, with specified layout.

pub fn to_contig_f(&self, order: FlagOrder) -> Result<TensorCow<'_, T, B, D>>

where B: OpAssignArbitaryAPI<T, D, D>,

pub fn into_contig_f(self, order: FlagOrder) -> Result<Tensor<T, B, D>>

where B: OpAssignArbitaryAPI<T, D, D> + OpAssignAPI<T, D>, B::Raw: Clone + 'a,

pub fn into_contig(self, order: FlagOrder) -> Tensor<T, B, D>

where B: OpAssignArbitaryAPI<T, D, D> + OpAssignAPI<T, D>, B::Raw: Clone + 'a,

pub fn change_contig_f(self, order: FlagOrder) -> Result<TensorCow<'a, T, B, D>>

where B: OpAssignArbitaryAPI<T, D, D>,

pub fn change_contig(self, order: FlagOrder) -> TensorCow<'a, T, B, D>

where B: OpAssignArbitaryAPI<T, D, D>,

impl<'a, R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw> + DataIntoCowAPI<'a>, D: DimAPI, T: Clone, B: DeviceAPI<T> + DeviceCreationAnyAPI<T>,

pub fn to_prefer(&self, order: FlagOrder) -> TensorCow<'_, T, B, D>

where B: OpAssignArbitaryAPI<T, D, D>,

Convert tensor to contiguous, with specified layout.

pub fn to_prefer_f(&self, order: FlagOrder) -> Result<TensorCow<'_, T, B, D>>

where B: OpAssignArbitaryAPI<T, D, D>,

pub fn into_prefer_f(self, order: FlagOrder) -> Result<Tensor<T, B, D>>

where B: OpAssignArbitaryAPI<T, D, D> + OpAssignAPI<T, D>, B::Raw: Clone + 'a,

pub fn into_prefer(self, order: FlagOrder) -> Tensor<T, B, D>

where B: OpAssignArbitaryAPI<T, D, D> + OpAssignAPI<T, D>, B::Raw: Clone + 'a,

pub fn change_prefer_f(self, order: FlagOrder) -> Result<TensorCow<'a, T, B, D>>

where B: OpAssignArbitaryAPI<T, D, D>,

pub fn change_prefer(self, order: FlagOrder) -> TensorCow<'a, T, B, D>

where B: OpAssignArbitaryAPI<T, D, D>,

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, D: DimAPI, B: DeviceAPI<T>,

pub fn map_fnmut_f<'f, TOut>( &self, f: impl FnMut(&T) -> TOut + 'f, ) -> Result<Tensor<TOut, B, D>>

where B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutA_RefB_API<TOut, T, D, dyn FnMut(&mut TOut, &T) + 'f>,

Call f by reference on each element and create a new tensor with the new values.

pub fn map_fnmut<'f, TOut>( &self, f: impl FnMut(&T) -> TOut + 'f, ) -> Tensor<TOut, B, D>

where B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutA_RefB_API<TOut, T, D, dyn FnMut(&mut TOut, &T) + 'f>,

Call f by reference on each element and create a new tensor with the new values.

pub fn mapv_fnmut_f<'f, TOut>( &self, f: impl FnMut(T) -> TOut + 'f, ) -> Result<Tensor<TOut, B, D>>

where B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutA_RefB_API<TOut, T, D, dyn FnMut(&mut TOut, &T) + 'f>, T: Clone,

Call f by value on each element and create a new tensor with the new values.

pub fn mapv_fnmut<'f, TOut>( &self, f: impl FnMut(T) -> TOut + 'f, ) -> Tensor<TOut, B, D>

where B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutA_RefB_API<TOut, T, D, dyn FnMut(&mut TOut, &T) + 'f>, T: Clone,

Call f by value on each element and create a new tensor with the new values.

pub fn mapi_fnmut_f<'f>(&mut self, f: impl FnMut(&mut T) + 'f) -> Result<()>

where R: DataMutAPI<Data = B::Raw>, B: DeviceOp_MutA_API<T, D, dyn FnMut(&mut T) + 'f>,

Modify the tensor in place by calling f by mutable reference on each element.

pub fn mapi_fnmut<'f>(&mut self, f: impl FnMut(&mut T) + 'f)

where R: DataMutAPI<Data = B::Raw>, B: DeviceOp_MutA_API<T, D, dyn FnMut(&mut T) + 'f>,

Modify the tensor in place by calling f by mutable reference on each element.

pub fn mapvi_fnmut_f<'f>(&mut self, f: impl FnMut(T) -> T + 'f) -> Result<()>

where R: DataMutAPI<Data = B::Raw>, T: Clone, B: DeviceOp_MutA_API<T, D, dyn FnMut(&mut T) + 'f>,

Modify the tensor in place by calling f by value on each element.

pub fn mapvi_fnmut<'f>(&mut self, f: impl FnMut(T) -> T + 'f)

where R: DataMutAPI<Data = B::Raw>, T: Clone, B: DeviceOp_MutA_API<T, D, dyn FnMut(&mut T) + 'f>,

Modify the tensor in place by calling f by value on each element.

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, D: DimAPI, B: DeviceAPI<T>, T: Clone,

pub fn mapb_fnmut_f<'f, R2, T2, D2, DOut, TOut>( &self, other: &TensorAny<R2, T2, B, D2>, f: impl FnMut(&T, &T2) -> TOut + 'f, ) -> Result<Tensor<TOut, B, DOut>>

where R2: DataAPI<Data = <B as DeviceRawAPI<T2>>::Raw>, D2: DimAPI, DOut: DimAPI, D: DimMaxAPI<D2, Max = DOut>, B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutC_RefA_RefB_API<T, T2, TOut, DOut, dyn FnMut(&mut TOut, &T, &T2) + 'f>,

pub fn mapb_fnmut<'f, R2, T2, D2, DOut, TOut>( &self, other: &TensorAny<R2, T2, B, D2>, f: impl FnMut(&T, &T2) -> TOut + 'f, ) -> Tensor<TOut, B, DOut>

where R2: DataAPI<Data = <B as DeviceRawAPI<T2>>::Raw>, D2: DimAPI, DOut: DimAPI, D: DimMaxAPI<D2, Max = DOut>, B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutC_RefA_RefB_API<T, T2, TOut, DOut, dyn FnMut(&mut TOut, &T, &T2) + 'f>,

pub fn mapvb_fnmut_f<'f, R2, T2, D2, DOut, TOut>( &self, other: &TensorAny<R2, T2, B, D2>, f: impl FnMut(T, T2) -> TOut + 'f, ) -> Result<Tensor<TOut, B, DOut>>

where R2: DataAPI<Data = <B as DeviceRawAPI<T2>>::Raw>, D2: DimAPI, DOut: DimAPI, D: DimMaxAPI<D2, Max = DOut>, T: Clone, T2: Clone, B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutC_RefA_RefB_API<T, T2, TOut, DOut, dyn FnMut(&mut TOut, &T, &T2) + 'f>,

pub fn mapvb_fnmut<'f, R2, T2, D2, DOut, TOut>( &self, other: &TensorAny<R2, T2, B, D2>, f: impl FnMut(T, T2) -> TOut + 'f, ) -> Tensor<TOut, B, DOut>

where R2: DataAPI<Data = <B as DeviceRawAPI<T2>>::Raw>, D2: DimAPI, DOut: DimAPI, D: DimMaxAPI<D2, Max = DOut>, T: Clone, T2: Clone, B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutC_RefA_RefB_API<T, T2, TOut, DOut, dyn FnMut(&mut TOut, &T, &T2) + 'f>,

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, D: DimAPI, B: DeviceAPI<T>,

pub fn map_f<'f, TOut>( &self, f: impl Fn(&T) -> TOut + Send + Sync + 'f, ) -> Result<Tensor<TOut, B, D>>

where B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutA_RefB_API<TOut, T, D, dyn Fn(&mut TOut, &T) + Send + Sync + 'f>,

Call f by reference on each element and create a new tensor with the new values.

pub fn map<'f, TOut>( &self, f: impl Fn(&T) -> TOut + Send + Sync + 'f, ) -> Tensor<TOut, B, D>

where B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutA_RefB_API<TOut, T, D, dyn Fn(&mut TOut, &T) + Send + Sync + 'f>,

Call f by reference on each element and create a new tensor with the new values.

pub fn mapv_f<'f, TOut>( &self, f: impl Fn(T) -> TOut + Send + Sync + 'f, ) -> Result<Tensor<TOut, B, D>>

where B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutA_RefB_API<TOut, T, D, dyn Fn(&mut TOut, &T) + Send + Sync + 'f>, T: Clone,

Call f by value on each element and create a new tensor with the new values.

pub fn mapv<'f, TOut>( &self, f: impl Fn(T) -> TOut + Send + Sync + 'f, ) -> Tensor<TOut, B, D>

where B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutA_RefB_API<TOut, T, D, dyn Fn(&mut TOut, &T) + Send + Sync + 'f>, T: Clone,

Call f by value on each element and create a new tensor with the new values.

pub fn mapi_f<'f>( &mut self, f: impl Fn(&mut T) + Send + Sync + 'f, ) -> Result<()>

where R: DataMutAPI<Data = B::Raw>, B: DeviceOp_MutA_API<T, D, dyn Fn(&mut T) + Send + Sync + 'f>,

Modify the tensor in place by calling f by mutable reference on each element.

pub fn mapi<'f>(&mut self, f: impl Fn(&mut T) + Send + Sync + 'f)

where R: DataMutAPI<Data = B::Raw>, B: DeviceOp_MutA_API<T, D, dyn Fn(&mut T) + Send + Sync + 'f>,

Modify the tensor in place by calling f by mutable reference on each element.

pub fn mapvi_f<'f>( &mut self, f: impl Fn(T) -> T + Send + Sync + 'f, ) -> Result<()>

where R: DataMutAPI<Data = B::Raw>, T: Clone, B: DeviceOp_MutA_API<T, D, dyn Fn(&mut T) + Send + Sync + 'f>,

Modify the tensor in place by calling f by value on each element.

pub fn mapvi<'f>(&mut self, f: impl Fn(T) -> T + Send + Sync + 'f)

where R: DataMutAPI<Data = B::Raw>, T: Clone, B: DeviceOp_MutA_API<T, D, dyn Fn(&mut T) + Send + Sync + 'f>,

Modify the tensor in place by calling f by value on each element.

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, D: DimAPI, B: DeviceAPI<T>, T: Clone,

pub fn mapb_f<'f, R2, T2, D2, DOut, TOut>( &self, other: &TensorAny<R2, T2, B, D2>, f: impl Fn(&T, &T2) -> TOut + Send + Sync + 'f, ) -> Result<Tensor<TOut, B, DOut>>

where R2: DataAPI<Data = <B as DeviceRawAPI<T2>>::Raw>, D2: DimAPI, DOut: DimAPI, D: DimMaxAPI<D2, Max = DOut>, B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutC_RefA_RefB_API<T, T2, TOut, DOut, dyn Fn(&mut TOut, &T, &T2) + Send + Sync + 'f>,

pub fn mapb<'f, R2, T2, D2, DOut, TOut>( &self, other: &TensorAny<R2, T2, B, D2>, f: impl Fn(&T, &T2) -> TOut + Send + Sync + 'f, ) -> Tensor<TOut, B, DOut>

where R2: DataAPI<Data = <B as DeviceRawAPI<T2>>::Raw>, D2: DimAPI, DOut: DimAPI, D: DimMaxAPI<D2, Max = DOut>, B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutC_RefA_RefB_API<T, T2, TOut, DOut, dyn Fn(&mut TOut, &T, &T2) + Send + Sync + 'f>,

pub fn mapvb_f<'f, R2, T2, D2, DOut, TOut>( &self, other: &TensorAny<R2, T2, B, D2>, f: impl Fn(T, T2) -> TOut + Send + Sync + 'f, ) -> Result<Tensor<TOut, B, DOut>>

where R2: DataAPI<Data = <B as DeviceRawAPI<T2>>::Raw>, D2: DimAPI, DOut: DimAPI, D: DimMaxAPI<D2, Max = DOut>, T: Clone, T2: Clone, B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutC_RefA_RefB_API<T, T2, TOut, DOut, dyn Fn(&mut TOut, &T, &T2) + Send + Sync + 'f>,

pub fn mapvb<'f, R2, T2, D2, DOut, TOut>( &self, other: &TensorAny<R2, T2, B, D2>, f: impl Fn(T, T2) -> TOut + Send + Sync + 'f, ) -> Tensor<TOut, B, DOut>

where R2: DataAPI<Data = <B as DeviceRawAPI<T2>>::Raw>, D2: DimAPI, DOut: DimAPI, D: DimMaxAPI<D2, Max = DOut>, T: Clone, T2: Clone, B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutC_RefA_RefB_API<T, T2, TOut, DOut, dyn Fn(&mut TOut, &T, &T2) + Send + Sync + 'f>,

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T>, D: DimAPI,

pub fn matmul_f<RB, TB, TC, DB, DC>( &self, rhs: &TensorAny<RB, TB, B, DB>, ) -> Result<Tensor<TC, B, DC>>

where RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DB: DimAPI, DC: DimAPI, T: Mul<TB, Output = TC>, TC: Mul<TC, Output = TC> + Add<TC, Output = TC> + Zero + One, B: DeviceAPI<TB> + DeviceAPI<TC> + DeviceCreationAnyAPI<TC> + DeviceMatMulAPI<T, TB, TC, D, DB, DC>, LayoutMatMulConfig<D, DB>: LayoutMatMulAPI<D, DB, DC = DC>,

pub fn matmul<RB, TB, TC, DB, DC>( &self, rhs: &TensorAny<RB, TB, B, DB>, ) -> Tensor<TC, B, DC>

where RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DB: DimAPI, DC: DimAPI, T: Mul<TB, Output = TC>, TC: Mul<TC, Output = TC> + Add<TC, Output = TC> + Zero + One, B: DeviceAPI<TB> + DeviceAPI<TC> + DeviceCreationAnyAPI<TC> + DeviceMatMulAPI<T, TB, TC, D, DB, DC>, LayoutMatMulConfig<D, DB>: LayoutMatMulAPI<D, DB, DC = DC>,

pub fn matmul_with_output_f<RB, RC, TB, TC, DB, DC>( &self, rhs: &TensorAny<RB, TB, B, DB>, c: &mut TensorAny<RC, TC, B, DC>, ) -> Result<()>

where RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, RC: DataMutAPI<Data = <B as DeviceRawAPI<TC>>::Raw>, DB: DimAPI, DC: DimAPI, T: Mul<TB, Output = TC>, TC: Mul<TC, Output = TC> + Add<TC, Output = TC> + Zero + One, B: DeviceAPI<TB> + DeviceAPI<TC> + DeviceMatMulAPI<T, TB, TC, D, DB, DC>,

pub fn matmul_with_output<RB, RC, TB, TC, DB, DC>( &self, rhs: &TensorAny<RB, TB, B, DB>, c: &mut TensorAny<RC, TC, B, DC>, )

where RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, RC: DataMutAPI<Data = <B as DeviceRawAPI<TC>>::Raw>, DB: DimAPI, DC: DimAPI, T: Mul<TB, Output = TC>, TC: Mul<TC, Output = TC> + Add<TC, Output = TC> + Zero + One, B: DeviceAPI<TB> + DeviceAPI<TC> + DeviceMatMulAPI<T, TB, TC, D, DB, DC>,

pub fn matmul_from_f<RA, RB, TA, TB, DA, DB>( &mut self, a: &TensorAny<RA, TA, B, DA>, b: &TensorAny<RB, TB, B, DB>, alpha: T, beta: T, ) -> Result<()>

where R: DataMutAPI<Data = <B as DeviceRawAPI<T>>::Raw>, RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI, DB: DimAPI, TA: Mul<TB, Output = T>, T: Mul<T, Output = T> + Add<T, Output = T> + Zero + One, B: DeviceAPI<TA> + DeviceAPI<TB> + DeviceMatMulAPI<TA, TB, T, DA, DB, D>,

pub fn matmul_from<RA, RB, TA, TB, DA, DB>( &mut self, a: &TensorAny<RA, TA, B, DA>, b: &TensorAny<RB, TB, B, DB>, alpha: T, beta: T, )

where R: DataMutAPI<Data = <B as DeviceRawAPI<T>>::Raw>, RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI, DB: DimAPI, TA: Mul<TB, Output = T>, T: Mul<T, Output = T> + Add<T, Output = T> + Zero + One, B: DeviceAPI<TA> + DeviceAPI<TB> + DeviceMatMulAPI<TA, TB, T, DA, DB, D>,

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, D: DimAPI + DimSmallerOneAPI, D::SmallerOne: DimAPI, B: DeviceAPI<T> + DeviceOpPackTriAPI<T> + DeviceCreationAnyAPI<T>,

pub fn pack_tri_f(&self, uplo: FlagUpLo) -> Result<Tensor<T, B, D::SmallerOne>>

pub fn pack_tri(&self, uplo: FlagUpLo) -> Tensor<T, B, D::SmallerOne>

pub fn pack_tril_f(&self) -> Result<Tensor<T, B, D::SmallerOne>>

pub fn pack_tril(&self) -> Tensor<T, B, D::SmallerOne>

pub fn pack_triu_f(&self) -> Result<Tensor<T, B, D::SmallerOne>>

pub fn pack_triu(&self) -> Tensor<T, B, D::SmallerOne>

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, D: DimAPI + DimLargerOneAPI, D::LargerOne: DimAPI, B: DeviceAPI<T> + DeviceOpUnpackTriAPI<T> + DeviceCreationAnyAPI<T>,

pub fn unpack_tri( &self, uplo: FlagUpLo, symm: FlagSymm, ) -> Result<Tensor<T, B, D::LargerOne>>

pub fn unpack_tril(&self, symm: FlagSymm) -> Tensor<T, B, D::LargerOne>

pub fn unpack_triu(&self, symm: FlagSymm) -> Tensor<T, B, D::LargerOne>

pub fn unpack_tri_f( &self, uplo: FlagUpLo, symm: FlagSymm, ) -> Result<Tensor<T, B, D::LargerOne>>

pub fn unpack_tril_f( &self, symm: FlagSymm, ) -> Result<Tensor<T, B, D::LargerOne>>

impl<R, T, B, D> TensorAny<R, T, B, D>

where D: DimAPI, B: DeviceAPI<T>, R: DataAPI<Data = B::Raw>,

Methods for tensor ownership conversion.

pub fn view(&self) -> TensorView<'_, T, B, D>

Get a view of tensor.

pub fn view_mut(&mut self) -> TensorMut<'_, T, B, D>

where R: DataMutAPI,

Get a mutable view of tensor.

pub fn into_cow<'a>(self) -> TensorCow<'a, T, B, D>

where R: DataIntoCowAPI<'a>,

Convert current tensor into copy-on-write.

pub fn into_owned_keep_layout(self) -> Tensor<T, B, D>

where R::Data: Clone, R: DataCloneAPI,

Convert tensor into owned tensor.

Data is either moved or fully cloned. Layout is not involved; i.e. all underlying data is moved or cloned without changing layout.

See also

Tensor::into_owned keep data in some conditions, otherwise clone. This function can avoid cases where data memory bulk is large, but tensor view is small.

pub fn into_shared_keep_layout(self) -> TensorArc<T, B, D>

where R::Data: Clone, R: DataCloneAPI,

Convert tensor into shared tensor.

Data is either moved or cloned. Layout is not involved; i.e. all underlying data is moved or cloned without changing layout.

See also

Tensor::into_shared keep data in some conditions, otherwise clone. This function can avoid cases where data memory bulk is large, but tensor view is small.

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataCloneAPI<Data = B::Raw>, R::Data: Clone, D: DimAPI, T: Clone, B: DeviceAPI<T> + DeviceCreationAnyAPI<T> + OpAssignAPI<T, D>,

pub fn into_owned(self) -> Tensor<T, B, D>

pub fn into_shared(self) -> TensorArc<T, B, D>

pub fn to_owned(&self) -> Tensor<T, B, D>

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw> + DataForceMutAPI<B::Raw>, B: DeviceAPI<T>, D: DimAPI,

pub unsafe fn force_mut(&self) -> TensorMut<'_, T, B, D>

Safety

This function is highly unsafe, as it entirely bypasses Rust’s lifetime and borrowing rules.

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, T: Clone, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>> + DeviceCreationAnyAPI<T> + OpAssignAPI<T, Ix1>,

pub fn to_raw_f(&self) -> Result<Vec<T>>

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

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataCloneAPI<Data = B::Raw>, B::Raw: Clone, T: Clone, D: DimAPI, B: DeviceAPI<T>,

pub fn to_scalar_f(&self) -> Result<T>

pub fn to_scalar(&self) -> T

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>>,

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

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

where R: DataMutAPI,

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, D: DimAPI, B: OpSumAPI<T, D>,

pub fn sum_all_f(&self) -> Result<B::TOut>

pub fn sum_all(&self) -> B::TOut

pub fn sum_axes_f<I>(&self, axes: I) -> Result<Tensor<B::TOut, B, IxD>>

where B: DeviceCreationAnyAPI<B::TOut>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn sum_axes<I>(&self, axes: I) -> Tensor<B::TOut, B, IxD>

where B: DeviceCreationAnyAPI<B::TOut>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn sum_f(&self) -> Result<B::TOut>

pub fn sum(&self) -> B::TOut

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, D: DimAPI, B: OpMinAPI<T, D>,

pub fn min_all_f(&self) -> Result<B::TOut>

pub fn min_all(&self) -> B::TOut

pub fn min_axes_f<I>(&self, axes: I) -> Result<Tensor<B::TOut, B, IxD>>

where B: DeviceCreationAnyAPI<B::TOut>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn min_axes<I>(&self, axes: I) -> Tensor<B::TOut, B, IxD>

where B: DeviceCreationAnyAPI<B::TOut>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn min_f(&self) -> Result<B::TOut>

pub fn min(&self) -> B::TOut

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, D: DimAPI, B: OpMaxAPI<T, D>,

pub fn max_all_f(&self) -> Result<B::TOut>

pub fn max_all(&self) -> B::TOut

pub fn max_axes_f<I>(&self, axes: I) -> Result<Tensor<B::TOut, B, IxD>>

where B: DeviceCreationAnyAPI<B::TOut>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn max_axes<I>(&self, axes: I) -> Tensor<B::TOut, B, IxD>

where B: DeviceCreationAnyAPI<B::TOut>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn max_f(&self) -> Result<B::TOut>

pub fn max(&self) -> B::TOut

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, D: DimAPI, B: OpProdAPI<T, D>,

pub fn prod_all_f(&self) -> Result<B::TOut>

pub fn prod_all(&self) -> B::TOut

pub fn prod_axes_f<I>(&self, axes: I) -> Result<Tensor<B::TOut, B, IxD>>

where B: DeviceCreationAnyAPI<B::TOut>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn prod_axes<I>(&self, axes: I) -> Tensor<B::TOut, B, IxD>

where B: DeviceCreationAnyAPI<B::TOut>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn prod_f(&self) -> Result<B::TOut>

pub fn prod(&self) -> B::TOut

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, D: DimAPI, B: OpMeanAPI<T, D>,

pub fn mean_all_f(&self) -> Result<B::TOut>

pub fn mean_all(&self) -> B::TOut

pub fn mean_axes_f<I>(&self, axes: I) -> Result<Tensor<B::TOut, B, IxD>>

where B: DeviceCreationAnyAPI<B::TOut>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn mean_axes<I>(&self, axes: I) -> Tensor<B::TOut, B, IxD>

where B: DeviceCreationAnyAPI<B::TOut>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn mean_f(&self) -> Result<B::TOut>

pub fn mean(&self) -> B::TOut

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, D: DimAPI, B: OpVarAPI<T, D>,

pub fn var_all_f(&self) -> Result<B::TOut>

pub fn var_all(&self) -> B::TOut

pub fn var_axes_f<I>(&self, axes: I) -> Result<Tensor<B::TOut, B, IxD>>

where B: DeviceCreationAnyAPI<B::TOut>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn var_axes<I>(&self, axes: I) -> Tensor<B::TOut, B, IxD>

where B: DeviceCreationAnyAPI<B::TOut>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn var_f(&self) -> Result<B::TOut>

pub fn var(&self) -> B::TOut

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, D: DimAPI, B: OpStdAPI<T, D>,

pub fn std_all_f(&self) -> Result<B::TOut>

pub fn std_all(&self) -> B::TOut

pub fn std_axes_f<I>(&self, axes: I) -> Result<Tensor<B::TOut, B, IxD>>

where B: DeviceCreationAnyAPI<B::TOut>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn std_axes<I>(&self, axes: I) -> Tensor<B::TOut, B, IxD>

where B: DeviceCreationAnyAPI<B::TOut>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn std_f(&self) -> Result<B::TOut>

pub fn std(&self) -> B::TOut

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, D: DimAPI, B: OpL2NormAPI<T, D>,

pub fn l2_norm_all_f(&self) -> Result<B::TOut>

pub fn l2_norm_all(&self) -> B::TOut

pub fn l2_norm_axes_f<I>(&self, axes: I) -> Result<Tensor<B::TOut, B, IxD>>

where B: DeviceCreationAnyAPI<B::TOut>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn l2_norm_axes<I>(&self, axes: I) -> Tensor<B::TOut, B, IxD>

where B: DeviceCreationAnyAPI<B::TOut>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn l2_norm_f(&self) -> Result<B::TOut>

pub fn l2_norm(&self) -> B::TOut

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, D: DimAPI, B: OpArgMinAPI<T, D>,

pub fn argmin_all_f(&self) -> Result<B::TOut>

pub fn argmin_all(&self) -> B::TOut

pub fn argmin_axes_f<I>(&self, axes: I) -> Result<Tensor<B::TOut, B, IxD>>

where B: DeviceCreationAnyAPI<B::TOut>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn argmin_axes<I>(&self, axes: I) -> Tensor<B::TOut, B, IxD>

where B: DeviceCreationAnyAPI<B::TOut>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn argmin_f(&self) -> Result<B::TOut>

pub fn argmin(&self) -> B::TOut

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, D: DimAPI, B: OpArgMaxAPI<T, D>,

pub fn argmax_all_f(&self) -> Result<B::TOut>

pub fn argmax_all(&self) -> B::TOut

pub fn argmax_axes_f<I>(&self, axes: I) -> Result<Tensor<B::TOut, B, IxD>>

where B: DeviceCreationAnyAPI<B::TOut>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn argmax_axes<I>(&self, axes: I) -> Tensor<B::TOut, B, IxD>

where B: DeviceCreationAnyAPI<B::TOut>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn argmax_f(&self) -> Result<B::TOut>

pub fn argmax(&self) -> B::TOut

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, D: DimAPI, B: OpUnraveledArgMinAPI<T, D>,

pub fn unraveled_argmin_all_f(&self) -> Result<D>

pub fn unraveled_argmin_all(&self) -> D

pub fn unraveled_argmin_axes_f<I>(&self, axes: I) -> Result<Tensor<IxD, B, IxD>>

where B: DeviceAPI<IxD>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn unraveled_argmin_axes<I>(&self, axes: I) -> Tensor<IxD, B, IxD>

where B: DeviceAPI<IxD>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn unraveled_argmin_f(&self) -> Result<D>

pub fn unraveled_argmin(&self) -> D

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, D: DimAPI, B: OpUnraveledArgMaxAPI<T, D>,

pub fn unraveled_argmax_all_f(&self) -> Result<D>

pub fn unraveled_argmax_all(&self) -> D

pub fn unraveled_argmax_axes_f<I>(&self, axes: I) -> Result<Tensor<IxD, B, IxD>>

where B: DeviceAPI<IxD>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn unraveled_argmax_axes<I>(&self, axes: I) -> Tensor<IxD, B, IxD>

where B: DeviceAPI<IxD>, I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

pub fn unraveled_argmax_f(&self) -> Result<D>

pub fn unraveled_argmax(&self) -> D

impl<R, T, B, D> TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, D: DimAPI, B: DeviceAPI<T>,

pub fn new_f(storage: Storage<R, T, B>, layout: Layout<D>) -> Result<Self>

pub fn new(storage: Storage<R, T, B>, layout: Layout<D>) -> Self

pub fn device(&self) -> &B

pub fn data(&self) -> &R

pub fn data_mut(&mut self) -> &mut R

pub fn raw(&self) -> &B::Raw

pub fn raw_mut(&mut self) -> &mut B::Raw

where R: DataMutAPI<Data = B::Raw>,

Trait Implementations

impl<TRB, RA, TA, DA, B> AddAssign<TRB> for TensorAny<RA, TA, B, DA>

where RA: DataMutAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI, B: DeviceAPI<TA>, for<'a> &'a mut Self: TensorAddAssignAPI<TRB>,

fn add_assign(&mut self, b: TRB)

Performs the += operation.

impl<R, T, B, D> AsArrayAPI<()> for &TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, T: Clone, D: DimAPI, B: DeviceAPI<T> + DeviceCreationAnyAPI<T> + OpAssignAPI<T, D>,

type Out = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

fn asarray_f(self) -> Result<Self::Out>

fn asarray(self) -> Self::Out

where Self: Sized,

impl<TRB, RA, TA, DA, B> BitAndAssign<TRB> for TensorAny<RA, TA, B, DA>

where RA: DataMutAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI, B: DeviceAPI<TA>, for<'a> &'a mut Self: TensorBitAndAssignAPI<TRB>,

fn bitand_assign(&mut self, b: TRB)

Performs the &= operation.

impl<TRB, RA, TA, DA, B> BitOrAssign<TRB> for TensorAny<RA, TA, B, DA>

where RA: DataMutAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI, B: DeviceAPI<TA>, for<'a> &'a mut Self: TensorBitOrAssignAPI<TRB>,

fn bitor_assign(&mut self, b: TRB)

Performs the |= operation.

impl<TRB, RA, TA, DA, B> BitXorAssign<TRB> for TensorAny<RA, TA, B, DA>

where RA: DataMutAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI, B: DeviceAPI<TA>, for<'a> &'a mut Self: TensorBitXorAssignAPI<TRB>,

fn bitxor_assign(&mut self, b: TRB)

Performs the ^= operation.

impl<R, T, B, D> Debug for TensorAny<R, T, B, D>

where T: Clone + Debug, B: DeviceAPI<T> + Debug, B::Raw: Clone, D: DimAPI, R: DataCloneAPI<Data = B::Raw>,

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

Formats the value using the given formatter.

impl<R, T, B, D> DiagAPI<()> for &TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, T: Clone + Default, D: DimAPI, B: DeviceAPI<T> + DeviceCreationAnyAPI<T> + OpAssignAPI<T, Ix1>,

type Out = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, Vec<usize>>

fn diag_f(self) -> Result<Self::Out>

fn diag(self) -> Self::Out

where Self: Sized,

impl<R, T, B, D> Display for TensorAny<R, T, B, D>

where T: Clone + Display, B: DeviceAPI<T>, B::Raw: Clone, D: DimAPI, R: DataCloneAPI<Data = B::Raw>,

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

Formats the value using the given formatter.

impl<TRB, RA, TA, DA, B> DivAssign<TRB> for TensorAny<RA, TA, B, DA>

where RA: DataMutAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI, B: DeviceAPI<TA>, for<'a> &'a mut Self: TensorDivAssignAPI<TRB>,

fn div_assign(&mut self, b: TRB)

Performs the /= operation.

impl<R, T, B, D> EmptyLikeAPI<()> for &TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, D: DimAPI, B: DeviceAPI<T> + DeviceCreationAnyAPI<T>,

type Out = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

unsafe fn empty_like_f(self) -> Result<Self::Out>

Safety

unsafe fn empty_like(self) -> Self::Out

where Self: Sized,

Safety

impl<TRB, RA, TA, DA, B> MulAssign<TRB> for TensorAny<RA, TA, B, DA>

where RA: DataMutAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI, B: DeviceAPI<TA>, for<'a> &'a mut Self: TensorMulAssignAPI<TRB>,

fn mul_assign(&mut self, b: TRB)

Performs the *= operation.

impl<R, T, B, D> Neg for &TensorAny<R, T, B, D>

where D: DimAPI, for<'a> &'a TensorAny<R, T, B, D>: TensorNegAPI, R: DataAPI<Data = B::Raw>, B: DeviceAPI<T>,

type Output = <&TensorBase<Storage<R, T, B>, D> as TensorNegAPI>::Output

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<R, T, B, D> Neg for TensorAny<R, T, B, D>

where D: DimAPI, TensorAny<R, T, B, D>: TensorNegAPI, R: DataAPI<Data = B::Raw>, B: DeviceAPI<T>,

type Output = <TensorBase<Storage<R, T, B>, D> as TensorNegAPI>::Output

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<R, T, B, D> Not for &TensorAny<R, T, B, D>

where D: DimAPI, for<'a> &'a TensorAny<R, T, B, D>: TensorNotAPI, R: DataAPI<Data = B::Raw>, B: DeviceAPI<T>,

type Output = <&TensorBase<Storage<R, T, B>, D> as TensorNotAPI>::Output

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<R, T, B, D> Not for TensorAny<R, T, B, D>

where D: DimAPI, TensorAny<R, T, B, D>: TensorNotAPI, R: DataAPI<Data = B::Raw>, B: DeviceAPI<T>,

type Output = <TensorBase<Storage<R, T, B>, D> as TensorNotAPI>::Output

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<R, T, B, D> OnesLikeAPI<()> for &TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, T: Num, D: DimAPI, B: DeviceAPI<T> + DeviceCreationNumAPI<T>,

type Out = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

fn ones_like_f(self) -> Result<Self::Out>

fn ones_like(self) -> Self::Out

where Self: Sized,

impl<RA, RB, TA, TB, TC, DA, DB, DC, B> Rem<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorAny<RA, TA, B, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI, DB: DimAPI, DC: DimAPI, TA: Mul<TB, Output = TC>, TC: Mul<TC, Output = TC> + Add<TC, Output = TC> + Zero + One, B: DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<TC> + DeviceCreationAnyAPI<TC> + DeviceMatMulAPI<TA, TB, TC, DA, DB, DC>, LayoutMatMulConfig<DA, DB>: LayoutMatMulAPI<DA, DB, DC = DC>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TC>>::Raw>, TC, B>, DC>

The resulting type after applying the % operator.

fn rem(self, rhs: &TensorAny<RB, TB, B, DB>) -> Self::Output

Performs the % operation.

impl<RA, RB, TA, TB, TC, DA, DB, DC, B> Rem<&TensorBase<Storage<RB, TB, B>, DB>> for TensorAny<RA, TA, B, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI, DB: DimAPI, DC: DimAPI, TA: Mul<TB, Output = TC>, TC: Mul<TC, Output = TC> + Add<TC, Output = TC> + Zero + One, B: DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<TC> + DeviceCreationAnyAPI<TC> + DeviceMatMulAPI<TA, TB, TC, DA, DB, DC>, LayoutMatMulConfig<DA, DB>: LayoutMatMulAPI<DA, DB, DC = DC>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TC>>::Raw>, TC, B>, DC>

The resulting type after applying the % operator.

fn rem(self, rhs: &TensorAny<RB, TB, B, DB>) -> Self::Output

Performs the % operation.

impl<RA, RB, TA, TB, TC, DA, DB, DC, B> Rem<TensorBase<Storage<RB, TB, B>, DB>> for &TensorAny<RA, TA, B, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI, DB: DimAPI, DC: DimAPI, TA: Mul<TB, Output = TC>, TC: Mul<TC, Output = TC> + Add<TC, Output = TC> + Zero + One, B: DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<TC> + DeviceCreationAnyAPI<TC> + DeviceMatMulAPI<TA, TB, TC, DA, DB, DC>, LayoutMatMulConfig<DA, DB>: LayoutMatMulAPI<DA, DB, DC = DC>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TC>>::Raw>, TC, B>, DC>

The resulting type after applying the % operator.

fn rem(self, rhs: TensorAny<RB, TB, B, DB>) -> Self::Output

Performs the % operation.

impl<RA, RB, TA, TB, TC, DA, DB, DC, B> Rem<TensorBase<Storage<RB, TB, B>, DB>> for TensorAny<RA, TA, B, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI, DB: DimAPI, DC: DimAPI, TA: Mul<TB, Output = TC>, TC: Mul<TC, Output = TC> + Add<TC, Output = TC> + Zero + One, B: DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<TC> + DeviceCreationAnyAPI<TC> + DeviceMatMulAPI<TA, TB, TC, DA, DB, DC>, LayoutMatMulConfig<DA, DB>: LayoutMatMulAPI<DA, DB, DC = DC>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TC>>::Raw>, TC, B>, DC>

The resulting type after applying the % operator.

fn rem(self, rhs: TensorAny<RB, TB, B, DB>) -> Self::Output

Performs the % operation.

impl<TRB, RA, TA, DA, B> RemAssign<TRB> for TensorAny<RA, TA, B, DA>

where RA: DataMutAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI, B: DeviceAPI<TA>, for<'a> &'a mut Self: TensorRemAssignAPI<TRB>,

fn rem_assign(&mut self, b: TRB)

Performs the %= operation.

impl<TRB, RA, TA, DA, B> ShlAssign<TRB> for TensorAny<RA, TA, B, DA>

where RA: DataMutAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI, B: DeviceAPI<TA>, for<'a> &'a mut Self: TensorShlAssignAPI<TRB>,

fn shl_assign(&mut self, b: TRB)

Performs the <<= operation.

impl<TRB, RA, TA, DA, B> ShrAssign<TRB> for TensorAny<RA, TA, B, DA>

where RA: DataMutAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI, B: DeviceAPI<TA>, for<'a> &'a mut Self: TensorShrAssignAPI<TRB>,

fn shr_assign(&mut self, b: TRB)

Performs the >>= operation.

impl<TRB, RA, TA, DA, B> SubAssign<TRB> for TensorAny<RA, TA, B, DA>

where RA: DataMutAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI, B: DeviceAPI<TA>, for<'a> &'a mut Self: TensorSubAssignAPI<TRB>,

fn sub_assign(&mut self, b: TRB)

Performs the -= operation.

impl<RA, TA, DA, RB, TB, DB, B> TensorATan2API<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorAny<RA, TA, B, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceATan2API<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceATan2API<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceATan2API<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn atan2_f(self, b: &TensorAny<RB, TB, B, DB>) -> Result<Self::Output>

fn atan2(self, b: TRB) -> Self::Output

where Self: Sized,

impl<TA, DA, TB, DB, B, R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>> TensorATan2API<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for &TensorAny<R, TA, B, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceATan2API<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceATan2API<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceATan2API<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn atan2_f(self, b: TensorView<'_, TB, B, DB>) -> Result<Self::Output>

fn atan2(self, b: TRB) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorAbsAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAbsAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceAbsAPI<T, D>>::TOut>>::Raw>, <B as DeviceAbsAPI<T, D>>::TOut, B>, D>

fn abs_f(self) -> Result<Self::Output>

fn abs(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorAcosAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAcosAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceAcosAPI<T, D>>::TOut>>::Raw>, <B as DeviceAcosAPI<T, D>>::TOut, B>, D>

fn acos_f(self) -> Result<Self::Output>

fn acos(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorAcoshAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAcoshAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceAcoshAPI<T, D>>::TOut>>::Raw>, <B as DeviceAcoshAPI<T, D>>::TOut, B>, D>

fn acosh_f(self) -> Result<Self::Output>

fn acosh(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorAsinAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAsinAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceAsinAPI<T, D>>::TOut>>::Raw>, <B as DeviceAsinAPI<T, D>>::TOut, B>, D>

fn asin_f(self) -> Result<Self::Output>

fn asin(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorAsinhAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAsinhAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceAsinhAPI<T, D>>::TOut>>::Raw>, <B as DeviceAsinhAPI<T, D>>::TOut, B>, D>

fn asinh_f(self) -> Result<Self::Output>

fn asinh(self) -> Self::Output

where Self: Sized,

impl<RA, DA, RB, DB, T, B> TensorAssignAPI<&TensorBase<Storage<RB, T, B>, DB>> for TensorAny<RA, T, B, DA>

where RA: DataMutAPI<Data = B::Raw>, RB: DataAPI<Data = B::Raw>, DA: DimAPI, DB: DimAPI, B: DeviceAPI<T> + OpAssignAPI<T, DA>,

fn assign_f(a: &mut Self, b: &TensorAny<RB, T, B, DB>) -> Result<()>

fn assign(a: &mut Self, b: TRB)

impl<RA, DA, RB, DB, T, B> TensorAssignAPI<TensorBase<Storage<RB, T, B>, DB>> for TensorAny<RA, T, B, DA>

where RA: DataMutAPI<Data = B::Raw>, RB: DataAPI<Data = B::Raw>, DA: DimAPI, DB: DimAPI, B: DeviceAPI<T> + OpAssignAPI<T, DA>,

fn assign_f(a: &mut Self, b: TensorAny<RB, T, B, DB>) -> Result<()>

fn assign(a: &mut Self, b: TRB)

impl<R, T, B, D> TensorAtanAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAtanAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceAtanAPI<T, D>>::TOut>>::Raw>, <B as DeviceAtanAPI<T, D>>::TOut, B>, D>

fn atan_f(self) -> Result<Self::Output>

fn atan(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorAtanhAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAtanhAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceAtanhAPI<T, D>>::TOut>>::Raw>, <B as DeviceAtanhAPI<T, D>>::TOut, B>, D>

fn atanh_f(self) -> Result<Self::Output>

fn atanh(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorCeilAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceCeilAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceCeilAPI<T, D>>::TOut>>::Raw>, <B as DeviceCeilAPI<T, D>>::TOut, B>, D>

fn ceil_f(self) -> Result<Self::Output>

fn ceil(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorConjAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceConjAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceConjAPI<T, D>>::TOut>>::Raw>, <B as DeviceConjAPI<T, D>>::TOut, B>, D>

fn conj_f(self) -> Result<Self::Output>

fn conj(self) -> Self::Output

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorCopySignAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorAny<RA, TA, B, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceCopySignAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceCopySignAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceCopySignAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn copysign_f(self, b: &TensorAny<RB, TB, B, DB>) -> Result<Self::Output>

fn copysign(self, b: TRB) -> Self::Output

where Self: Sized,

impl<TA, DA, TB, DB, B, R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>> TensorCopySignAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for &TensorAny<R, TA, B, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceCopySignAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceCopySignAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceCopySignAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn copysign_f(self, b: TensorView<'_, TB, B, DB>) -> Result<Self::Output>

fn copysign(self, b: TRB) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorCosAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceCosAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceCosAPI<T, D>>::TOut>>::Raw>, <B as DeviceCosAPI<T, D>>::TOut, B>, D>

fn cos_f(self) -> Result<Self::Output>

fn cos(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorCoshAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceCoshAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceCoshAPI<T, D>>::TOut>>::Raw>, <B as DeviceCoshAPI<T, D>>::TOut, B>, D>

fn cosh_f(self) -> Result<Self::Output>

fn cosh(self) -> Self::Output

where Self: Sized,

impl<'a, R, T, B, D, BOut> TensorDeviceChangeAPI<'a, BOut> for TensorAny<R, T, B, D>

where B: DeviceRawAPI<T> + DeviceChangeAPI<'a, BOut, R, T, D>, BOut: DeviceRawAPI<T>, D: DimAPI, R: DataAPI<Data = B::Raw>,

type Repr = <B as DeviceChangeAPI<'a, BOut, R, T, D>>::Repr

type ReprTo = <B as DeviceChangeAPI<'a, BOut, R, T, D>>::ReprTo

type Type = T

type Dim = D

fn change_device_f( self, device: &BOut, ) -> Result<TensorAny<B::Repr, T, BOut, D>>

fn into_device_f(self, device: &BOut) -> Result<Tensor<T, BOut, D>>

fn to_device_f( &'a self, device: &BOut, ) -> Result<TensorAny<B::ReprTo, Self::Type, BOut, Self::Dim>>

fn change_device( self, device: &BOut, ) -> TensorAny<Self::Repr, Self::Type, BOut, Self::Dim>

where Self: Sized,

fn into_device( self, device: &BOut, ) -> TensorAny<DataOwned<BOut::Raw>, Self::Type, BOut, Self::Dim>

where Self: Sized,

fn to_device( &'l self, device: &BOut, ) -> TensorAny<Self::ReprTo, Self::Type, BOut, Self::Dim>

impl<RA, TA, DA, RB, TB, DB, B> TensorEqualAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorAny<RA, TA, B, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceEqualAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn equal_f(self, b: &TensorAny<RB, TB, B, DB>) -> Result<Self::Output>

fn equal(self, b: TRB) -> Self::Output

where Self: Sized,

impl<TA, DA, TB, DB, B, R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>> TensorEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for &TensorAny<R, TA, B, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceEqualAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn equal_f(self, b: TensorView<'_, TB, B, DB>) -> Result<Self::Output>

fn equal(self, b: TRB) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorExpAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceExpAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceExpAPI<T, D>>::TOut>>::Raw>, <B as DeviceExpAPI<T, D>>::TOut, B>, D>

fn exp_f(self) -> Result<Self::Output>

fn exp(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorExpm1API for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceExpm1API<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceExpm1API<T, D>>::TOut>>::Raw>, <B as DeviceExpm1API<T, D>>::TOut, B>, D>

fn expm1_f(self) -> Result<Self::Output>

fn expm1(self) -> Self::Output

where Self: Sized,

impl<RA, DA, T, B> TensorFillAPI<T> for TensorAny<RA, T, B, DA>

where RA: DataMutAPI<Data = B::Raw>, DA: DimAPI, B: DeviceAPI<T> + OpAssignAPI<T, DA>,

fn fill_f(a: &mut Self, b: T) -> Result<()>

fn fill(a: &mut Self, b: T)

impl<R, T, B, D> TensorFloorAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceFloorAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceFloorAPI<T, D>>::TOut>>::Raw>, <B as DeviceFloorAPI<T, D>>::TOut, B>, D>

fn floor_f(self) -> Result<Self::Output>

fn floor(self) -> Self::Output

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorFloorDivideAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorAny<RA, TA, B, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceFloorDivideAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceFloorDivideAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceFloorDivideAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn floor_divide_f(self, b: &TensorAny<RB, TB, B, DB>) -> Result<Self::Output>

fn floor_divide(self, b: TRB) -> Self::Output

where Self: Sized,

impl<TA, DA, TB, DB, B, R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>> TensorFloorDivideAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for &TensorAny<R, TA, B, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceFloorDivideAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceFloorDivideAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceFloorDivideAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn floor_divide_f(self, b: TensorView<'_, TB, B, DB>) -> Result<Self::Output>

fn floor_divide(self, b: TRB) -> Self::Output

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorGreaterAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorAny<RA, TA, B, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceGreaterAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceGreaterAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceGreaterAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn greater_f(self, b: &TensorAny<RB, TB, B, DB>) -> Result<Self::Output>

fn greater(self, b: TRB) -> Self::Output

where Self: Sized,

impl<TA, DA, TB, DB, B, R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>> TensorGreaterAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for &TensorAny<R, TA, B, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceGreaterAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceGreaterAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceGreaterAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn greater_f(self, b: TensorView<'_, TB, B, DB>) -> Result<Self::Output>

fn greater(self, b: TRB) -> Self::Output

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorGreaterEqualAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorAny<RA, TA, B, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceGreaterEqualAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceGreaterEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceGreaterEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn greater_equal_f(self, b: &TensorAny<RB, TB, B, DB>) -> Result<Self::Output>

fn greater_equal(self, b: TRB) -> Self::Output

where Self: Sized,

impl<TA, DA, TB, DB, B, R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>> TensorGreaterEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for &TensorAny<R, TA, B, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceGreaterEqualAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceGreaterEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceGreaterEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn greater_equal_f(self, b: TensorView<'_, TB, B, DB>) -> Result<Self::Output>

fn greater_equal(self, b: TRB) -> Self::Output

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorHypotAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorAny<RA, TA, B, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceHypotAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceHypotAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceHypotAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn hypot_f(self, b: &TensorAny<RB, TB, B, DB>) -> Result<Self::Output>

fn hypot(self, b: TRB) -> Self::Output

where Self: Sized,

impl<TA, DA, TB, DB, B, R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>> TensorHypotAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for &TensorAny<R, TA, B, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceHypotAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceHypotAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceHypotAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn hypot_f(self, b: TensorView<'_, TB, B, DB>) -> Result<Self::Output>

fn hypot(self, b: TRB) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorImagAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceImagAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceImagAPI<T, D>>::TOut>>::Raw>, <B as DeviceImagAPI<T, D>>::TOut, B>, D>

fn imag_f(self) -> Result<Self::Output>

fn imag(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorIntoOwnedAPI<T, B, D> for TensorAny<R, T, B, D>

where R: DataCloneAPI<Data = B::Raw>, B::Raw: Clone, T: Clone, D: DimAPI, B: DeviceAPI<T> + DeviceCreationAnyAPI<T> + OpAssignAPI<T, D>,

fn into_owned(self) -> Tensor<T, B, D>

Convert tensor into owned tensor.

impl<R, T, B, D> TensorInvAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceInvAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceInvAPI<T, D>>::TOut>>::Raw>, <B as DeviceInvAPI<T, D>>::TOut, B>, D>

fn inv_f(self) -> Result<Self::Output>

fn inv(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorIsFiniteAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceIsFiniteAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceIsFiniteAPI<T, D>>::TOut>>::Raw>, <B as DeviceIsFiniteAPI<T, D>>::TOut, B>, D>

fn is_finite_f(self) -> Result<Self::Output>

fn is_finite(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorIsInfAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceIsInfAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceIsInfAPI<T, D>>::TOut>>::Raw>, <B as DeviceIsInfAPI<T, D>>::TOut, B>, D>

fn is_inf_f(self) -> Result<Self::Output>

fn is_inf(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorIsNanAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceIsNanAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceIsNanAPI<T, D>>::TOut>>::Raw>, <B as DeviceIsNanAPI<T, D>>::TOut, B>, D>

fn is_nan_f(self) -> Result<Self::Output>

fn is_nan(self) -> Self::Output

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorLessAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorAny<RA, TA, B, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceLessAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceLessAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceLessAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn less_f(self, b: &TensorAny<RB, TB, B, DB>) -> Result<Self::Output>

fn less(self, b: TRB) -> Self::Output

where Self: Sized,

impl<TA, DA, TB, DB, B, R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>> TensorLessAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for &TensorAny<R, TA, B, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceLessAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceLessAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceLessAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn less_f(self, b: TensorView<'_, TB, B, DB>) -> Result<Self::Output>

fn less(self, b: TRB) -> Self::Output

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorLessEqualAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorAny<RA, TA, B, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceLessEqualAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceLessEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceLessEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn less_equal_f(self, b: &TensorAny<RB, TB, B, DB>) -> Result<Self::Output>

fn less_equal(self, b: TRB) -> Self::Output

where Self: Sized,

impl<TA, DA, TB, DB, B, R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>> TensorLessEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for &TensorAny<R, TA, B, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceLessEqualAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceLessEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceLessEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn less_equal_f(self, b: TensorView<'_, TB, B, DB>) -> Result<Self::Output>

fn less_equal(self, b: TRB) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorLog10API for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceLog10API<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceLog10API<T, D>>::TOut>>::Raw>, <B as DeviceLog10API<T, D>>::TOut, B>, D>

fn log10_f(self) -> Result<Self::Output>

fn log10(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorLog1pAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceLog1pAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceLog1pAPI<T, D>>::TOut>>::Raw>, <B as DeviceLog1pAPI<T, D>>::TOut, B>, D>

fn log1p_f(self) -> Result<Self::Output>

fn log1p(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorLog2API for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceLog2API<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceLog2API<T, D>>::TOut>>::Raw>, <B as DeviceLog2API<T, D>>::TOut, B>, D>

fn log2_f(self) -> Result<Self::Output>

fn log2(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorLogAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceLogAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceLogAPI<T, D>>::TOut>>::Raw>, <B as DeviceLogAPI<T, D>>::TOut, B>, D>

fn log_f(self) -> Result<Self::Output>

fn log(self) -> Self::Output

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorLogAddExpAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorAny<RA, TA, B, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceLogAddExpAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceLogAddExpAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceLogAddExpAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn log_add_exp_f(self, b: &TensorAny<RB, TB, B, DB>) -> Result<Self::Output>

fn log_add_exp(self, b: TRB) -> Self::Output

where Self: Sized,

impl<TA, DA, TB, DB, B, R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>> TensorLogAddExpAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for &TensorAny<R, TA, B, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceLogAddExpAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceLogAddExpAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceLogAddExpAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn log_add_exp_f(self, b: TensorView<'_, TB, B, DB>) -> Result<Self::Output>

fn log_add_exp(self, b: TRB) -> Self::Output

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorMaximumAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorAny<RA, TA, B, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceMaximumAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceMaximumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceMaximumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn maximum_f(self, b: &TensorAny<RB, TB, B, DB>) -> Result<Self::Output>

fn maximum(self, b: TRB) -> Self::Output

where Self: Sized,

impl<TA, DA, TB, DB, B, R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>> TensorMaximumAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for &TensorAny<R, TA, B, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceMaximumAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceMaximumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceMaximumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn maximum_f(self, b: TensorView<'_, TB, B, DB>) -> Result<Self::Output>

fn maximum(self, b: TRB) -> Self::Output

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorMinimumAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorAny<RA, TA, B, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceMinimumAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceMinimumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceMinimumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn minimum_f(self, b: &TensorAny<RB, TB, B, DB>) -> Result<Self::Output>

fn minimum(self, b: TRB) -> Self::Output

where Self: Sized,

impl<TA, DA, TB, DB, B, R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>> TensorMinimumAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for &TensorAny<R, TA, B, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceMinimumAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceMinimumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceMinimumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn minimum_f(self, b: TensorView<'_, TB, B, DB>) -> Result<Self::Output>

fn minimum(self, b: TRB) -> Self::Output

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorNotEqualAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorAny<RA, TA, B, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceNotEqualAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceNotEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceNotEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn not_equal_f(self, b: &TensorAny<RB, TB, B, DB>) -> Result<Self::Output>

fn not_equal(self, b: TRB) -> Self::Output

where Self: Sized,

impl<TA, DA, TB, DB, B, R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>> TensorNotEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for &TensorAny<R, TA, B, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DeviceNotEqualAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceNotEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DeviceNotEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn not_equal_f(self, b: TensorView<'_, TB, B, DB>) -> Result<Self::Output>

fn not_equal(self, b: TRB) -> Self::Output

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorPowAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorAny<RA, TA, B, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DevicePowAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DevicePowAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DevicePowAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn pow_f(self, b: &TensorAny<RB, TB, B, DB>) -> Result<Self::Output>

fn pow(self, b: TRB) -> Self::Output

where Self: Sized,

impl<TA, DA, TB, DB, B, R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>> TensorPowAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for &TensorAny<R, TA, B, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, DA::Max: DimAPI, B: DevicePowAPI<TA, TB, DA::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<B::TOut> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DevicePowAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>>::Raw>, <B as DevicePowAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut, B>, <DA as DimMaxAPI<DB>>::Max>

fn pow_f(self, b: TensorView<'_, TB, B, DB>) -> Result<Self::Output>

fn pow(self, b: TRB) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorRealAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceRealAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceRealAPI<T, D>>::TOut>>::Raw>, <B as DeviceRealAPI<T, D>>::TOut, B>, D>

fn real_f(self) -> Result<Self::Output>

fn real(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorRoundAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceRoundAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceRoundAPI<T, D>>::TOut>>::Raw>, <B as DeviceRoundAPI<T, D>>::TOut, B>, D>

fn round_f(self) -> Result<Self::Output>

fn round(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorSignAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceSignAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceSignAPI<T, D>>::TOut>>::Raw>, <B as DeviceSignAPI<T, D>>::TOut, B>, D>

fn sign_f(self) -> Result<Self::Output>

fn sign(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorSignBitAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceSignBitAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceSignBitAPI<T, D>>::TOut>>::Raw>, <B as DeviceSignBitAPI<T, D>>::TOut, B>, D>

fn signbit_f(self) -> Result<Self::Output>

fn signbit(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorSinAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceSinAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceSinAPI<T, D>>::TOut>>::Raw>, <B as DeviceSinAPI<T, D>>::TOut, B>, D>

fn sin_f(self) -> Result<Self::Output>

fn sin(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorSinhAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceSinhAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceSinhAPI<T, D>>::TOut>>::Raw>, <B as DeviceSinhAPI<T, D>>::TOut, B>, D>

fn sinh_f(self) -> Result<Self::Output>

fn sinh(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorSqrtAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceSqrtAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceSqrtAPI<T, D>>::TOut>>::Raw>, <B as DeviceSqrtAPI<T, D>>::TOut, B>, D>

fn sqrt_f(self) -> Result<Self::Output>

fn sqrt(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorSquareAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceSquareAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceSquareAPI<T, D>>::TOut>>::Raw>, <B as DeviceSquareAPI<T, D>>::TOut, B>, D>

fn square_f(self) -> Result<Self::Output>

fn square(self) -> Self::Output

where Self: Sized,

impl<R, B, D> TensorSumBoolAPI<B, D> for TensorAny<R, bool, B, D>

where R: DataAPI<Data = <B as DeviceRawAPI<bool>>::Raw>, D: DimAPI, B: DeviceAPI<bool> + DeviceAPI<usize> + OpSumBoolAPI<D> + DeviceCreationAnyAPI<usize>,

fn sum_all_f(&self) -> Result<usize>

fn sum_axes_f<I>(&self, axes: I) -> Result<Tensor<usize, B, IxD>>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

fn sum_all(&self) -> usize

fn sum_f(&self) -> Result<usize>

fn sum(&self) -> usize

fn sum_axes<I>(&self, axes: I) -> Tensor<usize, B, IxD>

where I: TryInto<AxesIndex<isize>>, Error: From<I::Error>,

impl<R, T, B, D> TensorTanAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceTanAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceTanAPI<T, D>>::TOut>>::Raw>, <B as DeviceTanAPI<T, D>>::TOut, B>, D>

fn tan_f(self) -> Result<Self::Output>

fn tan(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorTanhAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceTanhAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceTanhAPI<T, D>>::TOut>>::Raw>, <B as DeviceTanhAPI<T, D>>::TOut, B>, D>

fn tanh_f(self) -> Result<Self::Output>

fn tanh(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorTruncAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceTruncAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceTruncAPI<T, D>>::TOut>>::Raw>, <B as DeviceTruncAPI<T, D>>::TOut, B>, D>

fn trunc_f(self) -> Result<Self::Output>

fn trunc(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorViewAPI<T, B, D> for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = B::Raw>, B: DeviceAPI<T>,

fn view(&self) -> TensorView<'_, T, B, D>

Get a view of tensor.

impl<R, T, B, D> TensorViewAPI<T, B, D> for TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = B::Raw>, B: DeviceAPI<T>,

fn view(&self) -> TensorView<'_, T, B, D>

Get a view of tensor.

impl<R, T, B, D> TensorViewMutAPI<T, B, D> for &mut TensorAny<R, T, B, D>

where D: DimAPI, R: DataMutAPI<Data = B::Raw>, B: DeviceAPI<T>,

fn view_mut(&mut self) -> TensorMut<'_, T, B, D>

Get a mutable view of tensor.

impl<R, T, B, D> TensorViewMutAPI<T, B, D> for TensorAny<R, T, B, D>

where D: DimAPI, R: DataMutAPI<Data = B::Raw>, B: DeviceAPI<T>,

fn view_mut(&mut self) -> TensorMut<'_, T, B, D>

Get a mutable view of tensor.

impl<R, T, D, B> TrilAPI<()> for &TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, T: Num + Clone, D: DimAPI, B: DeviceAPI<T> + DeviceCreationTriAPI<T> + DeviceCreationAnyAPI<T> + OpAssignArbitaryAPI<T, D, D> + OpAssignAPI<T, D>, B::Raw: Clone,

type Out = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

fn tril_f(self) -> Result<Self::Out>

fn tril(self) -> Self::Out

where Self: Sized,

impl<R, T, D, B> TriuAPI<()> for &TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, T: Num + Clone, D: DimAPI, B: DeviceAPI<T> + DeviceCreationTriAPI<T> + DeviceCreationAnyAPI<T> + OpAssignArbitaryAPI<T, D, D> + OpAssignAPI<T, D>, B::Raw: Clone,

type Out = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

fn triu_f(self) -> Result<Self::Out>

fn triu(self) -> Self::Out

where Self: Sized,

impl<R, T, B, D> ZerosLikeAPI<()> for &TensorAny<R, T, B, D>

where R: DataAPI<Data = B::Raw>, T: Num, D: DimAPI, B: DeviceAPI<T> + DeviceCreationNumAPI<T>,

type Out = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

fn zeros_like_f(self) -> Result<Self::Out>

fn zeros_like(self) -> Self::Out

where Self: Sized,

impl<R, T, B, D> TensorRefAPI for &TensorAny<R, T, B, D>

where D: DimAPI, R: DataAPI<Data = B::Raw>, B: DeviceAPI<T>, Self: TensorViewAPI<T, B, D>,

impl<R, T, B, D> TensorRefMutAPI for &mut TensorAny<R, T, B, D>

where D: DimAPI, R: DataMutAPI<Data = B::Raw>, B: DeviceAPI<T>, Self: TensorViewMutAPI<T, B, D>,