Type Alias TensorView

pub type TensorView<'a, T, B = DeviceCpu, D = IxD> = TensorBase<Storage<DataRef<'a, <B as DeviceRawAPI<T>>::Raw>, T, B>, D>;

Aliased Type

struct TensorView<'a, T, B = DeviceCpu, D = IxD> { /* private fields */ }

Implementations

impl<T, B, D> TensorView<'_, 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.

Trait Implementations

impl<TA, DA, B, TrB> Add<TrB> for TensorView<'_, TA, B, DA>

where DA: DimAPI, B: DeviceAPI<TA>, Self: 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) -> Self::Output

Performs the + operation.

impl<TA, DA, B, TrB> BitAnd<TrB> for TensorView<'_, TA, B, DA>

where DA: DimAPI, B: DeviceAPI<TA>, Self: 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) -> Self::Output

Performs the & operation.

impl<TA, DA, B, TrB> BitOr<TrB> for TensorView<'_, TA, B, DA>

where DA: DimAPI, B: DeviceAPI<TA>, Self: 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) -> Self::Output

Performs the | operation.

impl<TA, DA, B, TrB> BitXor<TrB> for TensorView<'_, TA, B, DA>

where DA: DimAPI, B: DeviceAPI<TA>, Self: 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) -> Self::Output

Performs the ^ operation.

impl<TA, DA, B, TrB> Div<TrB> for TensorView<'_, TA, B, DA>

where DA: DimAPI, B: DeviceAPI<TA>, Self: 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) -> Self::Output

Performs the / operation.

impl<'a, T> From<&'a [T]> for TensorView<'a, T, DeviceCpu, IxD>

where T: Clone,

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

Converts to this type from the input type.

impl<'a, T> From<&'a Vec<T>> for TensorView<'a, T, DeviceCpu, IxD>

where T: Clone,

fn from(input: &'a Vec<T>) -> Self

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 TensorView<'a, T, B, D>

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

fn from(tensor: TensorReference<'a, T, B, D>) -> Self

Converts to this type from the input type.

impl<T, D, B, I> Index<I> for TensorView<'_, 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) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, T, B> IntoFaer for TensorView<'a, T, B, Ix2>

where B: DeviceAPI<T, Raw = Vec<T>>,

type Faer = Mat<Ref<'a, T>>

fn into_faer(self) -> Self::Faer

impl<TA, DA, B, TrB> Mul<TrB> for TensorView<'_, TA, B, DA>

where DA: DimAPI, B: DeviceAPI<TA>, Self: 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) -> Self::Output

Performs the * operation.

impl<TA, DA, B, TrB> Shl<TrB> for TensorView<'_, TA, B, DA>

where DA: DimAPI, B: DeviceAPI<TA>, Self: 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) -> Self::Output

Performs the << operation.

impl<TA, DA, B, TrB> Shr<TrB> for TensorView<'_, TA, B, DA>

where DA: DimAPI, B: DeviceAPI<TA>, Self: 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) -> Self::Output

Performs the >> operation.

impl<TA, DA, B, TrB> Sub<TrB> for TensorView<'_, TA, B, DA>

where DA: DimAPI, B: DeviceAPI<TA>, Self: 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) -> Self::Output

Performs the - operation.

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

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

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

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

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 TensorView<'_, TA, B, DA>

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

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

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

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

where Self: Sized,

impl<T, B, D> TensorAbsAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAbsAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn abs(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorAcosAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAcosAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn acos(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorAcoshAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAcoshAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn acosh(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorAsinAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAsinAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn asin(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorAsinhAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAsinhAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn asinh(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorAtanAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAtanAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn atan(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorAtanhAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceAtanhAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn atanh(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorCeilAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceCeilAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn ceil(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorConjAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceConjAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn conj(self) -> Self::Output

where Self: Sized,

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

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

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

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

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 TensorView<'_, TA, B, DA>

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

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

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

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

where Self: Sized,

impl<T, B, D> TensorCosAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceCosAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn cos(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorCoshAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceCoshAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn cosh(self) -> Self::Output

where Self: Sized,

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

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

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

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

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 TensorView<'_, TA, B, DA>

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

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

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

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

where Self: Sized,

impl<T, B, D> TensorExpAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceExpAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn exp(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorExpm1API for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceExpm1API<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn expm1(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorFloorAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceFloorAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn floor(self) -> Self::Output

where Self: Sized,

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

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

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

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

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 TensorView<'_, TA, B, DA>

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

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

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

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

where Self: Sized,

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

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

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

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

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 TensorView<'_, TA, B, DA>

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

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

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

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

where Self: Sized,

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

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

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

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

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 TensorView<'_, TA, B, DA>

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

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

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

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

where Self: Sized,

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

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

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

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

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 TensorView<'_, TA, B, DA>

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

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

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

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

where Self: Sized,

impl<T, B, D> TensorImagAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceImagAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn imag(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorInvAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceInvAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn inv(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorIsFiniteAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceIsFiniteAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn is_finite(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorIsInfAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceIsInfAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn is_inf(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorIsNanAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceIsNanAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn is_nan(self) -> Self::Output

where Self: Sized,

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

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

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

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

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 TensorView<'_, TA, B, DA>

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

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

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

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

where Self: Sized,

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

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

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

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

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 TensorView<'_, TA, B, DA>

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

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

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

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

where Self: Sized,

impl<T, B, D> TensorLog10API for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceLog10API<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn log10(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorLog1pAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceLog1pAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn log1p(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorLog2API for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceLog2API<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn log2(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorLogAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceLogAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn log(self) -> Self::Output

where Self: Sized,

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

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

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

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

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 TensorView<'_, TA, B, DA>

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

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

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

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

where Self: Sized,

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

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

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

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

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 TensorView<'_, TA, B, DA>

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

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

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

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

where Self: Sized,

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

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

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

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

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 TensorView<'_, TA, B, DA>

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

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

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

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

where Self: Sized,

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

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

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

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

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 TensorView<'_, TA, B, DA>

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

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

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

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

where Self: Sized,

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

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

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

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

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 TensorView<'_, TA, B, DA>

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

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

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

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

where Self: Sized,

impl<T, B, D> TensorRealAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceRealAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn real(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorRoundAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceRoundAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn round(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorSignAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceSignAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn sign(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorSignBitAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceSignBitAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn signbit(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorSinAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceSinAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn sin(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorSinhAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceSinhAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn sinh(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorSqrtAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceSqrtAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn sqrt(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorSquareAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceSquareAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn square(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorTanAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceTanAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn tan(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorTanhAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceTanhAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn tanh(self) -> Self::Output

where Self: Sized,

impl<T, B, D> TensorTruncAPI for TensorView<'_, T, B, D>

where D: DimAPI, B: DeviceAPI<T> + DeviceTruncAPI<T, D> + DeviceCreationAnyAPI<B::TOut>,

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

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

fn trunc(self) -> Self::Output

where Self: Sized,

impl<T, D, B> TrilAPI<()> for TensorView<'_, T, B, D>

where T: Num + Clone, D: DimAPI, B: DeviceAPI<T> + DeviceCreationTriAPI<T> + DeviceCreationAnyAPI<T> + OpAssignArbitaryAPI<T, D, D> + OpAssignAPI<T, D>, B::Raw: Clone,

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

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

fn tril(self) -> Self::Out

where Self: Sized,

impl<T, D, B> TriuAPI<()> for TensorView<'_, T, B, D>

where T: Num + Clone, D: DimAPI, B: DeviceAPI<T> + DeviceCreationTriAPI<T> + DeviceCreationAnyAPI<T> + OpAssignArbitaryAPI<T, D, D> + OpAssignAPI<T, D>, B::Raw: Clone,

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

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

fn triu(self) -> Self::Out

where Self: Sized,

impl<T, B, D> TensorRefAPI for TensorView<'_, T, B, D>

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