Struct TensorBase 

pub struct TensorBase<S, D>
where
    D: DimAPI,
{ /* private fields */ }

Implementations

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn index_select_f<I>( &self, axis: isize, indices: I, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>, Error>

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

pub fn index_select<I>( &self, axis: isize, indices: I, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where I: TryInto<AxesIndex<isize>, Error = 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.

pub fn take_f<I>( &self, indices: I, axis: isize, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>, Error>

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

pub fn take<I>( &self, indices: I, axis: isize, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

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

Take elements from an array along an axis.

See also

Python Array API standard: take

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn bool_select_f<I>( &self, axis: isize, indices: I, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>, Error>

where I: TryInto<AxesIndex<bool>, Error = Error>,

pub fn bool_select<I>( &self, axis: isize, indices: I, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where I: TryInto<AxesIndex<bool>, Error = Error>,

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

impl<S, D> TensorBase<S, D>

where D: DimAPI,

pub fn assign_f<TRB>(&mut self, b: TRB) -> Result<(), Error>

where TensorBase<S, D>: TensorAssignAPI<TRB>,

pub fn assign<TRB>(&mut self, b: TRB)

where TensorBase<S, D>: TensorAssignAPI<TRB>,

impl<S, D> TensorBase<S, D>

where D: DimAPI,

pub fn fill_f<T>(&mut self, b: T) -> Result<(), Error>

where TensorBase<S, D>: TensorFillAPI<T>,

pub fn fill<T>(&mut self, b: T)

where TensorBase<S, D>: TensorFillAPI<T>,

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn full_like( &self, fill: T, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

pub fn full_like_f( &self, fill: T, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>, Error>

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn ones_like( &self, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, 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<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>, Error>

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn zeros_like( &self, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, 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<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>, Error>

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn into_slice_f<I>( self, index: I, ) -> Result<TensorBase<Storage<R, T, B>, Vec<usize>>, Error>

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

pub fn into_slice<I>(self, index: I) -> TensorBase<Storage<R, T, B>, Vec<usize>>

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

pub fn slice_f<I>( &self, index: I, ) -> Result<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, Vec<usize>>, Error>

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

pub fn slice<I>( &self, index: I, ) -> TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, Vec<usize>>

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

pub fn i_f<I>( &self, index: I, ) -> Result<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, Vec<usize>>, Error>

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

pub fn i<I>( &self, index: I, ) -> TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, Vec<usize>>

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

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn slice_mut_f<I>( &mut self, index: I, ) -> Result<TensorBase<Storage<DataMut<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, Vec<usize>>, Error>

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

pub fn slice_mut<I>( &mut self, index: I, ) -> TensorBase<Storage<DataMut<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, Vec<usize>>

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

pub fn i_mut_f<I>( &mut self, index: I, ) -> Result<TensorBase<Storage<DataMut<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, Vec<usize>>, Error>

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

pub fn i_mut<I>( &mut self, index: I, ) -> TensorBase<Storage<DataMut<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, Vec<usize>>

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

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn into_diagonal_f( self, diagonal_args: impl Into<DiagonalArgs>, ) -> Result<TensorBase<Storage<R, T, B>, <D as DimSmallerOneAPI>::SmallerOne>, Error>

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

pub fn diagonal_f( &self, diagonal_args: impl Into<DiagonalArgs>, ) -> Result<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, <D as DimSmallerOneAPI>::SmallerOne>, Error>

pub fn diagonal( &self, diagonal_args: impl Into<DiagonalArgs>, ) -> TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, <D as DimSmallerOneAPI>::SmallerOne>

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn into_diagonal_mut_f( self, diagonal_args: impl Into<DiagonalArgs>, ) -> Result<TensorBase<Storage<R, T, B>, <D as DimSmallerOneAPI>::SmallerOne>, Error>

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

pub fn diagonal_mut_f( &mut self, diagonal_args: impl Into<DiagonalArgs>, ) -> Result<TensorBase<Storage<DataMut<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, <D as DimSmallerOneAPI>::SmallerOne>, Error>

pub fn diagonal_mut( &mut self, diagonal_args: impl Into<DiagonalArgs>, ) -> TensorBase<Storage<DataMut<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, <D as DimSmallerOneAPI>::SmallerOne>

impl<T, B, D> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where T: Clone, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>>,

pub unsafe fn index_uncheck<I>(&self, index: I) -> &T

where I: AsRef<[usize]>,

Safety

This function is unsafe because it does not check the validity of the index.

impl<T, B, D> TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where T: Clone, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>>,

pub unsafe fn index_uncheck<I>(&self, index: I) -> &T

where I: AsRef<[usize]>,

Safety

This function is unsafe because it does not check the validity of the index.

impl<T, B, D> TensorBase<Storage<DataMut<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where T: Clone, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>>,

pub unsafe fn index_uncheck<I>(&self, index: I) -> &T

where I: AsRef<[usize]>,

Safety

This function is unsafe because it does not check the validity of the index.

impl<T, B, D> TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where T: Clone, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>>,

pub unsafe fn index_uncheck<I>(&self, index: I) -> &T

where I: AsRef<[usize]>,

Safety

This function is unsafe because it does not check the validity of the index.

impl<T, B, D> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where T: Clone, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>>,

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

where I: AsRef<[usize]>,

Safety

This function is unsafe because it does not check the validity of the index.

impl<T, B, D> TensorBase<Storage<DataMut<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where T: Clone, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>>,

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

where I: AsRef<[usize]>,

Safety

This function is unsafe because it does not check the validity of the index.

impl<'a, R, T, B, D> TensorBase<Storage<R, T, B>, D>

where T: Clone, R: DataCloneAPI<Data = <B as DeviceRawAPI<T>>::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>, Error>

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

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

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

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

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

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

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

impl<'a, R, T, B, D> TensorBase<Storage<R, T, B>, D>

where T: Clone, R: DataMutAPI<Data = <B as DeviceRawAPI<T>>::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>, Error>

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

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

where I: TryInto<AxesIndex<isize>, Error = 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 = Error>,

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

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

impl<'a, R, T, B, D> TensorBase<Storage<R, T, B>, D>

where T: Clone, R: DataCloneAPI<Data = <B as DeviceRawAPI<T>>::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>, Error>

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

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

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

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

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

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

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

impl<'a, R, T, B, D> TensorBase<Storage<R, T, B>, D>

where T: Clone, R: DataMutAPI<Data = <B as DeviceRawAPI<T>>::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>, Error>

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

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

where I: TryInto<AxesIndex<isize>, Error = 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 = Error>,

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

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

impl<'a, R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

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

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

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

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

impl<'a, R, T, B, D> TensorBase<Storage<R, T, B>, D>

where R: DataMutAPI<Data = <B as DeviceRawAPI<T>>::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>, Error>

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>, Error>

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

impl<'a, R, T, B, D> TensorBase<Storage<R, T, B>, D>

where R: DataAPI<Data = <B as DeviceRawAPI<T>>::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>, Error>

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

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

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

impl<'a, R, T, B, D> TensorBase<Storage<R, T, B>, D>

where R: DataMutAPI<Data = <B as DeviceRawAPI<T>>::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>, Error>

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>, Error>

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

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn to_broadcast<D2>( &self, shape: D2, ) -> TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D2>

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

Broadcasts an array to a specified shape.

See also

Refer to to_broadcast or into_broadcast for detailed documentation.

pub fn broadcast_to<D2>( &self, shape: D2, ) -> TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D2>

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

Broadcasts an array to a specified shape.

See also

Refer to to_broadcast or into_broadcast for detailed documentation.

pub fn to_broadcast_f<D2>( &self, shape: D2, ) -> Result<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D2>, Error>

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

Broadcasts an array to a specified shape.

See also

Refer to to_broadcast or into_broadcast for detailed documentation.

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

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

Broadcasts an array to a specified shape.

See also

Refer to to_broadcast or into_broadcast for detailed documentation.

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

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

Broadcasts an array to a specified shape.

See also

Refer to to_broadcast or into_broadcast for detailed documentation.

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn expand_dims<I>( &self, axes: I, ) -> TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, Vec<usize>>

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

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

See also

Refer to expand_dims and into_expand_dims for more detailed documentation.

pub fn expand_dims_f<I>( &self, axes: I, ) -> Result<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, Vec<usize>>, Error>

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

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

See also

Refer to expand_dims and into_expand_dims for more detailed documentation.

pub fn into_expand_dims<I>( self, axes: I, ) -> TensorBase<Storage<R, T, B>, Vec<usize>>

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

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

See also

Refer to expand_dims and into_expand_dims for more detailed documentation.

pub fn into_expand_dims_f<I>( self, axes: I, ) -> Result<TensorBase<Storage<R, T, B>, Vec<usize>>, Error>

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

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

See also

Refer to expand_dims and into_expand_dims for more detailed documentation.

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn flip<I>( &self, axis: I, ) -> TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

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

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

See also

Refer to flip for more detailed documentation.

pub fn flip_f<I>( &self, axis: I, ) -> Result<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>, Error>

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

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

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

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

See also

Refer to flip for more detailed documentation.

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

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

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

See also

Refer to flip for more detailed documentation.

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn to_dim<D2>( &self, ) -> TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D2>

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

Convert layout to the other dimension.

See also

Refer to into_dim for more detailed documentation.

pub fn to_dim_f<D2>( &self, ) -> Result<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D2>, Error>

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

Convert layout to the other dimension.

See also

Refer to into_dim for more detailed documentation.

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

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

Convert layout to the other dimension.

See also

Refer to into_dim for more detailed documentation.

pub fn into_dim_f<D2>(self) -> Result<TensorBase<Storage<R, T, B>, D2>, Error>

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

Convert layout to the other dimension.

See also

Refer to into_dim for more detailed documentation.

pub fn to_dyn( &self, ) -> TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, Vec<usize>>

Convert layout to the dynamic dimension IxD.

See also

Refer to into_dim for more detailed documentation.

pub fn into_dyn(self) -> TensorBase<Storage<R, T, B>, Vec<usize>>

Convert layout to the dynamic dimension IxD.

See also

Refer to into_dim for more detailed documentation.

impl<'a, R, T, B, D> TensorBase<Storage<R, T, B>, D>

where R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw> + DataIntoCowAPI<'a>, D: DimAPI, B: DeviceAPI<T> + DeviceRawAPI<MaybeUninit<T>> + DeviceCreationAnyAPI<T> + OpAssignArbitaryAPI<T, Vec<usize>, D>, T: Clone,

Reshapes the given tensor to the specified shape.

See also

Refer to reshape, into_shape and change_shape for more details and examples.

pub fn change_shape_f<I>( self, shape: I, ) -> Result<TensorBase<Storage<DataCow<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, Vec<usize>>, Error>

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

Reshapes the given tensor to the specified shape.

See also

Refer to reshape, into_shape and change_shape for more details and examples.

pub fn change_shape<I>( self, shape: I, ) -> TensorBase<Storage<DataCow<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, Vec<usize>>

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

Reshapes the given tensor to the specified shape.

See also

Refer to reshape, into_shape and change_shape for more details and examples.

pub fn into_shape_f<I>( self, shape: I, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, Vec<usize>>, Error>

where I: TryInto<AxesIndex<isize>, Error = Error>, <B as DeviceRawAPI<T>>::Raw: Clone + 'a, B: OpAssignAPI<T, Vec<usize>>,

Reshapes the given tensor to the specified shape.

See also

Refer to reshape, into_shape and change_shape for more details and examples.

pub fn into_shape<I>( self, shape: I, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, Vec<usize>>

where I: TryInto<AxesIndex<isize>, Error = Error>, <B as DeviceRawAPI<T>>::Raw: Clone + 'a, B: OpAssignAPI<T, Vec<usize>>,

Reshapes the given tensor to the specified shape.

See also

Refer to reshape, into_shape and change_shape for more details and examples.

pub fn to_shape_f<I>( &'a self, shape: I, ) -> Result<TensorBase<Storage<DataCow<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, Vec<usize>>, Error>

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

Reshapes the given tensor to the specified shape.

See also

Refer to reshape, into_shape and change_shape for more details and examples.

pub fn to_shape<I>( &'a self, shape: I, ) -> TensorBase<Storage<DataCow<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, Vec<usize>>

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

Reshapes the given tensor to the specified shape.

See also

Refer to reshape, into_shape and change_shape for more details and examples.

pub fn reshape_f<I>( &'a self, shape: I, ) -> Result<TensorBase<Storage<DataCow<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, Vec<usize>>, Error>

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

Reshapes the given tensor to the specified shape.

See also

Refer to reshape, into_shape and change_shape for more details and examples.

pub fn reshape<I>( &'a self, shape: I, ) -> TensorBase<Storage<DataCow<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, Vec<usize>>

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

Reshapes the given tensor to the specified shape.

See also

Refer to reshape, into_shape and change_shape for more details and examples.

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn reshape_assume_contig<D2>( &self, shape: D2, ) -> TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, 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<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D2>, Error>

where D2: DimAPI,

pub fn to_shape_assume_contig<D2>( &self, shape: D2, ) -> TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D2>

where D2: DimAPI,

pub fn to_shape_assume_contig_f<D2>( &self, shape: D2, ) -> Result<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D2>, Error>

where D2: DimAPI,

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

where D2: DimAPI,

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

where D2: DimAPI,

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn squeeze<I>( &self, axis: I, ) -> TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, Vec<usize>>

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

Removes singleton dimensions (axes) from x.

See also

squeeze

pub fn squeeze_f<I>( &self, axis: I, ) -> Result<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, Vec<usize>>, Error>

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

pub fn into_squeeze<I>( self, axis: I, ) -> TensorBase<Storage<R, T, B>, Vec<usize>>

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

Removes singleton dimensions (axes) from x.

See also

squeeze

pub fn into_squeeze_f<I>( self, axis: I, ) -> Result<TensorBase<Storage<R, T, B>, Vec<usize>>, Error>

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

impl<'a, R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn to_contig( &self, order: FlagOrder, ) -> TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, 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<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>, Error>

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

pub fn into_contig_f( self, order: FlagOrder, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>, Error>

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

pub fn into_contig( self, order: FlagOrder, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

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

pub fn change_contig_f( self, order: FlagOrder, ) -> Result<TensorBase<Storage<DataCow<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>, Error>

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

pub fn change_contig( self, order: FlagOrder, ) -> TensorBase<Storage<DataCow<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

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

impl<'a, R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn to_prefer( &self, order: FlagOrder, ) -> TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, 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<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>, Error>

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

pub fn into_prefer_f( self, order: FlagOrder, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>, Error>

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

pub fn into_prefer( self, order: FlagOrder, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

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

pub fn change_prefer_f( self, order: FlagOrder, ) -> Result<TensorBase<Storage<DataCow<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>, Error>

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

pub fn change_prefer( self, order: FlagOrder, ) -> TensorBase<Storage<DataCow<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

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

impl<'a, R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn to_layout<D2>( &self, layout: Layout<D2>, ) -> TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, 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<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D2>, Error>

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

pub fn into_layout_f<D2>( self, layout: Layout<D2>, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D2>, Error>

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

pub fn into_layout<D2>( self, layout: Layout<D2>, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D2>

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

pub fn change_layout_f<D2>( self, layout: Layout<D2>, ) -> Result<TensorBase<Storage<DataCow<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D2>, Error>

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

pub fn change_layout<D2>( self, layout: Layout<D2>, ) -> TensorBase<Storage<DataCow<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D2>

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

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn transpose<I>( &self, axes: I, ) -> TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

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

Permutes the axes (dimensions) of an array x.

See also

transpose

pub fn transpose_f<I>( &self, axes: I, ) -> Result<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>, Error>

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

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

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

Permutes the axes (dimensions) of an array x.

See also

transpose

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

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

pub fn permute_dims<I>( &self, axes: I, ) -> TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

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

Permutes the axes (dimensions) of an array x.

See also

transpose

pub fn permute_dims_f<I>( &self, axes: I, ) -> Result<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>, Error>

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

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

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

Permutes the axes (dimensions) of an array x.

See also

transpose

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

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

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn reverse_axes( &self, ) -> TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, 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) -> TensorBase<Storage<R, T, B>, D>

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

See also

reverse_axes

pub fn t( &self, ) -> TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

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

See also

reverse_axes

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn swapaxes<I>( &self, axis1: I, axis2: I, ) -> TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, 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<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>, Error>

where I: TryInto<isize>,

pub fn into_swapaxes<I>( self, axis1: I, axis2: I, ) -> TensorBase<Storage<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<TensorBase<Storage<R, T, B>, D>, Error>

where I: TryInto<isize>,

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn map_fnmut_f<'f, TOut>( &self, f: impl FnMut(&T) -> TOut + 'f, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TOut>>::Raw>, TOut, B>, D>, Error>

where B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutA_RefB_API<TOut, T, D, dyn FnMut(&mut MaybeUninit<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, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TOut>>::Raw>, TOut, B>, D>

where B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutA_RefB_API<TOut, T, D, dyn FnMut(&mut MaybeUninit<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<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TOut>>::Raw>, TOut, B>, D>, Error>

where B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutA_RefB_API<TOut, T, D, dyn FnMut(&mut MaybeUninit<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, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TOut>>::Raw>, TOut, B>, D>

where B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutA_RefB_API<TOut, T, D, dyn FnMut(&mut MaybeUninit<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<(), Error>

where R: DataMutAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceOp_MutA_API<T, D, dyn FnMut(&mut MaybeUninit<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 as DeviceRawAPI<T>>::Raw>, B: DeviceOp_MutA_API<T, D, dyn FnMut(&mut MaybeUninit<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<(), Error>

where R: DataMutAPI<Data = <B as DeviceRawAPI<T>>::Raw>, T: Clone, B: DeviceOp_MutA_API<T, D, dyn FnMut(&mut MaybeUninit<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 as DeviceRawAPI<T>>::Raw>, T: Clone, B: DeviceOp_MutA_API<T, D, dyn FnMut(&mut MaybeUninit<T>) + 'f>,

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

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn mapb_fnmut_f<'f, R2, T2, D2, DOut, TOut>( &self, other: &TensorBase<Storage<R2, T2, B>, D2>, f: impl FnMut(&T, &T2) -> TOut + 'f, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TOut>>::Raw>, TOut, B>, DOut>, Error>

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 MaybeUninit<TOut>, &T, &T2) + 'f>,

pub fn mapb_fnmut<'f, R2, T2, D2, DOut, TOut>( &self, other: &TensorBase<Storage<R2, T2, B>, D2>, f: impl FnMut(&T, &T2) -> TOut + 'f, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TOut>>::Raw>, 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 MaybeUninit<TOut>, &T, &T2) + 'f>,

pub fn mapvb_fnmut_f<'f, R2, T2, D2, DOut, TOut>( &self, other: &TensorBase<Storage<R2, T2, B>, D2>, f: impl FnMut(T, T2) -> TOut + 'f, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TOut>>::Raw>, TOut, B>, DOut>, Error>

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 MaybeUninit<TOut>, &T, &T2) + 'f>,

pub fn mapvb_fnmut<'f, R2, T2, D2, DOut, TOut>( &self, other: &TensorBase<Storage<R2, T2, B>, D2>, f: impl FnMut(T, T2) -> TOut + 'f, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TOut>>::Raw>, 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 MaybeUninit<TOut>, &T, &T2) + 'f>,

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn map_f<'f, TOut>( &self, f: impl Fn(&T) -> TOut + Send + Sync + 'f, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TOut>>::Raw>, TOut, B>, D>, Error>

where B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutA_RefB_API<TOut, T, D, dyn Fn(&mut MaybeUninit<TOut>, &T) + Sync + Send + '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, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TOut>>::Raw>, TOut, B>, D>

where B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutA_RefB_API<TOut, T, D, dyn Fn(&mut MaybeUninit<TOut>, &T) + Sync + Send + '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<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TOut>>::Raw>, TOut, B>, D>, Error>

where B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutA_RefB_API<TOut, T, D, dyn Fn(&mut MaybeUninit<TOut>, &T) + Sync + Send + '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, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TOut>>::Raw>, TOut, B>, D>

where B: DeviceAPI<TOut> + DeviceCreationAnyAPI<TOut> + DeviceOp_MutA_RefB_API<TOut, T, D, dyn Fn(&mut MaybeUninit<TOut>, &T) + Sync + Send + '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<(), Error>

where R: DataMutAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceOp_MutA_API<T, D, dyn Fn(&mut MaybeUninit<T>) + Sync + Send + '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 as DeviceRawAPI<T>>::Raw>, B: DeviceOp_MutA_API<T, D, dyn Fn(&mut MaybeUninit<T>) + Sync + Send + '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<(), Error>

where R: DataMutAPI<Data = <B as DeviceRawAPI<T>>::Raw>, T: Clone, B: DeviceOp_MutA_API<T, D, dyn Fn(&mut MaybeUninit<T>) + Sync + Send + '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 as DeviceRawAPI<T>>::Raw>, T: Clone, B: DeviceOp_MutA_API<T, D, dyn Fn(&mut MaybeUninit<T>) + Sync + Send + 'f>,

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

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn mapb_f<'f, R2, T2, D2, DOut, TOut>( &self, other: &TensorBase<Storage<R2, T2, B>, D2>, f: impl Fn(&T, &T2) -> TOut + Send + Sync + 'f, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TOut>>::Raw>, TOut, B>, DOut>, Error>

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 MaybeUninit<TOut>, &T, &T2) + Sync + Send + 'f>,

pub fn mapb<'f, R2, T2, D2, DOut, TOut>( &self, other: &TensorBase<Storage<R2, T2, B>, D2>, f: impl Fn(&T, &T2) -> TOut + Send + Sync + 'f, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TOut>>::Raw>, 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 MaybeUninit<TOut>, &T, &T2) + Sync + Send + 'f>,

pub fn mapvb_f<'f, R2, T2, D2, DOut, TOut>( &self, other: &TensorBase<Storage<R2, T2, B>, D2>, f: impl Fn(T, T2) -> TOut + Send + Sync + 'f, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TOut>>::Raw>, TOut, B>, DOut>, Error>

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 MaybeUninit<TOut>, &T, &T2) + Sync + Send + 'f>,

pub fn mapvb<'f, R2, T2, D2, DOut, TOut>( &self, other: &TensorBase<Storage<R2, T2, B>, D2>, f: impl Fn(T, T2) -> TOut + Send + Sync + 'f, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TOut>>::Raw>, 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 MaybeUninit<TOut>, &T, &T2) + Sync + Send + 'f>,

impl<R, T, B, D> TensorBase<Storage<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: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TC>>::Raw>, TC, B>, DC>, Error>

where RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DB: DimAPI, DC: DimAPI, T: Mul<TB, Output = TC>, TC: Mul<Output = TC> + Add<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: &TensorBase<Storage<RB, TB, B>, DB>, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TC>>::Raw>, TC, B>, DC>

where RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DB: DimAPI, DC: DimAPI, T: Mul<TB, Output = TC>, TC: Mul<Output = TC> + Add<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: &TensorBase<Storage<RB, TB, B>, DB>, c: &mut TensorBase<Storage<RC, TC, B>, DC>, ) -> Result<(), Error>

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<Output = TC> + Add<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: &TensorBase<Storage<RB, TB, B>, DB>, c: &mut TensorBase<Storage<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<Output = TC> + Add<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: &TensorBase<Storage<RA, TA, B>, DA>, b: &TensorBase<Storage<RB, TB, B>, DB>, alpha: T, beta: T, ) -> Result<(), Error>

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<Output = T> + Add<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: &TensorBase<Storage<RA, TA, B>, DA>, b: &TensorBase<Storage<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<Output = T> + Add<Output = T> + Zero + One, B: DeviceAPI<TA> + DeviceAPI<TB> + DeviceMatMulAPI<TA, TB, T, DA, DB, D>,

impl<S, D> TensorBase<S, D>

where D: DimAPI,

pub fn add_f<TrB>( &self, b: TrB, ) -> Result<<&TensorBase<S, D> as TensorAddAPI<TrB>>::Output, Error>

where &'a TensorBase<S, D>: for<'a> TensorAddAPI<TrB>,

pub fn add<TrB>( &self, b: TrB, ) -> <&TensorBase<S, D> as TensorAddAPI<TrB>>::Output

where &'a TensorBase<S, D>: for<'a> TensorAddAPI<TrB>,

impl<S, D> TensorBase<S, D>

where D: DimAPI,

pub fn sub_f<TrB>( &self, b: TrB, ) -> Result<<&TensorBase<S, D> as TensorSubAPI<TrB>>::Output, Error>

where &'a TensorBase<S, D>: for<'a> TensorSubAPI<TrB>,

pub fn sub<TrB>( &self, b: TrB, ) -> <&TensorBase<S, D> as TensorSubAPI<TrB>>::Output

where &'a TensorBase<S, D>: for<'a> TensorSubAPI<TrB>,

impl<S, D> TensorBase<S, D>

where D: DimAPI,

pub fn mul_f<TrB>( &self, b: TrB, ) -> Result<<&TensorBase<S, D> as TensorMulAPI<TrB>>::Output, Error>

where &'a TensorBase<S, D>: for<'a> TensorMulAPI<TrB>,

pub fn mul<TrB>( &self, b: TrB, ) -> <&TensorBase<S, D> as TensorMulAPI<TrB>>::Output

where &'a TensorBase<S, D>: for<'a> TensorMulAPI<TrB>,

impl<S, D> TensorBase<S, D>

where D: DimAPI,

pub fn div_f<TrB>( &self, b: TrB, ) -> Result<<&TensorBase<S, D> as TensorDivAPI<TrB>>::Output, Error>

where &'a TensorBase<S, D>: for<'a> TensorDivAPI<TrB>,

pub fn div<TrB>( &self, b: TrB, ) -> <&TensorBase<S, D> as TensorDivAPI<TrB>>::Output

where &'a TensorBase<S, D>: for<'a> TensorDivAPI<TrB>,

impl<S, D> TensorBase<S, D>

where D: DimAPI,

pub fn rem_f<TrB>( &self, b: TrB, ) -> Result<<&TensorBase<S, D> as TensorRemAPI<TrB>>::Output, Error>

where &'a TensorBase<S, D>: for<'a> TensorRemAPI<TrB>,

pub fn rem<TrB>( &self, b: TrB, ) -> <&TensorBase<S, D> as TensorRemAPI<TrB>>::Output

where &'a TensorBase<S, D>: for<'a> TensorRemAPI<TrB>,

impl<S, D> TensorBase<S, D>

where D: DimAPI,

pub fn bitor_f<TrB>( &self, b: TrB, ) -> Result<<&TensorBase<S, D> as TensorBitOrAPI<TrB>>::Output, Error>

where &'a TensorBase<S, D>: for<'a> TensorBitOrAPI<TrB>,

pub fn bitor<TrB>( &self, b: TrB, ) -> <&TensorBase<S, D> as TensorBitOrAPI<TrB>>::Output

where &'a TensorBase<S, D>: for<'a> TensorBitOrAPI<TrB>,

impl<S, D> TensorBase<S, D>

where D: DimAPI,

pub fn bitand_f<TrB>( &self, b: TrB, ) -> Result<<&TensorBase<S, D> as TensorBitAndAPI<TrB>>::Output, Error>

where &'a TensorBase<S, D>: for<'a> TensorBitAndAPI<TrB>,

pub fn bitand<TrB>( &self, b: TrB, ) -> <&TensorBase<S, D> as TensorBitAndAPI<TrB>>::Output

where &'a TensorBase<S, D>: for<'a> TensorBitAndAPI<TrB>,

impl<S, D> TensorBase<S, D>

where D: DimAPI,

pub fn bitxor_f<TrB>( &self, b: TrB, ) -> Result<<&TensorBase<S, D> as TensorBitXorAPI<TrB>>::Output, Error>

where &'a TensorBase<S, D>: for<'a> TensorBitXorAPI<TrB>,

pub fn bitxor<TrB>( &self, b: TrB, ) -> <&TensorBase<S, D> as TensorBitXorAPI<TrB>>::Output

where &'a TensorBase<S, D>: for<'a> TensorBitXorAPI<TrB>,

impl<S, D> TensorBase<S, D>

where D: DimAPI,

pub fn shl_f<TrB>( &self, b: TrB, ) -> Result<<&TensorBase<S, D> as TensorShlAPI<TrB>>::Output, Error>

where &'a TensorBase<S, D>: for<'a> TensorShlAPI<TrB>,

pub fn shl<TrB>( &self, b: TrB, ) -> <&TensorBase<S, D> as TensorShlAPI<TrB>>::Output

where &'a TensorBase<S, D>: for<'a> TensorShlAPI<TrB>,

impl<S, D> TensorBase<S, D>

where D: DimAPI,

pub fn shr_f<TrB>( &self, b: TrB, ) -> Result<<&TensorBase<S, D> as TensorShrAPI<TrB>>::Output, Error>

where &'a TensorBase<S, D>: for<'a> TensorShrAPI<TrB>,

pub fn shr<TrB>( &self, b: TrB, ) -> <&TensorBase<S, D> as TensorShrAPI<TrB>>::Output

where &'a TensorBase<S, D>: for<'a> TensorShrAPI<TrB>,

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn pack_tri_f( &self, uplo: FlagUpLo, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, <D as DimSmallerOneAPI>::SmallerOne>, Error>

pub fn pack_tri( &self, uplo: FlagUpLo, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, <D as DimSmallerOneAPI>::SmallerOne>

pub fn pack_tril_f( &self, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, <D as DimSmallerOneAPI>::SmallerOne>, Error>

pub fn pack_tril( &self, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, <D as DimSmallerOneAPI>::SmallerOne>

pub fn pack_triu_f( &self, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, <D as DimSmallerOneAPI>::SmallerOne>, Error>

pub fn pack_triu( &self, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, <D as DimSmallerOneAPI>::SmallerOne>

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn unpack_tri_f( &self, uplo: FlagUpLo, symm: FlagSymm, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, <D as DimLargerOneAPI>::LargerOne>, Error>

pub fn unpack_tri( &self, uplo: FlagUpLo, symm: FlagSymm, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, <D as DimLargerOneAPI>::LargerOne>

pub fn unpack_tril( &self, symm: FlagSymm, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, <D as DimLargerOneAPI>::LargerOne>

pub fn unpack_triu( &self, symm: FlagSymm, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, <D as DimLargerOneAPI>::LargerOne>

pub fn unpack_tril_f( &self, symm: FlagSymm, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, <D as DimLargerOneAPI>::LargerOne>, Error>

pub fn unpack_triu_f( &self, symm: FlagSymm, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, <D as DimLargerOneAPI>::LargerOne>, Error>

impl<S, D> TensorBase<S, D>

where D: DimAPI,

pub fn neg_f( &self, ) -> Result<<&TensorBase<S, D> as TensorNegAPI>::Output, Error>

where &'a TensorBase<S, D>: for<'a> TensorNegAPI,

pub fn neg(&self) -> <&TensorBase<S, D> as TensorNegAPI>::Output

where &'a TensorBase<S, D>: for<'a> TensorNegAPI,

impl<S, D> TensorBase<S, D>

where D: DimAPI,

pub fn not_f( &self, ) -> Result<<&TensorBase<S, D> as TensorNotAPI>::Output, Error>

where &'a TensorBase<S, D>: for<'a> TensorNotAPI,

pub fn not(&self) -> <&TensorBase<S, D> as TensorNotAPI>::Output

where &'a TensorBase<S, D>: for<'a> TensorNotAPI,

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

Methods for tensor ownership conversion.

pub fn view( &self, ) -> TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

Get a view of tensor.

pub fn view_mut( &mut self, ) -> TensorBase<Storage<DataMut<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where R: DataMutAPI,

Get a mutable view of tensor.

pub fn into_cow<'a>( self, ) -> TensorBase<Storage<DataCow<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where R: DataIntoCowAPI<'a>,

Convert current tensor into copy-on-write.

pub fn into_owned_keep_layout( self, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where <R as DataAPI>::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, ) -> TensorBase<Storage<DataArc<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where <R as DataAPI>::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> TensorBase<Storage<R, T, B>, D>

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

pub fn into_owned( self, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

pub fn into_shared( self, ) -> TensorBase<Storage<DataArc<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

pub fn to_owned( &self, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub unsafe fn force_mut( &self, ) -> TensorBase<Storage<DataMut<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

Safety

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

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

where R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, T: Clone, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>> + DeviceCreationAnyAPI<T> + OpAssignAPI<T, [usize; 1]>,

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

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

impl<T, B, D> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where T: Clone, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>> + DeviceCreationAnyAPI<T> + OpAssignAPI<T, [usize; 1]>,

pub fn into_vec_f(self) -> Result<Vec<T>, Error>

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

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

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

pub fn to_scalar(&self) -> T

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

where R: DataAPI<Data = <B as DeviceRawAPI<T>>::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> TensorBase<Storage<R, T, B>, D>

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

pub fn into_pack_array_f<const N: usize>( self, axis: isize, ) -> Result<TensorBase<Storage<<R as PackableArrayAPI<T, N>>::ArrayVec, <R as PackableArrayAPI<T, N>>::Array, B>, <D as DimSmallerOneAPI>::SmallerOne>, Error>

where B: DeviceAPI<<R as PackableArrayAPI<T, N>>::Array>, R: PackableArrayAPI<T, N> + PackArrayAPI<T>, <R as PackableArrayAPI<T, N>>::ArrayVec: DataAPI<Data = <B as DeviceRawAPI<<R as PackableArrayAPI<T, N>>::Array>>::Raw>,

pub fn into_pack_array<const N: usize>( self, axis: isize, ) -> TensorBase<Storage<<R as PackableArrayAPI<T, N>>::ArrayVec, <R as PackableArrayAPI<T, N>>::Array, B>, <D as DimSmallerOneAPI>::SmallerOne>

where B: DeviceAPI<<R as PackableArrayAPI<T, N>>::Array>, R: PackableArrayAPI<T, N> + PackArrayAPI<T>, <R as PackableArrayAPI<T, N>>::ArrayVec: DataAPI<Data = <B as DeviceRawAPI<<R as PackableArrayAPI<T, N>>::Array>>::Raw>,

impl<R, T, B, D, const N: usize> TensorBase<Storage<R, [T; N], B>, D>

where R: DataAPI<Data = <B as DeviceRawAPI<[T; N]>>::Raw>, B: DeviceAPI<T> + DeviceAPI<[T; N]>, D: DimAPI + DimLargerOneAPI, <D as DimLargerOneAPI>::LargerOne: DimAPI,

pub fn into_unpack_array_f( self, axis: isize, ) -> Result<TensorBase<Storage<<R as UnpackArrayAPI>::Output, T, B>, <D as DimLargerOneAPI>::LargerOne>, Error>

where R: UnpackArrayAPI, <R as UnpackArrayAPI>::Output: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T>,

pub fn into_unpack_array( self, axis: isize, ) -> TensorBase<Storage<<R as UnpackArrayAPI>::Output, T, B>, <D as DimLargerOneAPI>::LargerOne>

where R: UnpackArrayAPI, <R as UnpackArrayAPI>::Output: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T>,

impl<R, T, B, D> TensorBase<Storage<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 as OpSumAPI<T, D>>::TOut, Error>

pub fn sum_all(&self) -> <B as OpSumAPI<T, D>>::TOut

pub fn sum_axes_f( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpSumAPI<T, D>>::TOut>>::Raw>, <B as OpSumAPI<T, D>>::TOut, B>, Vec<usize>>, Error>

where B: DeviceCreationAnyAPI<<B as OpSumAPI<T, D>>::TOut>,

pub fn sum_axes( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpSumAPI<T, D>>::TOut>>::Raw>, <B as OpSumAPI<T, D>>::TOut, B>, Vec<usize>>

where B: DeviceCreationAnyAPI<<B as OpSumAPI<T, D>>::TOut>,

pub fn sum_f(&self) -> Result<<B as OpSumAPI<T, D>>::TOut, Error>

pub fn sum(&self) -> <B as OpSumAPI<T, D>>::TOut

impl<R, T, B, D> TensorBase<Storage<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 as OpMinAPI<T, D>>::TOut, Error>

pub fn min_all(&self) -> <B as OpMinAPI<T, D>>::TOut

pub fn min_axes_f( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpMinAPI<T, D>>::TOut>>::Raw>, <B as OpMinAPI<T, D>>::TOut, B>, Vec<usize>>, Error>

where B: DeviceCreationAnyAPI<<B as OpMinAPI<T, D>>::TOut>,

pub fn min_axes( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpMinAPI<T, D>>::TOut>>::Raw>, <B as OpMinAPI<T, D>>::TOut, B>, Vec<usize>>

where B: DeviceCreationAnyAPI<<B as OpMinAPI<T, D>>::TOut>,

pub fn min_f(&self) -> Result<<B as OpMinAPI<T, D>>::TOut, Error>

pub fn min(&self) -> <B as OpMinAPI<T, D>>::TOut

impl<R, T, B, D> TensorBase<Storage<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 as OpMaxAPI<T, D>>::TOut, Error>

pub fn max_all(&self) -> <B as OpMaxAPI<T, D>>::TOut

pub fn max_axes_f( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpMaxAPI<T, D>>::TOut>>::Raw>, <B as OpMaxAPI<T, D>>::TOut, B>, Vec<usize>>, Error>

where B: DeviceCreationAnyAPI<<B as OpMaxAPI<T, D>>::TOut>,

pub fn max_axes( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpMaxAPI<T, D>>::TOut>>::Raw>, <B as OpMaxAPI<T, D>>::TOut, B>, Vec<usize>>

where B: DeviceCreationAnyAPI<<B as OpMaxAPI<T, D>>::TOut>,

pub fn max_f(&self) -> Result<<B as OpMaxAPI<T, D>>::TOut, Error>

pub fn max(&self) -> <B as OpMaxAPI<T, D>>::TOut

impl<R, T, B, D> TensorBase<Storage<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 as OpProdAPI<T, D>>::TOut, Error>

pub fn prod_all(&self) -> <B as OpProdAPI<T, D>>::TOut

pub fn prod_axes_f( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpProdAPI<T, D>>::TOut>>::Raw>, <B as OpProdAPI<T, D>>::TOut, B>, Vec<usize>>, Error>

where B: DeviceCreationAnyAPI<<B as OpProdAPI<T, D>>::TOut>,

pub fn prod_axes( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpProdAPI<T, D>>::TOut>>::Raw>, <B as OpProdAPI<T, D>>::TOut, B>, Vec<usize>>

where B: DeviceCreationAnyAPI<<B as OpProdAPI<T, D>>::TOut>,

pub fn prod_f(&self) -> Result<<B as OpProdAPI<T, D>>::TOut, Error>

pub fn prod(&self) -> <B as OpProdAPI<T, D>>::TOut

impl<R, T, B, D> TensorBase<Storage<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 as OpMeanAPI<T, D>>::TOut, Error>

pub fn mean_all(&self) -> <B as OpMeanAPI<T, D>>::TOut

pub fn mean_axes_f( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpMeanAPI<T, D>>::TOut>>::Raw>, <B as OpMeanAPI<T, D>>::TOut, B>, Vec<usize>>, Error>

where B: DeviceCreationAnyAPI<<B as OpMeanAPI<T, D>>::TOut>,

pub fn mean_axes( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpMeanAPI<T, D>>::TOut>>::Raw>, <B as OpMeanAPI<T, D>>::TOut, B>, Vec<usize>>

where B: DeviceCreationAnyAPI<<B as OpMeanAPI<T, D>>::TOut>,

pub fn mean_f(&self) -> Result<<B as OpMeanAPI<T, D>>::TOut, Error>

pub fn mean(&self) -> <B as OpMeanAPI<T, D>>::TOut

impl<R, T, B, D> TensorBase<Storage<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 as OpVarAPI<T, D>>::TOut, Error>

pub fn var_all(&self) -> <B as OpVarAPI<T, D>>::TOut

pub fn var_axes_f( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpVarAPI<T, D>>::TOut>>::Raw>, <B as OpVarAPI<T, D>>::TOut, B>, Vec<usize>>, Error>

where B: DeviceCreationAnyAPI<<B as OpVarAPI<T, D>>::TOut>,

pub fn var_axes( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpVarAPI<T, D>>::TOut>>::Raw>, <B as OpVarAPI<T, D>>::TOut, B>, Vec<usize>>

where B: DeviceCreationAnyAPI<<B as OpVarAPI<T, D>>::TOut>,

pub fn var_f(&self) -> Result<<B as OpVarAPI<T, D>>::TOut, Error>

pub fn var(&self) -> <B as OpVarAPI<T, D>>::TOut

impl<R, T, B, D> TensorBase<Storage<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 as OpStdAPI<T, D>>::TOut, Error>

pub fn std_all(&self) -> <B as OpStdAPI<T, D>>::TOut

pub fn std_axes_f( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpStdAPI<T, D>>::TOut>>::Raw>, <B as OpStdAPI<T, D>>::TOut, B>, Vec<usize>>, Error>

where B: DeviceCreationAnyAPI<<B as OpStdAPI<T, D>>::TOut>,

pub fn std_axes( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpStdAPI<T, D>>::TOut>>::Raw>, <B as OpStdAPI<T, D>>::TOut, B>, Vec<usize>>

where B: DeviceCreationAnyAPI<<B as OpStdAPI<T, D>>::TOut>,

pub fn std_f(&self) -> Result<<B as OpStdAPI<T, D>>::TOut, Error>

pub fn std(&self) -> <B as OpStdAPI<T, D>>::TOut

impl<R, T, B, D> TensorBase<Storage<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 as OpL2NormAPI<T, D>>::TOut, Error>

pub fn l2_norm_all(&self) -> <B as OpL2NormAPI<T, D>>::TOut

pub fn l2_norm_axes_f( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpL2NormAPI<T, D>>::TOut>>::Raw>, <B as OpL2NormAPI<T, D>>::TOut, B>, Vec<usize>>, Error>

where B: DeviceCreationAnyAPI<<B as OpL2NormAPI<T, D>>::TOut>,

pub fn l2_norm_axes( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpL2NormAPI<T, D>>::TOut>>::Raw>, <B as OpL2NormAPI<T, D>>::TOut, B>, Vec<usize>>

where B: DeviceCreationAnyAPI<<B as OpL2NormAPI<T, D>>::TOut>,

pub fn l2_norm_f(&self) -> Result<<B as OpL2NormAPI<T, D>>::TOut, Error>

pub fn l2_norm(&self) -> <B as OpL2NormAPI<T, D>>::TOut

impl<R, T, B, D> TensorBase<Storage<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 as OpArgMinAPI<T, D>>::TOut, Error>

pub fn argmin_all(&self) -> <B as OpArgMinAPI<T, D>>::TOut

pub fn argmin_axes_f( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpArgMinAPI<T, D>>::TOut>>::Raw>, <B as OpArgMinAPI<T, D>>::TOut, B>, Vec<usize>>, Error>

where B: DeviceCreationAnyAPI<<B as OpArgMinAPI<T, D>>::TOut>,

pub fn argmin_axes( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpArgMinAPI<T, D>>::TOut>>::Raw>, <B as OpArgMinAPI<T, D>>::TOut, B>, Vec<usize>>

where B: DeviceCreationAnyAPI<<B as OpArgMinAPI<T, D>>::TOut>,

pub fn argmin_f(&self) -> Result<<B as OpArgMinAPI<T, D>>::TOut, Error>

pub fn argmin(&self) -> <B as OpArgMinAPI<T, D>>::TOut

impl<R, T, B, D> TensorBase<Storage<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 as OpArgMaxAPI<T, D>>::TOut, Error>

pub fn argmax_all(&self) -> <B as OpArgMaxAPI<T, D>>::TOut

pub fn argmax_axes_f( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpArgMaxAPI<T, D>>::TOut>>::Raw>, <B as OpArgMaxAPI<T, D>>::TOut, B>, Vec<usize>>, Error>

where B: DeviceCreationAnyAPI<<B as OpArgMaxAPI<T, D>>::TOut>,

pub fn argmax_axes( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpArgMaxAPI<T, D>>::TOut>>::Raw>, <B as OpArgMaxAPI<T, D>>::TOut, B>, Vec<usize>>

where B: DeviceCreationAnyAPI<<B as OpArgMaxAPI<T, D>>::TOut>,

pub fn argmax_f(&self) -> Result<<B as OpArgMaxAPI<T, D>>::TOut, Error>

pub fn argmax(&self) -> <B as OpArgMaxAPI<T, D>>::TOut

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn all_all_f(&self) -> Result<<B as OpAllAPI<T, D>>::TOut, Error>

pub fn all_all(&self) -> <B as OpAllAPI<T, D>>::TOut

pub fn all_axes_f( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpAllAPI<T, D>>::TOut>>::Raw>, <B as OpAllAPI<T, D>>::TOut, B>, Vec<usize>>, Error>

where B: DeviceCreationAnyAPI<<B as OpAllAPI<T, D>>::TOut>,

pub fn all_axes( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpAllAPI<T, D>>::TOut>>::Raw>, <B as OpAllAPI<T, D>>::TOut, B>, Vec<usize>>

where B: DeviceCreationAnyAPI<<B as OpAllAPI<T, D>>::TOut>,

pub fn all_f(&self) -> Result<<B as OpAllAPI<T, D>>::TOut, Error>

pub fn all(&self) -> <B as OpAllAPI<T, D>>::TOut

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn any_all_f(&self) -> Result<<B as OpAnyAPI<T, D>>::TOut, Error>

pub fn any_all(&self) -> <B as OpAnyAPI<T, D>>::TOut

pub fn any_axes_f( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpAnyAPI<T, D>>::TOut>>::Raw>, <B as OpAnyAPI<T, D>>::TOut, B>, Vec<usize>>, Error>

where B: DeviceCreationAnyAPI<<B as OpAnyAPI<T, D>>::TOut>,

pub fn any_axes( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpAnyAPI<T, D>>::TOut>>::Raw>, <B as OpAnyAPI<T, D>>::TOut, B>, Vec<usize>>

where B: DeviceCreationAnyAPI<<B as OpAnyAPI<T, D>>::TOut>,

pub fn any_f(&self) -> Result<<B as OpAnyAPI<T, D>>::TOut, Error>

pub fn any(&self) -> <B as OpAnyAPI<T, D>>::TOut

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

pub fn count_nonzero_all_f( &self, ) -> Result<<B as OpCountNonZeroAPI<T, D>>::TOut, Error>

pub fn count_nonzero_all(&self) -> <B as OpCountNonZeroAPI<T, D>>::TOut

pub fn count_nonzero_axes_f( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpCountNonZeroAPI<T, D>>::TOut>>::Raw>, <B as OpCountNonZeroAPI<T, D>>::TOut, B>, Vec<usize>>, Error>

where B: DeviceCreationAnyAPI<<B as OpCountNonZeroAPI<T, D>>::TOut>,

pub fn count_nonzero_axes( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as OpCountNonZeroAPI<T, D>>::TOut>>::Raw>, <B as OpCountNonZeroAPI<T, D>>::TOut, B>, Vec<usize>>

where B: DeviceCreationAnyAPI<<B as OpCountNonZeroAPI<T, D>>::TOut>,

pub fn count_nonzero_f( &self, ) -> Result<<B as OpCountNonZeroAPI<T, D>>::TOut, Error>

pub fn count_nonzero(&self) -> <B as OpCountNonZeroAPI<T, D>>::TOut

impl<R, T, B, D> TensorBase<Storage<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, Error>

pub fn unraveled_argmin_all(&self) -> D

pub fn unraveled_argmin_axes_f( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<Vec<usize>>>::Raw>, Vec<usize>, B>, Vec<usize>>, Error>

where B: DeviceAPI<Vec<usize>>,

pub fn unraveled_argmin_axes( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<Vec<usize>>>::Raw>, Vec<usize>, B>, Vec<usize>>

where B: DeviceAPI<Vec<usize>>,

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

pub fn unraveled_argmin(&self) -> D

impl<R, T, B, D> TensorBase<Storage<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, Error>

pub fn unraveled_argmax_all(&self) -> D

pub fn unraveled_argmax_axes_f( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<Vec<usize>>>::Raw>, Vec<usize>, B>, Vec<usize>>, Error>

where B: DeviceAPI<Vec<usize>>,

pub fn unraveled_argmax_axes( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<Vec<usize>>>::Raw>, Vec<usize>, B>, Vec<usize>>

where B: DeviceAPI<Vec<usize>>,

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

pub fn unraveled_argmax(&self) -> D

impl<S> TensorBase<S, [usize; 2]>

pub fn nrow(&self) -> usize

pub fn ncol(&self) -> usize

pub fn ld_row(&self) -> Option<usize>

Leading dimension in row-major order case.

This function will not return any value if the layout is not row-major.

pub fn ld_col(&self) -> Option<usize>

Leading dimension in column-major order case.

This function will not return any value if the layout is not column-major.

pub fn ld(&self, order: FlagOrder) -> Option<usize>

Leading dimension by order.

impl<S, D> TensorBase<S, D>

where D: DimAPI,

Basic definitions for tensor object.

pub unsafe fn new_unchecked(storage: S, layout: Layout<D>) -> TensorBase<S, D>

Initialize tensor object.

Safety

This function will not check whether data meets the standard of Storage<T, B>, or whether layout may exceed pointer bounds of data.

pub fn storage(&self) -> &S

pub fn storage_mut(&mut self) -> &mut S

pub fn layout(&self) -> &Layout<D>

pub fn shape(&self) -> &D

pub fn stride(&self) -> &<D as DimBaseAPI>::Stride

pub fn offset(&self) -> usize

pub fn ndim(&self) -> usize

pub fn size(&self) -> usize

pub fn into_data(self) -> S

pub fn into_raw_parts(self) -> (S, Layout<D>)

pub fn c_contig(&self) -> bool

pub fn f_contig(&self) -> bool

pub fn c_prefer(&self) -> bool

pub fn f_prefer(&self) -> bool

impl<R, T, B, D> TensorBase<Storage<R, T, B>, D>

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

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

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

pub fn device(&self) -> &B

pub fn data(&self) -> &R

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

pub fn raw(&self) -> &<B as DeviceRawAPI<T>>::Raw

pub fn raw_mut(&mut self) -> &mut <B as DeviceRawAPI<T>>::Raw

where R: DataMutAPI<Data = <B as DeviceRawAPI<T>>::Raw>,

impl<T, B, D> TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where B: DeviceAPI<T>, D: DimAPI,

pub fn is_owned(&self) -> bool

pub fn is_ref(&self) -> bool

impl<T, B, D> TensorBase<Storage<DataReference<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where B: DeviceAPI<T>, D: DimAPI,

pub fn is_ref(&self) -> bool

pub fn is_mut(&self) -> bool

Trait Implementations

impl<SA, DA, TrB> Add<TrB> for &TensorBase<SA, DA>

where DA: DimAPI, &TensorBase<SA, DA>: TensorAddAPI<TrB>,

type Output = <&TensorBase<SA, DA> as TensorAddAPI<TrB>>::Output

The resulting type after applying the + operator.

fn add(self, b: TrB) -> <&TensorBase<SA, DA> as Add<TrB>>::Output

Performs the + operation.

impl<TA, DA, B, TrB> Add<TrB> for TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorAddAPI<TrB>,

type Output = <TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorAddAPI<TrB>>::Output

The resulting type after applying the + operator.

fn add( self, b: TrB, ) -> <TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as Add<TrB>>::Output

Performs the + operation.

impl<TA, DA, B, TrB> Add<TrB> for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorAddAPI<TrB>,

type Output = <TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorAddAPI<TrB>>::Output

The resulting type after applying the + operator.

fn add( self, b: TrB, ) -> <TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as Add<TrB>>::Output

Performs the + operation.

impl<TA, DA, B, TrB> Add<TrB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorAddAPI<TrB>,

type Output = <TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorAddAPI<TrB>>::Output

The resulting type after applying the + operator.

fn add( self, b: TrB, ) -> <TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as Add<TrB>>::Output

Performs the + operation.

impl<TRB, RA, TA, DA, B> AddAssign<TRB> for TensorBase<Storage<RA, TA, B>, DA>

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

fn add_assign(&mut self, b: TRB)

Performs the += operation.

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

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

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

fn asarray_f( self, ) -> Result<<&TensorBase<Storage<R, T, B>, D> as AsArrayAPI<()>>::Out, Error>

fn asarray(self) -> Self::Out

where Self: Sized,

impl<T, B, D> AsArrayAPI<()> for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where 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<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as AsArrayAPI<()>>::Out, Error>

fn asarray(self) -> Self::Out

where Self: Sized,

impl<T, B, D> AsArrayAPI<()> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where 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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as AsArrayAPI<()>>::Out, Error>

fn asarray(self) -> Self::Out

where Self: Sized,

impl<SA, DA, TrB> BitAnd<TrB> for &TensorBase<SA, DA>

where DA: DimAPI, &TensorBase<SA, DA>: TensorBitAndAPI<TrB>,

type Output = <&TensorBase<SA, DA> as TensorBitAndAPI<TrB>>::Output

The resulting type after applying the & operator.

fn bitand(self, b: TrB) -> <&TensorBase<SA, DA> as BitAnd<TrB>>::Output

Performs the & operation.

impl<TA, DA, B, TrB> BitAnd<TrB> for TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorBitAndAPI<TrB>,

type Output = <TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorBitAndAPI<TrB>>::Output

The resulting type after applying the & operator.

fn bitand( self, b: TrB, ) -> <TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as BitAnd<TrB>>::Output

Performs the & operation.

impl<TA, DA, B, TrB> BitAnd<TrB> for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorBitAndAPI<TrB>,

type Output = <TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorBitAndAPI<TrB>>::Output

The resulting type after applying the & operator.

fn bitand( self, b: TrB, ) -> <TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as BitAnd<TrB>>::Output

Performs the & operation.

impl<TA, DA, B, TrB> BitAnd<TrB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorBitAndAPI<TrB>,

type Output = <TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorBitAndAPI<TrB>>::Output

The resulting type after applying the & operator.

fn bitand( self, b: TrB, ) -> <TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as BitAnd<TrB>>::Output

Performs the & operation.

impl<TRB, RA, TA, DA, B> BitAndAssign<TRB> for TensorBase<Storage<RA, TA, B>, DA>

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

fn bitand_assign(&mut self, b: TRB)

Performs the &= operation.

impl<SA, DA, TrB> BitOr<TrB> for &TensorBase<SA, DA>

where DA: DimAPI, &TensorBase<SA, DA>: TensorBitOrAPI<TrB>,

type Output = <&TensorBase<SA, DA> as TensorBitOrAPI<TrB>>::Output

The resulting type after applying the | operator.

fn bitor(self, b: TrB) -> <&TensorBase<SA, DA> as BitOr<TrB>>::Output

Performs the | operation.

impl<TA, DA, B, TrB> BitOr<TrB> for TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorBitOrAPI<TrB>,

type Output = <TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorBitOrAPI<TrB>>::Output

The resulting type after applying the | operator.

fn bitor( self, b: TrB, ) -> <TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as BitOr<TrB>>::Output

Performs the | operation.

impl<TA, DA, B, TrB> BitOr<TrB> for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorBitOrAPI<TrB>,

type Output = <TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorBitOrAPI<TrB>>::Output

The resulting type after applying the | operator.

fn bitor( self, b: TrB, ) -> <TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as BitOr<TrB>>::Output

Performs the | operation.

impl<TA, DA, B, TrB> BitOr<TrB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorBitOrAPI<TrB>,

type Output = <TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorBitOrAPI<TrB>>::Output

The resulting type after applying the | operator.

fn bitor( self, b: TrB, ) -> <TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as BitOr<TrB>>::Output

Performs the | operation.

impl<TRB, RA, TA, DA, B> BitOrAssign<TRB> for TensorBase<Storage<RA, TA, B>, DA>

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

fn bitor_assign(&mut self, b: TRB)

Performs the |= operation.

impl<SA, DA, TrB> BitXor<TrB> for &TensorBase<SA, DA>

where DA: DimAPI, &TensorBase<SA, DA>: TensorBitXorAPI<TrB>,

type Output = <&TensorBase<SA, DA> as TensorBitXorAPI<TrB>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, b: TrB) -> <&TensorBase<SA, DA> as BitXor<TrB>>::Output

Performs the ^ operation.

impl<TA, DA, B, TrB> BitXor<TrB> for TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorBitXorAPI<TrB>,

type Output = <TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorBitXorAPI<TrB>>::Output

The resulting type after applying the ^ operator.

fn bitxor( self, b: TrB, ) -> <TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as BitXor<TrB>>::Output

Performs the ^ operation.

impl<TA, DA, B, TrB> BitXor<TrB> for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorBitXorAPI<TrB>,

type Output = <TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorBitXorAPI<TrB>>::Output

The resulting type after applying the ^ operator.

fn bitxor( self, b: TrB, ) -> <TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as BitXor<TrB>>::Output

Performs the ^ operation.

impl<TA, DA, B, TrB> BitXor<TrB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorBitXorAPI<TrB>,

type Output = <TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorBitXorAPI<TrB>>::Output

The resulting type after applying the ^ operator.

fn bitxor( self, b: TrB, ) -> <TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as BitXor<TrB>>::Output

Performs the ^ operation.

impl<TRB, RA, TA, DA, B> BitXorAssign<TRB> for TensorBase<Storage<RA, TA, B>, DA>

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

fn bitxor_assign(&mut self, b: TRB)

Performs the ^= operation.

impl<T, B, D> Clone for TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where T: Clone, D: DimAPI, B: DeviceAPI<T> + DeviceRawAPI<MaybeUninit<T>> + DeviceCreationAnyAPI<T> + OpAssignAPI<T, D>, <B as DeviceRawAPI<T>>::Raw: Clone,

fn clone( &self, ) -> TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, B, D> Clone for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where T: Clone, D: DimAPI, B: DeviceAPI<T> + DeviceRawAPI<MaybeUninit<T>> + DeviceCreationAnyAPI<T> + OpAssignAPI<T, D>, <B as DeviceRawAPI<T>>::Raw: Clone,

fn clone( &self, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R, T, B, D> Debug for TensorBase<Storage<R, T, B>, D>

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

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

Formats the value using the given formatter.

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

where R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, T: Clone + Default, D: DimAPI, B: DeviceAPI<T> + DeviceCreationAnyAPI<T> + OpAssignAPI<T, [usize; 1]>,

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

fn diag_f( self, ) -> Result<<&TensorBase<Storage<R, T, B>, D> as DiagAPI<()>>::Out, Error>

fn diag(self) -> Self::Out

where Self: Sized,

impl<R, T, B, D> Display for TensorBase<Storage<R, T, B>, D>

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

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

Formats the value using the given formatter.

impl<SA, DA, TrB> Div<TrB> for &TensorBase<SA, DA>

where DA: DimAPI, &TensorBase<SA, DA>: TensorDivAPI<TrB>,

type Output = <&TensorBase<SA, DA> as TensorDivAPI<TrB>>::Output

The resulting type after applying the / operator.

fn div(self, b: TrB) -> <&TensorBase<SA, DA> as Div<TrB>>::Output

Performs the / operation.

impl<TA, DA, B, TrB> Div<TrB> for TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorDivAPI<TrB>,

type Output = <TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorDivAPI<TrB>>::Output

The resulting type after applying the / operator.

fn div( self, b: TrB, ) -> <TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as Div<TrB>>::Output

Performs the / operation.

impl<TA, DA, B, TrB> Div<TrB> for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorDivAPI<TrB>,

type Output = <TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorDivAPI<TrB>>::Output

The resulting type after applying the / operator.

fn div( self, b: TrB, ) -> <TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as Div<TrB>>::Output

Performs the / operation.

impl<TA, DA, B, TrB> Div<TrB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorDivAPI<TrB>,

type Output = <TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorDivAPI<TrB>>::Output

The resulting type after applying the / operator.

fn div( self, b: TrB, ) -> <TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as Div<TrB>>::Output

Performs the / operation.

impl<TRB, RA, TA, DA, B> DivAssign<TRB> for TensorBase<Storage<RA, TA, B>, DA>

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

fn div_assign(&mut self, b: TRB)

Performs the /= operation.

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

where R: DataAPI<Data = <B as DeviceRawAPI<T>>::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<<&TensorBase<Storage<R, T, B>, D> as EmptyLikeAPI<()>>::Out, Error>

Safety

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

where Self: Sized,

Safety

impl<'a, T> From<&'a [T]> for TensorBase<Storage<DataRef<'a, <DeviceCpuSerial as DeviceRawAPI<T>>::Raw>, T, DeviceCpuSerial>, Vec<usize>>

where T: Clone,

fn from( input: &'a [T], ) -> TensorBase<Storage<DataRef<'a, <DeviceCpuSerial as DeviceRawAPI<T>>::Raw>, T, DeviceCpuSerial>, Vec<usize>>

Converts to this type from the input type.

impl<'a, T> From<&'a Vec<T>> for TensorBase<Storage<DataRef<'a, <DeviceCpuSerial as DeviceRawAPI<T>>::Raw>, T, DeviceCpuSerial>, Vec<usize>>

where T: Clone,

fn from( input: &'a Vec<T>, ) -> TensorBase<Storage<DataRef<'a, <DeviceCpuSerial as DeviceRawAPI<T>>::Raw>, T, DeviceCpuSerial>, Vec<usize>>

Converts to this type from the input type.

impl<'a, T> From<&'a mut [T]> for TensorBase<Storage<DataMut<'a, <DeviceCpuSerial as DeviceRawAPI<T>>::Raw>, T, DeviceCpuSerial>, Vec<usize>>

where T: Clone,

fn from( input: &'a mut [T], ) -> TensorBase<Storage<DataMut<'a, <DeviceCpuSerial as DeviceRawAPI<T>>::Raw>, T, DeviceCpuSerial>, Vec<usize>>

Converts to this type from the input type.

impl<'a, T> From<&'a mut Vec<T>> for TensorBase<Storage<DataMut<'a, <DeviceCpuSerial as DeviceRawAPI<T>>::Raw>, T, DeviceCpuSerial>, Vec<usize>>

where T: Clone,

fn from( input: &'a mut Vec<T>, ) -> TensorBase<Storage<DataMut<'a, <DeviceCpuSerial as DeviceRawAPI<T>>::Raw>, T, DeviceCpuSerial>, Vec<usize>>

Converts to this type from the input type.

impl<'a, T, B, D> From<TensorBase<Storage<DataMut<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>> for TensorBase<Storage<DataReference<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where B: DeviceAPI<T>, D: DimAPI,

fn from( tensor: TensorBase<Storage<DataMut<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>, ) -> TensorBase<Storage<DataReference<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

Converts to this type from the input type.

impl<'a, T, B, D> From<TensorBase<Storage<DataRef<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>> for TensorBase<Storage<DataReference<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where B: DeviceAPI<T>, D: DimAPI,

fn from( tensor: TensorBase<Storage<DataRef<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>, ) -> TensorBase<Storage<DataReference<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

Converts to this type from the input type.

impl<'a, T, B, D> From<TensorBase<Storage<DataReference<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>> for TensorBase<Storage<DataMut<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where B: DeviceAPI<T>, D: DimAPI,

fn from( tensor: TensorBase<Storage<DataReference<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>, ) -> TensorBase<Storage<DataMut<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

Converts to this type from the input type.

impl<'a, T, B, D> From<TensorBase<Storage<DataReference<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>> for TensorBase<Storage<DataRef<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where B: DeviceAPI<T>, D: DimAPI,

fn from( tensor: TensorBase<Storage<DataReference<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>, ) -> TensorBase<Storage<DataRef<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

Converts to this type from the input type.

impl<T> From<Vec<T>> for TensorBase<Storage<DataOwned<<DeviceCpuSerial as DeviceRawAPI<T>>::Raw>, T, DeviceCpuSerial>, Vec<usize>>

where T: Clone,

fn from( input: Vec<T>, ) -> TensorBase<Storage<DataOwned<<DeviceCpuSerial as DeviceRawAPI<T>>::Raw>, T, DeviceCpuSerial>, Vec<usize>>

Converts to this type from the input type.

impl<T, B, const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize, const N6: usize> FromNestedArrayAPI<[[[[[[T; N6]; N5]; N4]; N3]; N2]; N1], B> for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, [usize; 6]>

where T: Clone, B: DeviceAPI<T> + DeviceCreationAnyAPI<T>,

fn from_nested_array( arr: [[[[[[T; N6]; N5]; N4]; N3]; N2]; N1], device: &B, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, [usize; 6]>

impl<T, B, const N1: usize, const N2: usize, const N3: usize, const N4: usize, const N5: usize> FromNestedArrayAPI<[[[[[T; N5]; N4]; N3]; N2]; N1], B> for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, [usize; 5]>

where T: Clone, B: DeviceAPI<T> + DeviceCreationAnyAPI<T>,

fn from_nested_array( arr: [[[[[T; N5]; N4]; N3]; N2]; N1], device: &B, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, [usize; 5]>

impl<T, B, const N1: usize, const N2: usize, const N3: usize, const N4: usize> FromNestedArrayAPI<[[[[T; N4]; N3]; N2]; N1], B> for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, [usize; 4]>

where T: Clone, B: DeviceAPI<T> + DeviceCreationAnyAPI<T>,

fn from_nested_array( arr: [[[[T; N4]; N3]; N2]; N1], device: &B, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, [usize; 4]>

impl<T, B, const N1: usize, const N2: usize, const N3: usize> FromNestedArrayAPI<[[[T; N3]; N2]; N1], B> for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, [usize; 3]>

where T: Clone, B: DeviceAPI<T> + DeviceCreationAnyAPI<T>,

fn from_nested_array( arr: [[[T; N3]; N2]; N1], device: &B, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, [usize; 3]>

impl<T, B, const N1: usize, const N2: usize> FromNestedArrayAPI<[[T; N2]; N1], B> for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, [usize; 2]>

where T: Clone, B: DeviceAPI<T> + DeviceCreationAnyAPI<T>,

fn from_nested_array( arr: [[T; N2]; N1], device: &B, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, [usize; 2]>

impl<T, B, const N1: usize> FromNestedArrayAPI<[T; N1], B> for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, [usize; 1]>

where T: Clone, B: DeviceAPI<T> + DeviceCreationAnyAPI<T>,

fn from_nested_array( arr: [T; N1], device: &B, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, [usize; 1]>

impl<T, D, B, I> Index<I> for TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where T: Clone, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>>, I: AsRef<[usize]>,

type Output = T

The returned type after indexing.

fn index( &self, index: I, ) -> &<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as Index<I>>::Output

Performs the indexing (container[index]) operation.

impl<T, D, B, I> Index<I> for TensorBase<Storage<DataMut<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where T: Clone, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>>, I: AsRef<[usize]>,

type Output = T

The returned type after indexing.

fn index( &self, index: I, ) -> &<TensorBase<Storage<DataMut<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as Index<I>>::Output

Performs the indexing (container[index]) operation.

impl<T, D, B, I> Index<I> for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where T: Clone, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>>, I: AsRef<[usize]>,

type Output = T

The returned type after indexing.

fn index( &self, index: I, ) -> &<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as Index<I>>::Output

Performs the indexing (container[index]) operation.

impl<T, D, B, I> Index<I> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where T: Clone, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>>, I: AsRef<[usize]>,

type Output = T

The returned type after indexing.

fn index( &self, index: I, ) -> &<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as Index<I>>::Output

Performs the indexing (container[index]) operation.

impl<T, D, B, I> IndexMut<I> for TensorBase<Storage<DataMut<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where T: Clone, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>>, I: AsRef<[usize]>,

fn index_mut( &mut self, index: I, ) -> &mut <TensorBase<Storage<DataMut<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as Index<I>>::Output

Performs the mutable indexing (container[index]) operation.

impl<T, D, B, I> IndexMut<I> for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where T: Clone, D: DimAPI, B: DeviceAPI<T, Raw = Vec<T>>, I: AsRef<[usize]>,

fn index_mut( &mut self, index: I, ) -> &mut <TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as Index<I>>::Output

Performs the mutable indexing (container[index]) operation.

impl<SA, DA, TrB> Mul<TrB> for &TensorBase<SA, DA>

where DA: DimAPI, &TensorBase<SA, DA>: TensorMulAPI<TrB>,

type Output = <&TensorBase<SA, DA> as TensorMulAPI<TrB>>::Output

The resulting type after applying the * operator.

fn mul(self, b: TrB) -> <&TensorBase<SA, DA> as Mul<TrB>>::Output

Performs the * operation.

impl<TA, DA, B, TrB> Mul<TrB> for TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorMulAPI<TrB>,

type Output = <TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorMulAPI<TrB>>::Output

The resulting type after applying the * operator.

fn mul( self, b: TrB, ) -> <TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as Mul<TrB>>::Output

Performs the * operation.

impl<TA, DA, B, TrB> Mul<TrB> for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorMulAPI<TrB>,

type Output = <TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorMulAPI<TrB>>::Output

The resulting type after applying the * operator.

fn mul( self, b: TrB, ) -> <TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as Mul<TrB>>::Output

Performs the * operation.

impl<TA, DA, B, TrB> Mul<TrB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorMulAPI<TrB>,

type Output = <TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorMulAPI<TrB>>::Output

The resulting type after applying the * operator.

fn mul( self, b: TrB, ) -> <TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as Mul<TrB>>::Output

Performs the * operation.

impl<TRB, RA, TA, DA, B> MulAssign<TRB> for TensorBase<Storage<RA, TA, B>, DA>

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

fn mul_assign(&mut self, b: TRB)

Performs the *= operation.

impl<R, T, B, D> Neg for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, &'a TensorBase<Storage<R, T, B>, D>: for<'a> TensorNegAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::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) -> <&TensorBase<Storage<R, T, B>, D> as Neg>::Output

Performs the unary - operation.

impl<R, T, B, D> Neg for TensorBase<Storage<R, T, B>, D>

where D: DimAPI, TensorBase<Storage<R, T, B>, D>: TensorNegAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::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) -> <TensorBase<Storage<R, T, B>, D> as Neg>::Output

Performs the unary - operation.

impl<R, T, B, D> Not for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, &'a TensorBase<Storage<R, T, B>, D>: for<'a> TensorNotAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::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) -> <&TensorBase<Storage<R, T, B>, D> as Not>::Output

Performs the unary ! operation.

impl<R, T, B, D> Not for TensorBase<Storage<R, T, B>, D>

where D: DimAPI, TensorBase<Storage<R, T, B>, D>: TensorNotAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::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) -> <TensorBase<Storage<R, T, B>, D> as Not>::Output

Performs the unary ! operation.

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

where R: DataAPI<Data = <B as DeviceRawAPI<T>>::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<<&TensorBase<Storage<R, T, B>, D> as OnesLikeAPI<()>>::Out, Error>

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 &TensorBase<Storage<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<Output = TC> + Add<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: &TensorBase<Storage<RB, TB, B>, DB>, ) -> <&TensorBase<Storage<RA, TA, B>, DA> as Rem<&TensorBase<Storage<RB, TB, B>, DB>>>::Output

Performs the % operation.

impl<RA, RB, TA, TB, TC, DA, DB, DC, B> Rem<&TensorBase<Storage<RB, TB, B>, DB>> for TensorBase<Storage<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<Output = TC> + Add<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: &TensorBase<Storage<RB, TB, B>, DB>, ) -> <TensorBase<Storage<RA, TA, B>, DA> as Rem<&TensorBase<Storage<RB, TB, B>, DB>>>::Output

Performs the % operation.

impl<RA, RB, TA, TB, TC, DA, DB, DC, B> Rem<TensorBase<Storage<RB, TB, B>, DB>> for &TensorBase<Storage<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<Output = TC> + Add<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: TensorBase<Storage<RB, TB, B>, DB>, ) -> <&TensorBase<Storage<RA, TA, B>, DA> as Rem<TensorBase<Storage<RB, TB, B>, DB>>>::Output

Performs the % operation.

impl<RA, RB, TA, TB, TC, DA, DB, DC, B> Rem<TensorBase<Storage<RB, TB, B>, DB>> for TensorBase<Storage<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<Output = TC> + Add<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: TensorBase<Storage<RB, TB, B>, DB>, ) -> <TensorBase<Storage<RA, TA, B>, DA> as Rem<TensorBase<Storage<RB, TB, B>, DB>>>::Output

Performs the % operation.

impl<TRB, RA, TA, DA, B> RemAssign<TRB> for TensorBase<Storage<RA, TA, B>, DA>

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

fn rem_assign(&mut self, b: TRB)

Performs the %= operation.

impl<SA, DA, TrB> Shl<TrB> for &TensorBase<SA, DA>

where DA: DimAPI, &TensorBase<SA, DA>: TensorShlAPI<TrB>,

type Output = <&TensorBase<SA, DA> as TensorShlAPI<TrB>>::Output

The resulting type after applying the << operator.

fn shl(self, b: TrB) -> <&TensorBase<SA, DA> as Shl<TrB>>::Output

Performs the << operation.

impl<TA, DA, B, TrB> Shl<TrB> for TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorShlAPI<TrB>,

type Output = <TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorShlAPI<TrB>>::Output

The resulting type after applying the << operator.

fn shl( self, b: TrB, ) -> <TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as Shl<TrB>>::Output

Performs the << operation.

impl<TA, DA, B, TrB> Shl<TrB> for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorShlAPI<TrB>,

type Output = <TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorShlAPI<TrB>>::Output

The resulting type after applying the << operator.

fn shl( self, b: TrB, ) -> <TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as Shl<TrB>>::Output

Performs the << operation.

impl<TA, DA, B, TrB> Shl<TrB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorShlAPI<TrB>,

type Output = <TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorShlAPI<TrB>>::Output

The resulting type after applying the << operator.

fn shl( self, b: TrB, ) -> <TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as Shl<TrB>>::Output

Performs the << operation.

impl<TRB, RA, TA, DA, B> ShlAssign<TRB> for TensorBase<Storage<RA, TA, B>, DA>

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

fn shl_assign(&mut self, b: TRB)

Performs the <<= operation.

impl<SA, DA, TrB> Shr<TrB> for &TensorBase<SA, DA>

where DA: DimAPI, &TensorBase<SA, DA>: TensorShrAPI<TrB>,

type Output = <&TensorBase<SA, DA> as TensorShrAPI<TrB>>::Output

The resulting type after applying the >> operator.

fn shr(self, b: TrB) -> <&TensorBase<SA, DA> as Shr<TrB>>::Output

Performs the >> operation.

impl<TA, DA, B, TrB> Shr<TrB> for TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorShrAPI<TrB>,

type Output = <TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorShrAPI<TrB>>::Output

The resulting type after applying the >> operator.

fn shr( self, b: TrB, ) -> <TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as Shr<TrB>>::Output

Performs the >> operation.

impl<TA, DA, B, TrB> Shr<TrB> for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorShrAPI<TrB>,

type Output = <TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorShrAPI<TrB>>::Output

The resulting type after applying the >> operator.

fn shr( self, b: TrB, ) -> <TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as Shr<TrB>>::Output

Performs the >> operation.

impl<TA, DA, B, TrB> Shr<TrB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorShrAPI<TrB>,

type Output = <TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorShrAPI<TrB>>::Output

The resulting type after applying the >> operator.

fn shr( self, b: TrB, ) -> <TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as Shr<TrB>>::Output

Performs the >> operation.

impl<TRB, RA, TA, DA, B> ShrAssign<TRB> for TensorBase<Storage<RA, TA, B>, DA>

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

fn shr_assign(&mut self, b: TRB)

Performs the >>= operation.

impl<SA, DA, TrB> Sub<TrB> for &TensorBase<SA, DA>

where DA: DimAPI, &TensorBase<SA, DA>: TensorSubAPI<TrB>,

type Output = <&TensorBase<SA, DA> as TensorSubAPI<TrB>>::Output

The resulting type after applying the - operator.

fn sub(self, b: TrB) -> <&TensorBase<SA, DA> as Sub<TrB>>::Output

Performs the - operation.

impl<TA, DA, B, TrB> Sub<TrB> for TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorSubAPI<TrB>,

type Output = <TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorSubAPI<TrB>>::Output

The resulting type after applying the - operator.

fn sub( self, b: TrB, ) -> <TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as Sub<TrB>>::Output

Performs the - operation.

impl<TA, DA, B, TrB> Sub<TrB> for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorSubAPI<TrB>,

type Output = <TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorSubAPI<TrB>>::Output

The resulting type after applying the - operator.

fn sub( self, b: TrB, ) -> <TensorBase<Storage<DataOwned<<B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as Sub<TrB>>::Output

Performs the - operation.

impl<TA, DA, B, TrB> Sub<TrB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceAPI<TA>, TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>: TensorSubAPI<TrB>,

type Output = <TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorSubAPI<TrB>>::Output

The resulting type after applying the - operator.

fn sub( self, b: TrB, ) -> <TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as Sub<TrB>>::Output

Performs the - operation.

impl<TRB, RA, TA, DA, B> SubAssign<TRB> for TensorBase<Storage<RA, TA, B>, DA>

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

fn sub_assign(&mut self, b: TRB)

Performs the -= operation.

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

where R: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceATan2API<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceATan2API<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceATan2API<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<R, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorATan2API<&TensorBase<Storage<R, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorATan2API<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorBase<Storage<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 as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceATan2API<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceATan2API<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceATan2API<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorATan2API<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

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

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

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

fn atan2_f( self, b: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<TA as TensorATan2API<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

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

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

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

fn atan2_f( self, b: TB, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorATan2API<TB>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, B> TensorATan2API<TB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceATan2API<TA, TB, DA> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceATan2API<TA, TB, DA>>::TOut> + DeviceCreationAnyAPI<<B as DeviceATan2API<TA, TB, DA>>::TOut>, TB: Num,

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

fn atan2_f( self, b: TB, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorATan2API<TB>>::Output, Error>

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

where Self: Sized,

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

where R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceATan2API<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceATan2API<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceATan2API<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<R, TA, B>, DA> as TensorATan2API<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DB, TB, B> TensorATan2API<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TA

where DB: DimAPI, B: DeviceATan2API<TA, TB, DB> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceATan2API<TA, TB, DB>>::TOut> + DeviceCreationAnyAPI<<B as DeviceATan2API<TA, TB, DB>>::TOut>, TA: Num,

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

fn atan2_f( self, b: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TA as TensorATan2API<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B> TensorATan2API<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceATan2API<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceATan2API<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceATan2API<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorATan2API<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<R, T, B, D> TensorAbsAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceAbsAPI<T, D>>::TOut> + DeviceAbsAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceAbsAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorAbsAPI>::Output, Error>

fn abs(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorAbsAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAbsAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn abs_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorAbsAPI>::Output, Error>

fn abs(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorAbsAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceAbsAPI<T, D>>::TOut> + DeviceAbsAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceAbsAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorAbsAPI>::Output, Error>

fn abs(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorAcosAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceAcosAPI<T, D>>::TOut> + DeviceAcosAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceAcosAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorAcosAPI>::Output, Error>

fn acos(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorAcosAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAcosAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn acos_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorAcosAPI>::Output, Error>

fn acos(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorAcosAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceAcosAPI<T, D>>::TOut> + DeviceAcosAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceAcosAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorAcosAPI>::Output, Error>

fn acos(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorAcoshAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceAcoshAPI<T, D>>::TOut> + DeviceAcoshAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceAcoshAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorAcoshAPI>::Output, Error>

fn acosh(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorAcoshAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAcoshAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn acosh_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorAcoshAPI>::Output, Error>

fn acosh(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorAcoshAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceAcoshAPI<T, D>>::TOut> + DeviceAcoshAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceAcoshAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorAcoshAPI>::Output, Error>

fn acosh(self) -> Self::Output

where Self: Sized,

impl<T, DA, DB, DC, B> TensorAddAPI<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>> for TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA>

where DA: DimAPI + DimMaxAPI<DB, Max = DC> + DimIntoAPI<DC>, DB: DimAPI + DimMaxAPI<DA, Max = DC> + DimIntoAPI<DC>, DC: DimAPI + DimIntoAPI<DA> + DimIntoAPI<DB>, B: DeviceAPI<T> + DeviceCreationAnyAPI<T> + DeviceAddAPI<T, T, T, DC> + DeviceLConsumeAddAPI<T, T, DA> + DeviceRConsumeAddAPI<T, T, DB> + OpAssignAPI<T, DA> + OpAssignAPI<T, DB>, T: Add<Output = T> + Clone, <B as DeviceRawAPI<T>>::Raw: Clone,

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

fn add_f( a: TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA>, b: TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>, ) -> Result<<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA> as TensorAddAPI<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>>>::Output, Error>

fn add(a: Self, b: TrB) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorAsinAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceAsinAPI<T, D>>::TOut> + DeviceAsinAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceAsinAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorAsinAPI>::Output, Error>

fn asin(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorAsinAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAsinAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn asin_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorAsinAPI>::Output, Error>

fn asin(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorAsinAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceAsinAPI<T, D>>::TOut> + DeviceAsinAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceAsinAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorAsinAPI>::Output, Error>

fn asin(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorAsinhAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceAsinhAPI<T, D>>::TOut> + DeviceAsinhAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceAsinhAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorAsinhAPI>::Output, Error>

fn asinh(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorAsinhAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAsinhAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn asinh_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorAsinhAPI>::Output, Error>

fn asinh(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorAsinhAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceAsinhAPI<T, D>>::TOut> + DeviceAsinhAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceAsinhAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorAsinhAPI>::Output, Error>

fn asinh(self) -> Self::Output

where Self: Sized,

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

where RA: DataMutAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI, DB: DimAPI, B: DeviceAPI<TA> + DeviceAPI<TB> + OpAssignAPI<TA, DA, TB>,

fn assign_f( a: &mut TensorBase<Storage<RA, TA, B>, DA>, b: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<(), Error>

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

impl<RA, DA, RB, DB, TA, TB, B> TensorAssignAPI<TensorBase<Storage<RB, TB, B>, DB>> for TensorBase<Storage<RA, TA, B>, DA>

where RA: DataMutAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI, DB: DimAPI, B: DeviceAPI<TA> + DeviceAPI<TB> + OpAssignAPI<TA, DA, TB>,

fn assign_f( a: &mut TensorBase<Storage<RA, TA, B>, DA>, b: TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<(), Error>

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

impl<R, T, B, D> TensorAtanAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceAtanAPI<T, D>>::TOut> + DeviceAtanAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceAtanAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorAtanAPI>::Output, Error>

fn atan(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorAtanAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAtanAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn atan_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorAtanAPI>::Output, Error>

fn atan(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorAtanAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceAtanAPI<T, D>>::TOut> + DeviceAtanAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceAtanAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorAtanAPI>::Output, Error>

fn atan(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorAtanhAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceAtanhAPI<T, D>>::TOut> + DeviceAtanhAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceAtanhAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorAtanhAPI>::Output, Error>

fn atanh(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorAtanhAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAtanhAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn atanh_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorAtanhAPI>::Output, Error>

fn atanh(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorAtanhAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceAtanhAPI<T, D>>::TOut> + DeviceAtanhAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceAtanhAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorAtanhAPI>::Output, Error>

fn atanh(self) -> Self::Output

where Self: Sized,

impl<T, DA, DB, DC, B> TensorBitAndAPI<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>> for TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA>

where DA: DimAPI + DimMaxAPI<DB, Max = DC> + DimIntoAPI<DC>, DB: DimAPI + DimMaxAPI<DA, Max = DC> + DimIntoAPI<DC>, DC: DimAPI + DimIntoAPI<DA> + DimIntoAPI<DB>, B: DeviceAPI<T> + DeviceCreationAnyAPI<T> + DeviceBitAndAPI<T, T, T, DC> + DeviceLConsumeBitAndAPI<T, T, DA> + DeviceRConsumeBitAndAPI<T, T, DB> + OpAssignAPI<T, DA> + OpAssignAPI<T, DB>, T: BitAnd<Output = T> + Clone, <B as DeviceRawAPI<T>>::Raw: Clone,

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

fn bitand_f( a: TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA>, b: TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>, ) -> Result<<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA> as TensorBitAndAPI<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>>>::Output, Error>

fn bitand(a: Self, b: TrB) -> Self::Output

where Self: Sized,

impl<T, DA, DB, DC, B> TensorBitOrAPI<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>> for TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA>

where DA: DimAPI + DimMaxAPI<DB, Max = DC> + DimIntoAPI<DC>, DB: DimAPI + DimMaxAPI<DA, Max = DC> + DimIntoAPI<DC>, DC: DimAPI + DimIntoAPI<DA> + DimIntoAPI<DB>, B: DeviceAPI<T> + DeviceCreationAnyAPI<T> + DeviceBitOrAPI<T, T, T, DC> + DeviceLConsumeBitOrAPI<T, T, DA> + DeviceRConsumeBitOrAPI<T, T, DB> + OpAssignAPI<T, DA> + OpAssignAPI<T, DB>, T: BitOr<Output = T> + Clone, <B as DeviceRawAPI<T>>::Raw: Clone,

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

fn bitor_f( a: TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA>, b: TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>, ) -> Result<<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA> as TensorBitOrAPI<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>>>::Output, Error>

fn bitor(a: Self, b: TrB) -> Self::Output

where Self: Sized,

impl<T, DA, DB, DC, B> TensorBitXorAPI<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>> for TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA>

where DA: DimAPI + DimMaxAPI<DB, Max = DC> + DimIntoAPI<DC>, DB: DimAPI + DimMaxAPI<DA, Max = DC> + DimIntoAPI<DC>, DC: DimAPI + DimIntoAPI<DA> + DimIntoAPI<DB>, B: DeviceAPI<T> + DeviceCreationAnyAPI<T> + DeviceBitXorAPI<T, T, T, DC> + DeviceLConsumeBitXorAPI<T, T, DA> + DeviceRConsumeBitXorAPI<T, T, DB> + OpAssignAPI<T, DA> + OpAssignAPI<T, DB>, T: BitXor<Output = T> + Clone, <B as DeviceRawAPI<T>>::Raw: Clone,

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

fn bitxor_f( a: TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA>, b: TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>, ) -> Result<<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA> as TensorBitXorAPI<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>>>::Output, Error>

fn bitxor(a: Self, b: TrB) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorCeilAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceCeilAPI<T, D>>::TOut> + DeviceCeilAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceCeilAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorCeilAPI>::Output, Error>

fn ceil(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorCeilAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceCeilAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn ceil_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorCeilAPI>::Output, Error>

fn ceil(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorCeilAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceCeilAPI<T, D>>::TOut> + DeviceCeilAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceCeilAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorCeilAPI>::Output, Error>

fn ceil(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorConjAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceConjAPI<T, D>>::TOut> + DeviceConjAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceConjAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorConjAPI>::Output, Error>

fn conj(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorConjAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceConjAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn conj_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorConjAPI>::Output, Error>

fn conj(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorConjAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceConjAPI<T, D>>::TOut> + DeviceConjAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceConjAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorConjAPI>::Output, Error>

fn conj(self) -> Self::Output

where Self: Sized,

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

where R: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceCopySignAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceCopySignAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceCopySignAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<R, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorCopySignAPI<&TensorBase<Storage<R, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorCopySignAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorBase<Storage<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 as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceCopySignAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceCopySignAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceCopySignAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorCopySignAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

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

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

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

fn copysign_f( self, b: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<TA as TensorCopySignAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

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

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

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

fn copysign_f( self, b: TB, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorCopySignAPI<TB>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, B> TensorCopySignAPI<TB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceCopySignAPI<TA, TB, DA> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceCopySignAPI<TA, TB, DA>>::TOut> + DeviceCreationAnyAPI<<B as DeviceCopySignAPI<TA, TB, DA>>::TOut>, TB: Num,

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

fn copysign_f( self, b: TB, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorCopySignAPI<TB>>::Output, Error>

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

where Self: Sized,

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

where R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceCopySignAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceCopySignAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceCopySignAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<R, TA, B>, DA> as TensorCopySignAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DB, TB, B> TensorCopySignAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TA

where DB: DimAPI, B: DeviceCopySignAPI<TA, TB, DB> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceCopySignAPI<TA, TB, DB>>::TOut> + DeviceCreationAnyAPI<<B as DeviceCopySignAPI<TA, TB, DB>>::TOut>, TA: Num,

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

fn copysign_f( self, b: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TA as TensorCopySignAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B> TensorCopySignAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceCopySignAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceCopySignAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceCopySignAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorCopySignAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<R, T, B, D> TensorCosAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceCosAPI<T, D>>::TOut> + DeviceCosAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceCosAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorCosAPI>::Output, Error>

fn cos(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorCosAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceCosAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn cos_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorCosAPI>::Output, Error>

fn cos(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorCosAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceCosAPI<T, D>>::TOut> + DeviceCosAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceCosAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorCosAPI>::Output, Error>

fn cos(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorCoshAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceCoshAPI<T, D>>::TOut> + DeviceCoshAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceCoshAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorCoshAPI>::Output, Error>

fn cosh(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorCoshAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceCoshAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn cosh_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorCoshAPI>::Output, Error>

fn cosh(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorCoshAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceCoshAPI<T, D>>::TOut> + DeviceCoshAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceCoshAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorCoshAPI>::Output, Error>

fn cosh(self) -> Self::Output

where Self: Sized,

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

where B: DeviceRawAPI<T> + DeviceChangeAPI<'a, BOut, R, T, D>, BOut: DeviceRawAPI<T>, D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::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<TensorBase<Storage<<B as DeviceChangeAPI<'a, BOut, R, T, D>>::Repr, T, BOut>, D>, Error>

fn into_device_f( self, device: &BOut, ) -> Result<TensorBase<Storage<DataOwned<<BOut as DeviceRawAPI<T>>::Raw>, T, BOut>, D>, Error>

fn to_device_f( &'a self, device: &BOut, ) -> Result<TensorBase<Storage<<B as DeviceChangeAPI<'a, BOut, R, T, D>>::ReprTo, <TensorBase<Storage<R, T, B>, D> as TensorDeviceChangeAPI<'a, BOut>>::Type, BOut>, <TensorBase<Storage<R, T, B>, D> as TensorDeviceChangeAPI<'a, BOut>>::Dim>, Error>

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

where Self: Sized,

fn into_device( self, device: &BOut, ) -> TensorBase<Storage<DataOwned<<BOut as DeviceRawAPI<Self::Type>>::Raw>, Self::Type, BOut>, Self::Dim>

where Self: Sized,

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

impl<T, DA, DB, DC, B> TensorDivAPI<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>> for TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA>

where DA: DimAPI + DimMaxAPI<DB, Max = DC> + DimIntoAPI<DC>, DB: DimAPI + DimMaxAPI<DA, Max = DC> + DimIntoAPI<DC>, DC: DimAPI + DimIntoAPI<DA> + DimIntoAPI<DB>, B: DeviceAPI<T> + DeviceCreationAnyAPI<T> + DeviceDivAPI<T, T, T, DC> + DeviceLConsumeDivAPI<T, T, DA> + DeviceRConsumeDivAPI<T, T, DB> + OpAssignAPI<T, DA> + OpAssignAPI<T, DB>, T: Div<Output = T> + Clone, <B as DeviceRawAPI<T>>::Raw: Clone,

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

fn div_f( a: TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA>, b: TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>, ) -> Result<<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA> as TensorDivAPI<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>>>::Output, Error>

fn div(a: Self, b: TrB) -> Self::Output

where Self: Sized,

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

where R: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<R, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorEqualAPI<&TensorBase<Storage<R, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorEqualAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorBase<Storage<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 as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorEqualAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

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

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

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

fn equal_f( self, b: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<TA as TensorEqualAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

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

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

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

fn equal_f( self, b: TB, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorEqualAPI<TB>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, B> TensorEqualAPI<TB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceEqualAPI<TA, TB, DA> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceEqualAPI<TA, TB, DA>>::TOut> + DeviceCreationAnyAPI<<B as DeviceEqualAPI<TA, TB, DA>>::TOut>, TB: Num,

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

fn equal_f( self, b: TB, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorEqualAPI<TB>>::Output, Error>

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

where Self: Sized,

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

where R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<R, TA, B>, DA> as TensorEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DB, TB, B> TensorEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TA

where DB: DimAPI, B: DeviceEqualAPI<TA, TB, DB> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceEqualAPI<TA, TB, DB>>::TOut> + DeviceCreationAnyAPI<<B as DeviceEqualAPI<TA, TB, DB>>::TOut>, TA: Num,

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

fn equal_f( self, b: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TA as TensorEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B> TensorEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<R, T, B, D> TensorExpAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceExpAPI<T, D>>::TOut> + DeviceExpAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceExpAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorExpAPI>::Output, Error>

fn exp(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorExpAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceExpAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn exp_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorExpAPI>::Output, Error>

fn exp(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorExpAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceExpAPI<T, D>>::TOut> + DeviceExpAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceExpAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorExpAPI>::Output, Error>

fn exp(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorExpm1API for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceExpm1API<T, D>>::TOut> + DeviceExpm1API<T, D> + DeviceCreationAnyAPI<<B as DeviceExpm1API<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorExpm1API>::Output, Error>

fn expm1(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorExpm1API for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceExpm1API<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn expm1_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorExpm1API>::Output, Error>

fn expm1(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorExpm1API for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceExpm1API<T, D>>::TOut> + DeviceExpm1API<T, D> + DeviceCreationAnyAPI<<B as DeviceExpm1API<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorExpm1API>::Output, Error>

fn expm1(self) -> Self::Output

where Self: Sized,

impl<RA, DA, TA, TB, B> TensorFillAPI<TB> for TensorBase<Storage<RA, TA, B>, DA>

where RA: DataMutAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI, B: DeviceAPI<TA> + OpAssignAPI<TA, DA, TB>,

fn fill_f( a: &mut TensorBase<Storage<RA, TA, B>, DA>, b: TB, ) -> Result<(), Error>

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

impl<R, T, B, D> TensorFloorAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceFloorAPI<T, D>>::TOut> + DeviceFloorAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceFloorAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorFloorAPI>::Output, Error>

fn floor(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorFloorAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceFloorAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn floor_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorFloorAPI>::Output, Error>

fn floor(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorFloorAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceFloorAPI<T, D>>::TOut> + DeviceFloorAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceFloorAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorFloorAPI>::Output, Error>

fn floor(self) -> Self::Output

where Self: Sized,

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

where R: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceFloorDivideAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceFloorDivideAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceFloorDivideAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<R, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorFloorDivideAPI<&TensorBase<Storage<R, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorFloorDivideAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorBase<Storage<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 as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceFloorDivideAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceFloorDivideAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceFloorDivideAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorFloorDivideAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

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

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

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

fn floor_divide_f( self, b: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<TA as TensorFloorDivideAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

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

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

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

fn floor_divide_f( self, b: TB, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorFloorDivideAPI<TB>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, B> TensorFloorDivideAPI<TB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceFloorDivideAPI<TA, TB, DA> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceFloorDivideAPI<TA, TB, DA>>::TOut> + DeviceCreationAnyAPI<<B as DeviceFloorDivideAPI<TA, TB, DA>>::TOut>, TB: Num,

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

fn floor_divide_f( self, b: TB, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorFloorDivideAPI<TB>>::Output, Error>

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

where Self: Sized,

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

where R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceFloorDivideAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceFloorDivideAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceFloorDivideAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<R, TA, B>, DA> as TensorFloorDivideAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DB, TB, B> TensorFloorDivideAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TA

where DB: DimAPI, B: DeviceFloorDivideAPI<TA, TB, DB> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceFloorDivideAPI<TA, TB, DB>>::TOut> + DeviceCreationAnyAPI<<B as DeviceFloorDivideAPI<TA, TB, DB>>::TOut>, TA: Num,

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

fn floor_divide_f( self, b: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TA as TensorFloorDivideAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B> TensorFloorDivideAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceFloorDivideAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceFloorDivideAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceFloorDivideAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorFloorDivideAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

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

where R: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceGreaterAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceGreaterAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceGreaterAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<R, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorGreaterAPI<&TensorBase<Storage<R, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorGreaterAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorBase<Storage<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 as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceGreaterAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceGreaterAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceGreaterAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorGreaterAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

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

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

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

fn greater_f( self, b: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<TA as TensorGreaterAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

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

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

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

fn greater_f( self, b: TB, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorGreaterAPI<TB>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, B> TensorGreaterAPI<TB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceGreaterAPI<TA, TB, DA> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceGreaterAPI<TA, TB, DA>>::TOut> + DeviceCreationAnyAPI<<B as DeviceGreaterAPI<TA, TB, DA>>::TOut>, TB: Num,

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

fn greater_f( self, b: TB, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorGreaterAPI<TB>>::Output, Error>

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

where Self: Sized,

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

where R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceGreaterAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceGreaterAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceGreaterAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<R, TA, B>, DA> as TensorGreaterAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DB, TB, B> TensorGreaterAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TA

where DB: DimAPI, B: DeviceGreaterAPI<TA, TB, DB> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceGreaterAPI<TA, TB, DB>>::TOut> + DeviceCreationAnyAPI<<B as DeviceGreaterAPI<TA, TB, DB>>::TOut>, TA: Num,

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

fn greater_f( self, b: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TA as TensorGreaterAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B> TensorGreaterAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceGreaterAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceGreaterAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceGreaterAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorGreaterAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

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

where R: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceGreaterEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceGreaterEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceGreaterEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<R, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorGreaterEqualAPI<&TensorBase<Storage<R, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorGreaterEqualAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorBase<Storage<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 as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceGreaterEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceGreaterEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceGreaterEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorGreaterEqualAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

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

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

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

fn greater_equal_f( self, b: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<TA as TensorGreaterEqualAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

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

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

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

fn greater_equal_f( self, b: TB, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorGreaterEqualAPI<TB>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, B> TensorGreaterEqualAPI<TB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceGreaterEqualAPI<TA, TB, DA> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceGreaterEqualAPI<TA, TB, DA>>::TOut> + DeviceCreationAnyAPI<<B as DeviceGreaterEqualAPI<TA, TB, DA>>::TOut>, TB: Num,

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

fn greater_equal_f( self, b: TB, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorGreaterEqualAPI<TB>>::Output, Error>

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

where Self: Sized,

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

where R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceGreaterEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceGreaterEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceGreaterEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<R, TA, B>, DA> as TensorGreaterEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DB, TB, B> TensorGreaterEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TA

where DB: DimAPI, B: DeviceGreaterEqualAPI<TA, TB, DB> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceGreaterEqualAPI<TA, TB, DB>>::TOut> + DeviceCreationAnyAPI<<B as DeviceGreaterEqualAPI<TA, TB, DB>>::TOut>, TA: Num,

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

fn greater_equal_f( self, b: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TA as TensorGreaterEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B> TensorGreaterEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceGreaterEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceGreaterEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceGreaterEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorGreaterEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

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

where R: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceHypotAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceHypotAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceHypotAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<R, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorHypotAPI<&TensorBase<Storage<R, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorHypotAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorBase<Storage<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 as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceHypotAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceHypotAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceHypotAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorHypotAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

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

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

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

fn hypot_f( self, b: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<TA as TensorHypotAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

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

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

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

fn hypot_f( self, b: TB, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorHypotAPI<TB>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, B> TensorHypotAPI<TB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceHypotAPI<TA, TB, DA> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceHypotAPI<TA, TB, DA>>::TOut> + DeviceCreationAnyAPI<<B as DeviceHypotAPI<TA, TB, DA>>::TOut>, TB: Num,

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

fn hypot_f( self, b: TB, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorHypotAPI<TB>>::Output, Error>

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

where Self: Sized,

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

where R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceHypotAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceHypotAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceHypotAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<R, TA, B>, DA> as TensorHypotAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DB, TB, B> TensorHypotAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TA

where DB: DimAPI, B: DeviceHypotAPI<TA, TB, DB> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceHypotAPI<TA, TB, DB>>::TOut> + DeviceCreationAnyAPI<<B as DeviceHypotAPI<TA, TB, DB>>::TOut>, TA: Num,

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

fn hypot_f( self, b: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TA as TensorHypotAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B> TensorHypotAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceHypotAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceHypotAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceHypotAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorHypotAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<R, T, B, D> TensorImagAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceImagAPI<T, D>>::TOut> + DeviceImagAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceImagAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorImagAPI>::Output, Error>

fn imag(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorImagAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceImagAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn imag_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorImagAPI>::Output, Error>

fn imag(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorImagAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceImagAPI<T, D>>::TOut> + DeviceImagAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceImagAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorImagAPI>::Output, Error>

fn imag(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorIntoOwnedAPI<T, B, D> for TensorBase<Storage<R, T, B>, D>

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

fn into_owned( self, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

Convert tensor into owned tensor.

impl<R, T, B, D> TensorInvAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceInvAPI<T, D>>::TOut> + DeviceInvAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceInvAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorInvAPI>::Output, Error>

fn inv(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorInvAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceInvAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn inv_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorInvAPI>::Output, Error>

fn inv(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorInvAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceInvAPI<T, D>>::TOut> + DeviceInvAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceInvAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorInvAPI>::Output, Error>

fn inv(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorIsFiniteAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceIsFiniteAPI<T, D>>::TOut> + DeviceIsFiniteAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceIsFiniteAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorIsFiniteAPI>::Output, Error>

fn is_finite(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorIsFiniteAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceIsFiniteAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn is_finite_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorIsFiniteAPI>::Output, Error>

fn is_finite(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorIsFiniteAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceIsFiniteAPI<T, D>>::TOut> + DeviceIsFiniteAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceIsFiniteAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorIsFiniteAPI>::Output, Error>

fn is_finite(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorIsInfAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceIsInfAPI<T, D>>::TOut> + DeviceIsInfAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceIsInfAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorIsInfAPI>::Output, Error>

fn is_inf(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorIsInfAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceIsInfAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn is_inf_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorIsInfAPI>::Output, Error>

fn is_inf(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorIsInfAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceIsInfAPI<T, D>>::TOut> + DeviceIsInfAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceIsInfAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorIsInfAPI>::Output, Error>

fn is_inf(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorIsNanAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceIsNanAPI<T, D>>::TOut> + DeviceIsNanAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceIsNanAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorIsNanAPI>::Output, Error>

fn is_nan(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorIsNanAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceIsNanAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn is_nan_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorIsNanAPI>::Output, Error>

fn is_nan(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorIsNanAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceIsNanAPI<T, D>>::TOut> + DeviceIsNanAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceIsNanAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorIsNanAPI>::Output, Error>

fn is_nan(self) -> Self::Output

where Self: Sized,

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

where R: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceLessAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceLessAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceLessAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<R, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorLessAPI<&TensorBase<Storage<R, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorLessAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorBase<Storage<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 as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceLessAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceLessAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceLessAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorLessAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

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

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

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

fn less_f( self, b: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<TA as TensorLessAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

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

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

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

fn less_f( self, b: TB, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorLessAPI<TB>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, B> TensorLessAPI<TB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceLessAPI<TA, TB, DA> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceLessAPI<TA, TB, DA>>::TOut> + DeviceCreationAnyAPI<<B as DeviceLessAPI<TA, TB, DA>>::TOut>, TB: Num,

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

fn less_f( self, b: TB, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorLessAPI<TB>>::Output, Error>

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

where Self: Sized,

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

where R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceLessAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceLessAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceLessAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<R, TA, B>, DA> as TensorLessAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DB, TB, B> TensorLessAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TA

where DB: DimAPI, B: DeviceLessAPI<TA, TB, DB> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceLessAPI<TA, TB, DB>>::TOut> + DeviceCreationAnyAPI<<B as DeviceLessAPI<TA, TB, DB>>::TOut>, TA: Num,

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

fn less_f( self, b: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TA as TensorLessAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B> TensorLessAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceLessAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceLessAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceLessAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorLessAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

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

where R: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceLessEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceLessEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceLessEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<R, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorLessEqualAPI<&TensorBase<Storage<R, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorLessEqualAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorBase<Storage<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 as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceLessEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceLessEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceLessEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorLessEqualAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

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

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

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

fn less_equal_f( self, b: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<TA as TensorLessEqualAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

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

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

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

fn less_equal_f( self, b: TB, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorLessEqualAPI<TB>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, B> TensorLessEqualAPI<TB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceLessEqualAPI<TA, TB, DA> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceLessEqualAPI<TA, TB, DA>>::TOut> + DeviceCreationAnyAPI<<B as DeviceLessEqualAPI<TA, TB, DA>>::TOut>, TB: Num,

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

fn less_equal_f( self, b: TB, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorLessEqualAPI<TB>>::Output, Error>

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

where Self: Sized,

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

where R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceLessEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceLessEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceLessEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<R, TA, B>, DA> as TensorLessEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DB, TB, B> TensorLessEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TA

where DB: DimAPI, B: DeviceLessEqualAPI<TA, TB, DB> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceLessEqualAPI<TA, TB, DB>>::TOut> + DeviceCreationAnyAPI<<B as DeviceLessEqualAPI<TA, TB, DB>>::TOut>, TA: Num,

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

fn less_equal_f( self, b: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TA as TensorLessEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B> TensorLessEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceLessEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceLessEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceLessEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorLessEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<R, T, B, D> TensorLog10API for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceLog10API<T, D>>::TOut> + DeviceLog10API<T, D> + DeviceCreationAnyAPI<<B as DeviceLog10API<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorLog10API>::Output, Error>

fn log10(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorLog10API for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceLog10API<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn log10_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorLog10API>::Output, Error>

fn log10(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorLog10API for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceLog10API<T, D>>::TOut> + DeviceLog10API<T, D> + DeviceCreationAnyAPI<<B as DeviceLog10API<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorLog10API>::Output, Error>

fn log10(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorLog1pAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceLog1pAPI<T, D>>::TOut> + DeviceLog1pAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceLog1pAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorLog1pAPI>::Output, Error>

fn log1p(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorLog1pAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceLog1pAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn log1p_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorLog1pAPI>::Output, Error>

fn log1p(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorLog1pAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceLog1pAPI<T, D>>::TOut> + DeviceLog1pAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceLog1pAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorLog1pAPI>::Output, Error>

fn log1p(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorLog2API for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceLog2API<T, D>>::TOut> + DeviceLog2API<T, D> + DeviceCreationAnyAPI<<B as DeviceLog2API<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorLog2API>::Output, Error>

fn log2(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorLog2API for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceLog2API<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn log2_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorLog2API>::Output, Error>

fn log2(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorLog2API for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceLog2API<T, D>>::TOut> + DeviceLog2API<T, D> + DeviceCreationAnyAPI<<B as DeviceLog2API<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorLog2API>::Output, Error>

fn log2(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorLogAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceLogAPI<T, D>>::TOut> + DeviceLogAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceLogAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorLogAPI>::Output, Error>

fn log(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorLogAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceLogAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn log_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorLogAPI>::Output, Error>

fn log(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorLogAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceLogAPI<T, D>>::TOut> + DeviceLogAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceLogAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorLogAPI>::Output, Error>

fn log(self) -> Self::Output

where Self: Sized,

impl<TA, DA, TB, DB, B, R> TensorLogAddExpAPI<&TensorBase<Storage<R, TB, B>, DB>> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where R: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceLogAddExpAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceLogAddExpAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceLogAddExpAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<R, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorLogAddExpAPI<&TensorBase<Storage<R, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorLogAddExpAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorBase<Storage<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 as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceLogAddExpAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceLogAddExpAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceLogAddExpAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorLogAddExpAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RB, TA, DB, TB, B> TensorLogAddExpAPI<&TensorBase<Storage<RB, TB, B>, DB>> for TA

where RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DB: DimAPI, B: DeviceLogAddExpAPI<TA, TB, DB> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceLogAddExpAPI<TA, TB, DB>>::TOut> + DeviceCreationAnyAPI<<B as DeviceLogAddExpAPI<TA, TB, DB>>::TOut>, TA: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceLogAddExpAPI<TA, TB, DB>>::TOut>>::Raw>, <B as DeviceLogAddExpAPI<TA, TB, DB>>::TOut, B>, DB>

fn log_add_exp_f( self, b: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<TA as TensorLogAddExpAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RA, TA, DA, TB, B> TensorLogAddExpAPI<TB> for &TensorBase<Storage<RA, TA, B>, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI, B: DeviceLogAddExpAPI<TA, TB, DA> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceLogAddExpAPI<TA, TB, DA>>::TOut> + DeviceCreationAnyAPI<<B as DeviceLogAddExpAPI<TA, TB, DA>>::TOut>, TB: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceLogAddExpAPI<TA, TB, DA>>::TOut>>::Raw>, <B as DeviceLogAddExpAPI<TA, TB, DA>>::TOut, B>, DA>

fn log_add_exp_f( self, b: TB, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorLogAddExpAPI<TB>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, B> TensorLogAddExpAPI<TB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceLogAddExpAPI<TA, TB, DA> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceLogAddExpAPI<TA, TB, DA>>::TOut> + DeviceCreationAnyAPI<<B as DeviceLogAddExpAPI<TA, TB, DA>>::TOut>, TB: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceLogAddExpAPI<TA, TB, DA>>::TOut>>::Raw>, <B as DeviceLogAddExpAPI<TA, TB, DA>>::TOut, B>, DA>

fn log_add_exp_f( self, b: TB, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorLogAddExpAPI<TB>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B, R> TensorLogAddExpAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for &TensorBase<Storage<R, TA, B>, DA>

where R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceLogAddExpAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceLogAddExpAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceLogAddExpAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<R, TA, B>, DA> as TensorLogAddExpAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DB, TB, B> TensorLogAddExpAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TA

where DB: DimAPI, B: DeviceLogAddExpAPI<TA, TB, DB> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceLogAddExpAPI<TA, TB, DB>>::TOut> + DeviceCreationAnyAPI<<B as DeviceLogAddExpAPI<TA, TB, DB>>::TOut>, TA: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceLogAddExpAPI<TA, TB, DB>>::TOut>>::Raw>, <B as DeviceLogAddExpAPI<TA, TB, DB>>::TOut, B>, DB>

fn log_add_exp_f( self, b: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TA as TensorLogAddExpAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B> TensorLogAddExpAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceLogAddExpAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceLogAddExpAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceLogAddExpAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorLogAddExpAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B, R> TensorMaximumAPI<&TensorBase<Storage<R, TB, B>, DB>> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where R: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceMaximumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceMaximumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceMaximumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<R, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorMaximumAPI<&TensorBase<Storage<R, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorMaximumAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorBase<Storage<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 as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceMaximumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceMaximumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceMaximumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorMaximumAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RB, TA, DB, TB, B> TensorMaximumAPI<&TensorBase<Storage<RB, TB, B>, DB>> for TA

where RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DB: DimAPI, B: DeviceMaximumAPI<TA, TB, DB> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceMaximumAPI<TA, TB, DB>>::TOut> + DeviceCreationAnyAPI<<B as DeviceMaximumAPI<TA, TB, DB>>::TOut>, TA: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceMaximumAPI<TA, TB, DB>>::TOut>>::Raw>, <B as DeviceMaximumAPI<TA, TB, DB>>::TOut, B>, DB>

fn maximum_f( self, b: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<TA as TensorMaximumAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RA, TA, DA, TB, B> TensorMaximumAPI<TB> for &TensorBase<Storage<RA, TA, B>, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI, B: DeviceMaximumAPI<TA, TB, DA> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceMaximumAPI<TA, TB, DA>>::TOut> + DeviceCreationAnyAPI<<B as DeviceMaximumAPI<TA, TB, DA>>::TOut>, TB: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceMaximumAPI<TA, TB, DA>>::TOut>>::Raw>, <B as DeviceMaximumAPI<TA, TB, DA>>::TOut, B>, DA>

fn maximum_f( self, b: TB, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorMaximumAPI<TB>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, B> TensorMaximumAPI<TB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceMaximumAPI<TA, TB, DA> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceMaximumAPI<TA, TB, DA>>::TOut> + DeviceCreationAnyAPI<<B as DeviceMaximumAPI<TA, TB, DA>>::TOut>, TB: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceMaximumAPI<TA, TB, DA>>::TOut>>::Raw>, <B as DeviceMaximumAPI<TA, TB, DA>>::TOut, B>, DA>

fn maximum_f( self, b: TB, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorMaximumAPI<TB>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B, R> TensorMaximumAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for &TensorBase<Storage<R, TA, B>, DA>

where R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceMaximumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceMaximumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceMaximumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<R, TA, B>, DA> as TensorMaximumAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DB, TB, B> TensorMaximumAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TA

where DB: DimAPI, B: DeviceMaximumAPI<TA, TB, DB> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceMaximumAPI<TA, TB, DB>>::TOut> + DeviceCreationAnyAPI<<B as DeviceMaximumAPI<TA, TB, DB>>::TOut>, TA: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceMaximumAPI<TA, TB, DB>>::TOut>>::Raw>, <B as DeviceMaximumAPI<TA, TB, DB>>::TOut, B>, DB>

fn maximum_f( self, b: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TA as TensorMaximumAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B> TensorMaximumAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceMaximumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceMaximumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceMaximumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorMaximumAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B, R> TensorMinimumAPI<&TensorBase<Storage<R, TB, B>, DB>> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where R: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceMinimumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceMinimumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceMinimumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<R, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorMinimumAPI<&TensorBase<Storage<R, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorMinimumAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorBase<Storage<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 as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceMinimumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceMinimumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceMinimumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorMinimumAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RB, TA, DB, TB, B> TensorMinimumAPI<&TensorBase<Storage<RB, TB, B>, DB>> for TA

where RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DB: DimAPI, B: DeviceMinimumAPI<TA, TB, DB> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceMinimumAPI<TA, TB, DB>>::TOut> + DeviceCreationAnyAPI<<B as DeviceMinimumAPI<TA, TB, DB>>::TOut>, TA: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceMinimumAPI<TA, TB, DB>>::TOut>>::Raw>, <B as DeviceMinimumAPI<TA, TB, DB>>::TOut, B>, DB>

fn minimum_f( self, b: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<TA as TensorMinimumAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RA, TA, DA, TB, B> TensorMinimumAPI<TB> for &TensorBase<Storage<RA, TA, B>, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI, B: DeviceMinimumAPI<TA, TB, DA> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceMinimumAPI<TA, TB, DA>>::TOut> + DeviceCreationAnyAPI<<B as DeviceMinimumAPI<TA, TB, DA>>::TOut>, TB: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceMinimumAPI<TA, TB, DA>>::TOut>>::Raw>, <B as DeviceMinimumAPI<TA, TB, DA>>::TOut, B>, DA>

fn minimum_f( self, b: TB, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorMinimumAPI<TB>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, B> TensorMinimumAPI<TB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceMinimumAPI<TA, TB, DA> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceMinimumAPI<TA, TB, DA>>::TOut> + DeviceCreationAnyAPI<<B as DeviceMinimumAPI<TA, TB, DA>>::TOut>, TB: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceMinimumAPI<TA, TB, DA>>::TOut>>::Raw>, <B as DeviceMinimumAPI<TA, TB, DA>>::TOut, B>, DA>

fn minimum_f( self, b: TB, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorMinimumAPI<TB>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B, R> TensorMinimumAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for &TensorBase<Storage<R, TA, B>, DA>

where R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceMinimumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceMinimumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceMinimumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<R, TA, B>, DA> as TensorMinimumAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DB, TB, B> TensorMinimumAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TA

where DB: DimAPI, B: DeviceMinimumAPI<TA, TB, DB> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceMinimumAPI<TA, TB, DB>>::TOut> + DeviceCreationAnyAPI<<B as DeviceMinimumAPI<TA, TB, DB>>::TOut>, TA: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceMinimumAPI<TA, TB, DB>>::TOut>>::Raw>, <B as DeviceMinimumAPI<TA, TB, DB>>::TOut, B>, DB>

fn minimum_f( self, b: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TA as TensorMinimumAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B> TensorMinimumAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceMinimumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceMinimumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceMinimumAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorMinimumAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<T, DA, DB, DC, B> TensorMulAPI<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>> for TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA>

where DA: DimAPI + DimMaxAPI<DB, Max = DC> + DimIntoAPI<DC>, DB: DimAPI + DimMaxAPI<DA, Max = DC> + DimIntoAPI<DC>, DC: DimAPI + DimIntoAPI<DA> + DimIntoAPI<DB>, B: DeviceAPI<T> + DeviceCreationAnyAPI<T> + DeviceMulAPI<T, T, T, DC> + DeviceLConsumeMulAPI<T, T, DA> + DeviceRConsumeMulAPI<T, T, DB> + OpAssignAPI<T, DA> + OpAssignAPI<T, DB>, T: Mul<Output = T> + Clone, <B as DeviceRawAPI<T>>::Raw: Clone,

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

fn mul_f( a: TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA>, b: TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>, ) -> Result<<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA> as TensorMulAPI<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>>>::Output, Error>

fn mul(a: Self, b: TrB) -> Self::Output

where Self: Sized,

impl<TA, DA, TB, DB, B, R> TensorNextAfterAPI<&TensorBase<Storage<R, TB, B>, DB>> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

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

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

fn nextafter_f( self, b: &TensorBase<Storage<R, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorNextAfterAPI<&TensorBase<Storage<R, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorNextAfterAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorBase<Storage<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 as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceNextAfterAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceNextAfterAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceNextAfterAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut>,

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

fn nextafter_f( self, b: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorNextAfterAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RB, TA, DB, TB, B> TensorNextAfterAPI<&TensorBase<Storage<RB, TB, B>, DB>> for TA

where RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DB: DimAPI, B: DeviceNextAfterAPI<TA, TB, DB> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceNextAfterAPI<TA, TB, DB>>::TOut> + DeviceCreationAnyAPI<<B as DeviceNextAfterAPI<TA, TB, DB>>::TOut>, TA: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceNextAfterAPI<TA, TB, DB>>::TOut>>::Raw>, <B as DeviceNextAfterAPI<TA, TB, DB>>::TOut, B>, DB>

fn nextafter_f( self, b: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<TA as TensorNextAfterAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RA, TA, DA, TB, B> TensorNextAfterAPI<TB> for &TensorBase<Storage<RA, TA, B>, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI, B: DeviceNextAfterAPI<TA, TB, DA> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceNextAfterAPI<TA, TB, DA>>::TOut> + DeviceCreationAnyAPI<<B as DeviceNextAfterAPI<TA, TB, DA>>::TOut>, TB: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceNextAfterAPI<TA, TB, DA>>::TOut>>::Raw>, <B as DeviceNextAfterAPI<TA, TB, DA>>::TOut, B>, DA>

fn nextafter_f( self, b: TB, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorNextAfterAPI<TB>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, B> TensorNextAfterAPI<TB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceNextAfterAPI<TA, TB, DA> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceNextAfterAPI<TA, TB, DA>>::TOut> + DeviceCreationAnyAPI<<B as DeviceNextAfterAPI<TA, TB, DA>>::TOut>, TB: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceNextAfterAPI<TA, TB, DA>>::TOut>>::Raw>, <B as DeviceNextAfterAPI<TA, TB, DA>>::TOut, B>, DA>

fn nextafter_f( self, b: TB, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorNextAfterAPI<TB>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B, R> TensorNextAfterAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for &TensorBase<Storage<R, TA, B>, DA>

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

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

fn nextafter_f( self, b: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<R, TA, B>, DA> as TensorNextAfterAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DB, TB, B> TensorNextAfterAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TA

where DB: DimAPI, B: DeviceNextAfterAPI<TA, TB, DB> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceNextAfterAPI<TA, TB, DB>>::TOut> + DeviceCreationAnyAPI<<B as DeviceNextAfterAPI<TA, TB, DB>>::TOut>, TA: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceNextAfterAPI<TA, TB, DB>>::TOut>>::Raw>, <B as DeviceNextAfterAPI<TA, TB, DB>>::TOut, B>, DB>

fn nextafter_f( self, b: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TA as TensorNextAfterAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B> TensorNextAfterAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

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

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

fn nextafter_f( self, b: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorNextAfterAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B, R> TensorNotEqualAPI<&TensorBase<Storage<R, TB, B>, DB>> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where R: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceNotEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceNotEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceNotEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<R, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorNotEqualAPI<&TensorBase<Storage<R, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorNotEqualAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorBase<Storage<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 as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceNotEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceNotEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceNotEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorNotEqualAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RB, TA, DB, TB, B> TensorNotEqualAPI<&TensorBase<Storage<RB, TB, B>, DB>> for TA

where RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DB: DimAPI, B: DeviceNotEqualAPI<TA, TB, DB> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceNotEqualAPI<TA, TB, DB>>::TOut> + DeviceCreationAnyAPI<<B as DeviceNotEqualAPI<TA, TB, DB>>::TOut>, TA: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceNotEqualAPI<TA, TB, DB>>::TOut>>::Raw>, <B as DeviceNotEqualAPI<TA, TB, DB>>::TOut, B>, DB>

fn not_equal_f( self, b: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<TA as TensorNotEqualAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RA, TA, DA, TB, B> TensorNotEqualAPI<TB> for &TensorBase<Storage<RA, TA, B>, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI, B: DeviceNotEqualAPI<TA, TB, DA> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceNotEqualAPI<TA, TB, DA>>::TOut> + DeviceCreationAnyAPI<<B as DeviceNotEqualAPI<TA, TB, DA>>::TOut>, TB: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceNotEqualAPI<TA, TB, DA>>::TOut>>::Raw>, <B as DeviceNotEqualAPI<TA, TB, DA>>::TOut, B>, DA>

fn not_equal_f( self, b: TB, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorNotEqualAPI<TB>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, B> TensorNotEqualAPI<TB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DeviceNotEqualAPI<TA, TB, DA> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceNotEqualAPI<TA, TB, DA>>::TOut> + DeviceCreationAnyAPI<<B as DeviceNotEqualAPI<TA, TB, DA>>::TOut>, TB: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceNotEqualAPI<TA, TB, DA>>::TOut>>::Raw>, <B as DeviceNotEqualAPI<TA, TB, DA>>::TOut, B>, DA>

fn not_equal_f( self, b: TB, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorNotEqualAPI<TB>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B, R> TensorNotEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for &TensorBase<Storage<R, TA, B>, DA>

where R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceNotEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceNotEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceNotEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<R, TA, B>, DA> as TensorNotEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DB, TB, B> TensorNotEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TA

where DB: DimAPI, B: DeviceNotEqualAPI<TA, TB, DB> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceNotEqualAPI<TA, TB, DB>>::TOut> + DeviceCreationAnyAPI<<B as DeviceNotEqualAPI<TA, TB, DB>>::TOut>, TA: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DeviceNotEqualAPI<TA, TB, DB>>::TOut>>::Raw>, <B as DeviceNotEqualAPI<TA, TB, DB>>::TOut, B>, DB>

fn not_equal_f( self, b: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TA as TensorNotEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B> TensorNotEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DeviceNotEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DeviceNotEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DeviceNotEqualAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorNotEqualAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B, R> TensorPowAPI<&TensorBase<Storage<R, TB, B>, DB>> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where R: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DevicePowAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DevicePowAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DevicePowAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<R, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorPowAPI<&TensorBase<Storage<R, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RA, TA, DA, RB, TB, DB, B> TensorPowAPI<&TensorBase<Storage<RB, TB, B>, DB>> for &TensorBase<Storage<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 as DimMaxAPI<DB>>::Max: DimAPI, B: DevicePowAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DevicePowAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DevicePowAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorPowAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RB, TA, DB, TB, B> TensorPowAPI<&TensorBase<Storage<RB, TB, B>, DB>> for TA

where RB: DataAPI<Data = <B as DeviceRawAPI<TB>>::Raw>, DB: DimAPI, B: DevicePowAPI<TA, TB, DB> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DevicePowAPI<TA, TB, DB>>::TOut> + DeviceCreationAnyAPI<<B as DevicePowAPI<TA, TB, DB>>::TOut>, TA: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DevicePowAPI<TA, TB, DB>>::TOut>>::Raw>, <B as DevicePowAPI<TA, TB, DB>>::TOut, B>, DB>

fn pow_f( self, b: &TensorBase<Storage<RB, TB, B>, DB>, ) -> Result<<TA as TensorPowAPI<&TensorBase<Storage<RB, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<RA, TA, DA, TB, B> TensorPowAPI<TB> for &TensorBase<Storage<RA, TA, B>, DA>

where RA: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI, B: DevicePowAPI<TA, TB, DA> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DevicePowAPI<TA, TB, DA>>::TOut> + DeviceCreationAnyAPI<<B as DevicePowAPI<TA, TB, DA>>::TOut>, TB: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DevicePowAPI<TA, TB, DA>>::TOut>>::Raw>, <B as DevicePowAPI<TA, TB, DA>>::TOut, B>, DA>

fn pow_f( self, b: TB, ) -> Result<<&TensorBase<Storage<RA, TA, B>, DA> as TensorPowAPI<TB>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, B> TensorPowAPI<TB> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI, B: DevicePowAPI<TA, TB, DA> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DevicePowAPI<TA, TB, DA>>::TOut> + DeviceCreationAnyAPI<<B as DevicePowAPI<TA, TB, DA>>::TOut>, TB: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DevicePowAPI<TA, TB, DA>>::TOut>>::Raw>, <B as DevicePowAPI<TA, TB, DA>>::TOut, B>, DA>

fn pow_f( self, b: TB, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorPowAPI<TB>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B, R> TensorPowAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for &TensorBase<Storage<R, TA, B>, DA>

where R: DataAPI<Data = <B as DeviceRawAPI<TA>>::Raw>, DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DevicePowAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DevicePowAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DevicePowAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<&TensorBase<Storage<R, TA, B>, DA> as TensorPowAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DB, TB, B> TensorPowAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TA

where DB: DimAPI, B: DevicePowAPI<TA, TB, DB> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DevicePowAPI<TA, TB, DB>>::TOut> + DeviceCreationAnyAPI<<B as DevicePowAPI<TA, TB, DB>>::TOut>, TA: Num,

type Output = TensorBase<Storage<DataOwned<<B as DeviceRawAPI<<B as DevicePowAPI<TA, TB, DB>>::TOut>>::Raw>, <B as DevicePowAPI<TA, TB, DB>>::TOut, B>, DB>

fn pow_f( self, b: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TA as TensorPowAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<TA, DA, TB, DB, B> TensorPowAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA>

where DA: DimAPI + DimMaxAPI<DB>, DB: DimAPI, <DA as DimMaxAPI<DB>>::Max: DimAPI, B: DevicePowAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max> + DeviceAPI<TA> + DeviceAPI<TB> + DeviceAPI<<B as DevicePowAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::TOut> + DeviceCreationAnyAPI<<B as DevicePowAPI<TA, TB, <DA as DimMaxAPI<DB>>::Max>>::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: TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TA>>::Raw>, TA, B>, DA> as TensorPowAPI<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<TB>>::Raw>, TB, B>, DB>>>::Output, Error>

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

where Self: Sized,

impl<R, T, B, D> TensorRealAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceRealAPI<T, D>>::TOut> + DeviceRealAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceRealAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorRealAPI>::Output, Error>

fn real(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorRealAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceRealAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn real_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorRealAPI>::Output, Error>

fn real(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorRealAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceRealAPI<T, D>>::TOut> + DeviceRealAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceRealAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorRealAPI>::Output, Error>

fn real(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorReciprocalAPI for &TensorBase<Storage<R, T, B>, D>

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

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

fn reciprocal_f( self, ) -> Result<<&TensorBase<Storage<R, T, B>, D> as TensorReciprocalAPI>::Output, Error>

fn reciprocal(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorReciprocalAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceReciprocalAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn reciprocal_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorReciprocalAPI>::Output, Error>

fn reciprocal(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorReciprocalAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceReciprocalAPI<T, D>>::TOut> + DeviceReciprocalAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceReciprocalAPI<T, D>>::TOut>,

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

fn reciprocal_f( self, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorReciprocalAPI>::Output, Error>

fn reciprocal(self) -> Self::Output

where Self: Sized,

impl<T, DA, DB, DC, B> TensorRemAPI<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>> for TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA>

where DA: DimAPI + DimMaxAPI<DB, Max = DC> + DimIntoAPI<DC>, DB: DimAPI + DimMaxAPI<DA, Max = DC> + DimIntoAPI<DC>, DC: DimAPI + DimIntoAPI<DA> + DimIntoAPI<DB>, B: DeviceAPI<T> + DeviceCreationAnyAPI<T> + DeviceRemAPI<T, T, T, DC> + DeviceLConsumeRemAPI<T, T, DA> + DeviceRConsumeRemAPI<T, T, DB> + OpAssignAPI<T, DA> + OpAssignAPI<T, DB>, T: Rem<Output = T> + Clone, <B as DeviceRawAPI<T>>::Raw: Clone,

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

fn rem_f( a: TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA>, b: TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>, ) -> Result<<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA> as TensorRemAPI<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>>>::Output, Error>

fn rem(a: Self, b: TrB) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorRoundAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceRoundAPI<T, D>>::TOut> + DeviceRoundAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceRoundAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorRoundAPI>::Output, Error>

fn round(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorRoundAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceRoundAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn round_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorRoundAPI>::Output, Error>

fn round(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorRoundAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceRoundAPI<T, D>>::TOut> + DeviceRoundAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceRoundAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorRoundAPI>::Output, Error>

fn round(self) -> Self::Output

where Self: Sized,

impl<T, DA, DB, DC, B> TensorShlAPI<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>> for TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA>

where DA: DimAPI + DimMaxAPI<DB, Max = DC> + DimIntoAPI<DC>, DB: DimAPI + DimMaxAPI<DA, Max = DC> + DimIntoAPI<DC>, DC: DimAPI + DimIntoAPI<DA> + DimIntoAPI<DB>, B: DeviceAPI<T> + DeviceCreationAnyAPI<T> + DeviceShlAPI<T, T, T, DC> + DeviceLConsumeShlAPI<T, T, DA> + DeviceRConsumeShlAPI<T, T, DB> + OpAssignAPI<T, DA> + OpAssignAPI<T, DB>, T: Shl<Output = T> + Clone, <B as DeviceRawAPI<T>>::Raw: Clone,

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

fn shl_f( a: TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA>, b: TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>, ) -> Result<<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA> as TensorShlAPI<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>>>::Output, Error>

fn shl(a: Self, b: TrB) -> Self::Output

where Self: Sized,

impl<T, DA, DB, DC, B> TensorShrAPI<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>> for TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA>

where DA: DimAPI + DimMaxAPI<DB, Max = DC> + DimIntoAPI<DC>, DB: DimAPI + DimMaxAPI<DA, Max = DC> + DimIntoAPI<DC>, DC: DimAPI + DimIntoAPI<DA> + DimIntoAPI<DB>, B: DeviceAPI<T> + DeviceCreationAnyAPI<T> + DeviceShrAPI<T, T, T, DC> + DeviceLConsumeShrAPI<T, T, DA> + DeviceRConsumeShrAPI<T, T, DB> + OpAssignAPI<T, DA> + OpAssignAPI<T, DB>, T: Shr<Output = T> + Clone, <B as DeviceRawAPI<T>>::Raw: Clone,

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

fn shr_f( a: TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA>, b: TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>, ) -> Result<<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA> as TensorShrAPI<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>>>::Output, Error>

fn shr(a: Self, b: TrB) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorSignAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceSignAPI<T, D>>::TOut> + DeviceSignAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceSignAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorSignAPI>::Output, Error>

fn sign(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorSignAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceSignAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn sign_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorSignAPI>::Output, Error>

fn sign(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorSignAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceSignAPI<T, D>>::TOut> + DeviceSignAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceSignAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorSignAPI>::Output, Error>

fn sign(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorSignBitAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceSignBitAPI<T, D>>::TOut> + DeviceSignBitAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceSignBitAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorSignBitAPI>::Output, Error>

fn signbit(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorSignBitAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceSignBitAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn signbit_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorSignBitAPI>::Output, Error>

fn signbit(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorSignBitAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceSignBitAPI<T, D>>::TOut> + DeviceSignBitAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceSignBitAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorSignBitAPI>::Output, Error>

fn signbit(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorSinAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceSinAPI<T, D>>::TOut> + DeviceSinAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceSinAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorSinAPI>::Output, Error>

fn sin(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorSinAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceSinAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn sin_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorSinAPI>::Output, Error>

fn sin(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorSinAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceSinAPI<T, D>>::TOut> + DeviceSinAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceSinAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorSinAPI>::Output, Error>

fn sin(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorSinhAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceSinhAPI<T, D>>::TOut> + DeviceSinhAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceSinhAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorSinhAPI>::Output, Error>

fn sinh(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorSinhAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceSinhAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn sinh_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorSinhAPI>::Output, Error>

fn sinh(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorSinhAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceSinhAPI<T, D>>::TOut> + DeviceSinhAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceSinhAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorSinhAPI>::Output, Error>

fn sinh(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorSqrtAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceSqrtAPI<T, D>>::TOut> + DeviceSqrtAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceSqrtAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorSqrtAPI>::Output, Error>

fn sqrt(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorSqrtAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceSqrtAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn sqrt_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorSqrtAPI>::Output, Error>

fn sqrt(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorSqrtAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceSqrtAPI<T, D>>::TOut> + DeviceSqrtAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceSqrtAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorSqrtAPI>::Output, Error>

fn sqrt(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorSquareAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceSquareAPI<T, D>>::TOut> + DeviceSquareAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceSquareAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorSquareAPI>::Output, Error>

fn square(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorSquareAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceSquareAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn square_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorSquareAPI>::Output, Error>

fn square(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorSquareAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceSquareAPI<T, D>>::TOut> + DeviceSquareAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceSquareAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorSquareAPI>::Output, Error>

fn square(self) -> Self::Output

where Self: Sized,

impl<T, DA, DB, DC, B> TensorSubAPI<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>> for TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA>

where DA: DimAPI + DimMaxAPI<DB, Max = DC> + DimIntoAPI<DC>, DB: DimAPI + DimMaxAPI<DA, Max = DC> + DimIntoAPI<DC>, DC: DimAPI + DimIntoAPI<DA> + DimIntoAPI<DB>, B: DeviceAPI<T> + DeviceCreationAnyAPI<T> + DeviceSubAPI<T, T, T, DC> + DeviceLConsumeSubAPI<T, T, DA> + DeviceRConsumeSubAPI<T, T, DB> + OpAssignAPI<T, DA> + OpAssignAPI<T, DB>, T: Sub<Output = T> + Clone, <B as DeviceRawAPI<T>>::Raw: Clone,

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

fn sub_f( a: TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA>, b: TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>, ) -> Result<<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DA> as TensorSubAPI<TensorBase<Storage<DataCow<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, DB>>>::Output, Error>

fn sub(a: Self, b: TrB) -> Self::Output

where Self: Sized,

impl<R, B, D> TensorSumBoolAPI<B, D> for TensorBase<Storage<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, Error>

fn sum_axes_f( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> Result<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<usize>>::Raw>, usize, B>, Vec<usize>>, Error>

fn sum_all(&self) -> usize

fn sum_f(&self) -> Result<usize, Error>

fn sum(&self) -> usize

fn sum_axes( &self, axes: impl TryInto<AxesIndex<isize>, Error = Error>, ) -> TensorBase<Storage<DataOwned<<B as DeviceRawAPI<usize>>::Raw>, usize, B>, Vec<usize>>

impl<R, T, B, D> TensorTanAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceTanAPI<T, D>>::TOut> + DeviceTanAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceTanAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorTanAPI>::Output, Error>

fn tan(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorTanAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceTanAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn tan_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorTanAPI>::Output, Error>

fn tan(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorTanAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceTanAPI<T, D>>::TOut> + DeviceTanAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceTanAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorTanAPI>::Output, Error>

fn tan(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorTanhAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceTanhAPI<T, D>>::TOut> + DeviceTanhAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceTanhAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorTanhAPI>::Output, Error>

fn tanh(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorTanhAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceTanhAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn tanh_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorTanhAPI>::Output, Error>

fn tanh(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorTanhAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceTanhAPI<T, D>>::TOut> + DeviceTanhAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceTanhAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorTanhAPI>::Output, Error>

fn tanh(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorTruncAPI for &TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T> + DeviceAPI<<B as DeviceTruncAPI<T, D>>::TOut> + DeviceTruncAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceTruncAPI<T, D>>::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<<&TensorBase<Storage<R, T, B>, D> as TensorTruncAPI>::Output, Error>

fn trunc(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorTruncAPI for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceTruncAPI<T, D, TOut = T> + DeviceCreationAnyAPI<T>,

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

fn trunc_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorTruncAPI>::Output, Error>

fn trunc(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorTruncAPI for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAPI<<B as DeviceTruncAPI<T, D>>::TOut> + DeviceTruncAPI<T, D> + DeviceCreationAnyAPI<<B as DeviceTruncAPI<T, D>>::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<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TensorTruncAPI>::Output, Error>

fn trunc(self) -> Self::Output

where Self: Sized,

impl<R, T, B, D> TensorViewAPI for &TensorBase<Storage<R, T, B>, D>

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

type Type = T

type Backend = B

type Dim = D

fn view( &self, ) -> TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

Get a view of tensor.

impl<R, T, B, D> TensorViewAPI for &mut TensorBase<Storage<R, T, B>, D>

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

type Type = T

type Backend = B

type Dim = D

fn view( &self, ) -> TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

Get a view of tensor.

impl<R, T, B, D> TensorViewAPI for TensorBase<Storage<R, T, B>, D>

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

type Type = T

type Backend = B

type Dim = D

fn view( &self, ) -> TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

Get a view of tensor.

impl<R, T, B, D> TensorViewMutAPI for &mut TensorBase<Storage<R, T, B>, D>

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

type Type = T

type Backend = B

type Dim = D

fn view_mut( &mut self, ) -> TensorBase<Storage<DataMut<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

Get a mutable view of tensor.

impl<R, T, B, D> TensorViewMutAPI for TensorBase<Storage<R, T, B>, D>

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

type Type = T

type Backend = B

type Dim = D

fn view_mut( &mut self, ) -> TensorBase<Storage<DataMut<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

Get a mutable view of tensor.

impl<R, T, D, B> TrilAPI<()> for &TensorBase<Storage<R, T, B>, D>

where R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, T: Num + Clone, D: DimAPI, B: DeviceAPI<T> + DeviceRawAPI<MaybeUninit<T>> + DeviceCreationTriAPI<T> + DeviceCreationAnyAPI<T> + OpAssignArbitaryAPI<T, D, D> + OpAssignAPI<T, D>, <B as DeviceRawAPI<T>>::Raw: Clone,

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

fn tril_f( self, ) -> Result<<&TensorBase<Storage<R, T, B>, D> as TrilAPI<()>>::Out, Error>

fn tril(self) -> Self::Out

where Self: Sized,

impl<'a, T, D, B> TrilAPI<()> for TensorBase<Storage<DataMut<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where T: Num + Clone, D: DimAPI, B: DeviceAPI<T> + DeviceCreationTriAPI<T> + DeviceCreationAnyAPI<T> + OpAssignArbitaryAPI<T, D, D> + OpAssignAPI<T, D>,

type Out = TensorBase<Storage<DataMut<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

fn tril_f( self, ) -> Result<<TensorBase<Storage<DataMut<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TrilAPI<()>>::Out, Error>

fn tril(self) -> Self::Out

where Self: Sized,

impl<T, D, B> TrilAPI<()> for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where T: Num + Clone, D: DimAPI, B: DeviceAPI<T> + DeviceCreationTriAPI<T> + DeviceCreationAnyAPI<T>,

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

fn tril_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TrilAPI<()>>::Out, Error>

fn tril(self) -> Self::Out

where Self: Sized,

impl<T, D, B> TrilAPI<()> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where T: Num + Clone, D: DimAPI, B: DeviceAPI<T> + DeviceRawAPI<MaybeUninit<T>> + DeviceCreationTriAPI<T> + DeviceCreationAnyAPI<T> + OpAssignArbitaryAPI<T, D, D> + OpAssignAPI<T, D>, <B as DeviceRawAPI<T>>::Raw: Clone,

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

fn tril_f( self, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TrilAPI<()>>::Out, Error>

fn tril(self) -> Self::Out

where Self: Sized,

impl<R, T, D, B> TriuAPI<()> for &TensorBase<Storage<R, T, B>, D>

where R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, T: Num + Clone, D: DimAPI, B: DeviceAPI<T> + DeviceRawAPI<MaybeUninit<T>> + DeviceCreationTriAPI<T> + DeviceCreationAnyAPI<T> + OpAssignArbitaryAPI<T, D, D> + OpAssignAPI<T, D>, <B as DeviceRawAPI<T>>::Raw: Clone,

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

fn triu_f( self, ) -> Result<<&TensorBase<Storage<R, T, B>, D> as TriuAPI<()>>::Out, Error>

fn triu(self) -> Self::Out

where Self: Sized,

impl<'a, T, D, B> TriuAPI<()> for TensorBase<Storage<DataMut<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where T: Num + Clone, D: DimAPI, B: DeviceAPI<T> + DeviceCreationTriAPI<T> + DeviceCreationAnyAPI<T> + OpAssignArbitaryAPI<T, D, D> + OpAssignAPI<T, D>,

type Out = TensorBase<Storage<DataMut<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

fn triu_f( self, ) -> Result<<TensorBase<Storage<DataMut<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TriuAPI<()>>::Out, Error>

fn triu(self) -> Self::Out

where Self: Sized,

impl<T, D, B> TriuAPI<()> for TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where T: Num + Clone, D: DimAPI, B: DeviceAPI<T> + DeviceCreationTriAPI<T> + DeviceCreationAnyAPI<T>,

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

fn triu_f( self, ) -> Result<<TensorBase<Storage<DataOwned<<B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TriuAPI<()>>::Out, Error>

fn triu(self) -> Self::Out

where Self: Sized,

impl<T, D, B> TriuAPI<()> for TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where T: Num + Clone, D: DimAPI, B: DeviceAPI<T> + DeviceRawAPI<MaybeUninit<T>> + DeviceCreationTriAPI<T> + DeviceCreationAnyAPI<T> + OpAssignArbitaryAPI<T, D, D> + OpAssignAPI<T, D>, <B as DeviceRawAPI<T>>::Raw: Clone,

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

fn triu_f( self, ) -> Result<<TensorBase<Storage<DataRef<'_, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as TriuAPI<()>>::Out, Error>

fn triu(self) -> Self::Out

where Self: Sized,

impl<'a, R, T, B, D> UnstackAPI<()> for &'a TensorBase<Storage<R, T, B>, D>

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

type Out = Vec<TensorBase<Storage<DataRef<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, <D as DimSmallerOneAPI>::SmallerOne>>

fn unstack_f( self, ) -> Result<<&'a TensorBase<Storage<R, T, B>, D> as UnstackAPI<()>>::Out, Error>

fn unstack(self) -> Self::Out

where Self: Sized,

impl<'a, T, B, D> UnstackAPI<()> for TensorBase<Storage<DataRef<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where T: Clone + Default, D: DimAPI + DimSmallerOneAPI, <D as DimSmallerOneAPI>::SmallerOne: DimAPI, B: DeviceAPI<T>,

type Out = Vec<TensorBase<Storage<DataRef<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, <D as DimSmallerOneAPI>::SmallerOne>>

fn unstack_f( self, ) -> Result<<TensorBase<Storage<DataRef<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D> as UnstackAPI<()>>::Out, Error>

fn unstack(self) -> Self::Out

where Self: Sized,

impl<R, T, B, D> ZerosLikeAPI<()> for &TensorBase<Storage<R, T, B>, D>

where R: DataAPI<Data = <B as DeviceRawAPI<T>>::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<<&TensorBase<Storage<R, T, B>, D> as ZerosLikeAPI<()>>::Out, Error>

fn zeros_like(self) -> Self::Out

where Self: Sized,

impl<R, D> Send for TensorBase<R, D>

where D: DimAPI, R: Send,

impl<R, D> Sync for TensorBase<R, D>

where D: DimAPI, R: Sync,

impl<R, D> TensorBaseAPI for TensorBase<R, D>

where D: DimAPI,

impl<'l, R, T, B, D> TensorRefAPI<'l> for &'l TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T>, &'l TensorBase<Storage<R, T, B>, D>: TensorViewAPI,

impl<'l, T, B, D> TensorRefAPI<'l> for TensorBase<Storage<DataRef<'l, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T>, TensorBase<Storage<DataRef<'l, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>: TensorViewAPI,

impl<'l, R, T, B, D> TensorRefMutAPI<'l> for &mut TensorBase<Storage<R, T, B>, D>

where D: DimAPI, R: DataMutAPI<Data = <B as DeviceRawAPI<T>>::Raw>, B: DeviceAPI<T>, &mut TensorBase<Storage<R, T, B>, D>: TensorViewMutAPI,

impl<'l, T, B, D> TensorRefMutAPI<'l> for TensorBase<Storage<DataMut<'l, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>

where D: DimAPI, B: DeviceAPI<T>, TensorBase<Storage<DataMut<'l, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>: TensorViewMutAPI,