Struct Tensor

pub struct Tensor<T: TensorValue, S> { /* private fields */ }

Implementations

impl<T, S> Tensor<T, S>

where T: TensorValue, T::Unmasked: Float, S: Shape,

pub fn atan2<T2, S2>( &self, x: &Tensor<T2, S2>, ) -> Tensor<T::Output<T::Unmasked>, <S as NdimMax<S2>>::Output>

where T2: TensorValue<Unmasked = T::Unmasked>, S2: Shape, T: TensorOp<T2>, S: NdimMax<S2>, T::Output<T::Unmasked>: TensorValue,

impl<T, S> Tensor<T, S>

where T: TensorValue<Unmasked = bool>, S: Shape,

pub fn all(&self) -> bool

pub fn any(&self) -> bool

impl<T, S> Tensor<T, S>

where T: TensorValue, S: Shape,

pub fn eq<C>(&self, other: C) -> C::Output

where C: TensorCompare<Self>,

Examples found in repository

examples/tensor.rs (line 9)

fn main() {
    let x = Tensor::linspace(0_f32, 10., 100).cos();
    let y = Tensor::linspace(0_f32, 10., 100).sin();

    let mask = Tensor::range(0_i32, 100, 1) % 2;
    let y = y.with_mask(mask.eq(0));
    let z = x.unsqueeze(0) * y.unsqueeze(-1);
    println!("{:?}", z);

    let s1 = tensor::tensor!["A".to_string(), "B".to_string(), "C".to_string()];
    let s2 = tensor::tensor![Some("A".to_string()), None, Some("B".to_string())];
    println!("{:?}", s1);
    println!("{:?}", s1.eq(s2));

    let df = tensor::frame!(
        x = Tensor::linspace(0_f32, 10., 100).cos().reshape((10, 10)),
        y = Tensor::linspace(0_f32, 10., 10).sin(),
    );
    println!("{}", df.pretty_print());
}

pub fn ne<C>(&self, other: C) -> C::Output

where C: TensorCompare<Self>,

pub fn lt<C>(&self, other: C) -> C::Output

where C: TensorCompare<Self>,

pub fn gt<C>(&self, other: C) -> C::Output

where C: TensorCompare<Self>,

pub fn lte<C>(&self, other: C) -> C::Output

where C: TensorCompare<Self>,

pub fn gte<C>(&self, other: C) -> C::Output

where C: TensorCompare<Self>,

impl<T, S> Tensor<T, S>

where T: TensorValue, S: Shape,

pub fn concat(axis: Axis, tensors: &[Tensor<T, S>]) -> Result<Self>

where S: RemoveAxis,

pub fn stack( axis: Axis, tensors: &[Tensor<T, S>], ) -> Result<Tensor<T, S::Larger>>

pub fn unstack<A: Into<Axis>>(self, axis: A) -> Vec<Tensor<T, S::Smaller>>

where S: RemoveAxis,

impl<T, S> Tensor<T, S>

where T: TensorValue, S: Shape,

pub fn full<I, V>(shape: I, value: V) -> Self

where I: IntoShape<Shape = S>, V: Into<T>,

pub fn zeros<I>(shape: I) -> Self

where I: IntoShape<Shape = S>, T: Zero,

pub fn ones<I>(shape: I) -> Self

where I: IntoShape<Shape = S>, T: One,

impl<T> Tensor<T, Const<1>>

where T: TensorValue,

1-D constructors

pub fn linspace(start: T, end: T, steps: usize) -> Self

where T: Float,

Examples found in repository

examples/tensor.rs (line 5)

fn main() {
    let x = Tensor::linspace(0_f32, 10., 100).cos();
    let y = Tensor::linspace(0_f32, 10., 100).sin();

    let mask = Tensor::range(0_i32, 100, 1) % 2;
    let y = y.with_mask(mask.eq(0));
    let z = x.unsqueeze(0) * y.unsqueeze(-1);
    println!("{:?}", z);

    let s1 = tensor::tensor!["A".to_string(), "B".to_string(), "C".to_string()];
    let s2 = tensor::tensor![Some("A".to_string()), None, Some("B".to_string())];
    println!("{:?}", s1);
    println!("{:?}", s1.eq(s2));

    let df = tensor::frame!(
        x = Tensor::linspace(0_f32, 10., 100).cos().reshape((10, 10)),
        y = Tensor::linspace(0_f32, 10., 10).sin(),
    );
    println!("{}", df.pretty_print());
}

pub fn range(start: T, end: T, step: T) -> Self

where T: Num,

Examples found in repository

examples/tensor.rs (line 8)

fn main() {
    let x = Tensor::linspace(0_f32, 10., 100).cos();
    let y = Tensor::linspace(0_f32, 10., 100).sin();

    let mask = Tensor::range(0_i32, 100, 1) % 2;
    let y = y.with_mask(mask.eq(0));
    let z = x.unsqueeze(0) * y.unsqueeze(-1);
    println!("{:?}", z);

    let s1 = tensor::tensor!["A".to_string(), "B".to_string(), "C".to_string()];
    let s2 = tensor::tensor![Some("A".to_string()), None, Some("B".to_string())];
    println!("{:?}", s1);
    println!("{:?}", s1.eq(s2));

    let df = tensor::frame!(
        x = Tensor::linspace(0_f32, 10., 100).cos().reshape((10, 10)),
        y = Tensor::linspace(0_f32, 10., 10).sin(),
    );
    println!("{}", df.pretty_print());
}

impl<T> Tensor<T, Const<2>>

where T: TensorValue,

2-D constructors

pub fn eye(size: usize) -> Self

where T: One + Zero,

impl<T: TensorValue> Tensor<T, Const<0>>

pub fn scalar(&self) -> T

impl<T, S> Tensor<T, S>

where T: TensorValue, S: Shape,

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

where I: Indexer<S>,

impl<T, S> Tensor<T, S>

where T: TensorValue, S: Shape + RemoveAxis,

pub fn index_axis<I: IndexValue>( &self, axis: Axis, index: I, ) -> Tensor<T, S::Smaller>

impl<T, S> Tensor<T, S>

where T: MaskedValue, S: Shape,

pub fn mask(&self) -> Mask<S>

pub fn fill_masked(&self, value: T::Unmasked) -> Tensor<T::Unmasked, S>

pub fn drop_mask(&self) -> Tensor<T::Unmasked, S>

pub fn compress(&self) -> Tensor<T::Unmasked, Const<1>>

impl<T, S> Tensor<T, S>

where T: TensorValue, S: Shape,

pub fn with_mask<M>(&self, mask: M) -> Tensor<T::Masked, S>

where M: AsMask<S>,

Examples found in repository

examples/tensor.rs (line 9)

fn main() {
    let x = Tensor::linspace(0_f32, 10., 100).cos();
    let y = Tensor::linspace(0_f32, 10., 100).sin();

    let mask = Tensor::range(0_i32, 100, 1) % 2;
    let y = y.with_mask(mask.eq(0));
    let z = x.unsqueeze(0) * y.unsqueeze(-1);
    println!("{:?}", z);

    let s1 = tensor::tensor!["A".to_string(), "B".to_string(), "C".to_string()];
    let s2 = tensor::tensor![Some("A".to_string()), None, Some("B".to_string())];
    println!("{:?}", s1);
    println!("{:?}", s1.eq(s2));

    let df = tensor::frame!(
        x = Tensor::linspace(0_f32, 10., 100).cos().reshape((10, 10)),
        y = Tensor::linspace(0_f32, 10., 10).sin(),
    );
    println!("{}", df.pretty_print());
}

pub fn nullable(&self) -> Tensor<T::Masked, S>

impl<T, S> Tensor<T, S>

where T: TensorValue, S: Shape,

pub fn as_dyn(&self) -> Tensor<T, Dyn>

pub fn reshape<I>(&self, shape: I) -> Tensor<T, I::Shape>

where I: IntoShape,

Examples found in repository

examples/tensor.rs (line 19)

fn main() {
    let x = Tensor::linspace(0_f32, 10., 100).cos();
    let y = Tensor::linspace(0_f32, 10., 100).sin();

    let mask = Tensor::range(0_i32, 100, 1) % 2;
    let y = y.with_mask(mask.eq(0));
    let z = x.unsqueeze(0) * y.unsqueeze(-1);
    println!("{:?}", z);

    let s1 = tensor::tensor!["A".to_string(), "B".to_string(), "C".to_string()];
    let s2 = tensor::tensor![Some("A".to_string()), None, Some("B".to_string())];
    println!("{:?}", s1);
    println!("{:?}", s1.eq(s2));

    let df = tensor::frame!(
        x = Tensor::linspace(0_f32, 10., 100).cos().reshape((10, 10)),
        y = Tensor::linspace(0_f32, 10., 10).sin(),
    );
    println!("{}", df.pretty_print());
}

pub fn flatten(&self) -> Tensor<T, Const<1>>

pub fn unsqueeze<A>(&self, axis: A) -> Tensor<T, S::Larger>

where A: Into<Axis>,

Examples found in repository

examples/tensor.rs (line 10)

fn main() {
    let x = Tensor::linspace(0_f32, 10., 100).cos();
    let y = Tensor::linspace(0_f32, 10., 100).sin();

    let mask = Tensor::range(0_i32, 100, 1) % 2;
    let y = y.with_mask(mask.eq(0));
    let z = x.unsqueeze(0) * y.unsqueeze(-1);
    println!("{:?}", z);

    let s1 = tensor::tensor!["A".to_string(), "B".to_string(), "C".to_string()];
    let s2 = tensor::tensor![Some("A".to_string()), None, Some("B".to_string())];
    println!("{:?}", s1);
    println!("{:?}", s1.eq(s2));

    let df = tensor::frame!(
        x = Tensor::linspace(0_f32, 10., 100).cos().reshape((10, 10)),
        y = Tensor::linspace(0_f32, 10., 10).sin(),
    );
    println!("{}", df.pretty_print());
}

pub fn swap_axes<A1, A2>(&self, ax1: A1, ax2: A2) -> Self

where A1: Into<Axis>, A2: Into<Axis>,

pub fn as_shape<S2>(&self) -> Result<Tensor<T, S2>>

where S2: Shape,

pub fn broadcast_to<I, O>(&self, shape: I) -> Result<Tensor<T, O>>

where O: Shape, I: IntoShape<Shape = O>,

pub fn broadcast_with<T2, S2>( &self, other: &Tensor<T2, S2>, ) -> Result<(Tensor<T, <S as NdimMax<S2>>::Output>, Tensor<T2, <S as NdimMax<S2>>::Output>)>

where T2: TensorValue, S2: Shape, S: NdimMax<S2>,

pub fn invert_axis<A: Into<Axis>>(&self, axis: A) -> Self

pub fn roll(&self, axis: Axis, roll: isize) -> Self

where S: RemoveAxis,

impl<T, S> Tensor<T, S>

where T: TensorValue, S: Shape + RemoveAxis,

1-D shape operations

pub fn squeeze(&self, axis: Axis) -> Tensor<T, S::Smaller>

impl<T> Tensor<T, Const<2>>

where T: TensorValue,

2-D shape operations

pub fn t(&self) -> Self

impl<T, S> Tensor<T, S>

where T: TensorValue, S: Shape,

pub fn slice_axis<I>(&self, axis: Axis, slice: I) -> Self

where I: Into<Slice>,

pub fn collapse_axis<I: IndexValue>(&self, axis: Axis, index: I) -> Self

pub fn slice<I: SliceShape<S>>(&self, slice: I) -> Tensor<T, I::Out>

pub fn diag(&self) -> Tensor<T, Const<1>>

impl<T, S> Tensor<T, S>

where T: TensorUnaryOp<Output<<T as TensorValue>::Unmasked> = T>, S: Shape, T::Unmasked: Float,

pub fn sin(&self) -> Tensor<T::Output<T::Unmasked>, S>

Examples found in repository

examples/tensor.rs (line 6)

fn main() {
    let x = Tensor::linspace(0_f32, 10., 100).cos();
    let y = Tensor::linspace(0_f32, 10., 100).sin();

    let mask = Tensor::range(0_i32, 100, 1) % 2;
    let y = y.with_mask(mask.eq(0));
    let z = x.unsqueeze(0) * y.unsqueeze(-1);
    println!("{:?}", z);

    let s1 = tensor::tensor!["A".to_string(), "B".to_string(), "C".to_string()];
    let s2 = tensor::tensor![Some("A".to_string()), None, Some("B".to_string())];
    println!("{:?}", s1);
    println!("{:?}", s1.eq(s2));

    let df = tensor::frame!(
        x = Tensor::linspace(0_f32, 10., 100).cos().reshape((10, 10)),
        y = Tensor::linspace(0_f32, 10., 10).sin(),
    );
    println!("{}", df.pretty_print());
}

pub fn cos(&self) -> Tensor<T::Output<T::Unmasked>, S>

Examples found in repository

examples/tensor.rs (line 5)

fn main() {
    let x = Tensor::linspace(0_f32, 10., 100).cos();
    let y = Tensor::linspace(0_f32, 10., 100).sin();

    let mask = Tensor::range(0_i32, 100, 1) % 2;
    let y = y.with_mask(mask.eq(0));
    let z = x.unsqueeze(0) * y.unsqueeze(-1);
    println!("{:?}", z);

    let s1 = tensor::tensor!["A".to_string(), "B".to_string(), "C".to_string()];
    let s2 = tensor::tensor![Some("A".to_string()), None, Some("B".to_string())];
    println!("{:?}", s1);
    println!("{:?}", s1.eq(s2));

    let df = tensor::frame!(
        x = Tensor::linspace(0_f32, 10., 100).cos().reshape((10, 10)),
        y = Tensor::linspace(0_f32, 10., 10).sin(),
    );
    println!("{}", df.pretty_print());
}

pub fn tan(&self) -> Tensor<T::Output<T::Unmasked>, S>

pub fn acos(&self) -> Tensor<T::Output<T::Unmasked>, S>

pub fn asin(&self) -> Tensor<T::Output<T::Unmasked>, S>

pub fn atan(&self) -> Tensor<T::Output<T::Unmasked>, S>

pub fn exp(&self) -> Tensor<T::Output<T::Unmasked>, S>

pub fn exp2(&self) -> Tensor<T::Output<T::Unmasked>, S>

pub fn ln(&self) -> Tensor<T::Output<T::Unmasked>, S>

pub fn log2(&self) -> Tensor<T::Output<T::Unmasked>, S>

pub fn log10(&self) -> Tensor<T::Output<T::Unmasked>, S>

impl<T, S> Tensor<T, S>

where T: TensorUnaryOp<Output<<T as TensorValue>::Unmasked> = T>, S: Shape, T::Unmasked: Signed,

pub fn abs(&self) -> Tensor<T::Output<T::Unmasked>, S>

impl<T, S> Tensor<T, S>

where T: TensorValue, S: Shape,

pub fn iter(&self) -> TensorIter<T, S>

pub fn iter_valid(&self) -> TensorIterValid<T, S>

impl<T, S> Tensor<T, S>

where T: TensorValue, S: Shape + RemoveAxis,

pub fn axis_iter<A: Into<Axis>>(&self, axis: A) -> AxisIter<T, S>

impl<T, S> Tensor<T, S>

where T: TensorValue, S: Shape,

pub fn shape(&self) -> &S

pub fn strides(&self) -> &S

pub fn size(&self) -> usize

pub fn ndim(&self) -> usize

pub fn is_standard_layout(&self) -> bool

pub fn try_from_arrow<R>(array: ArrayRef, row_shape: R) -> Result<Self>

where R: Shape<Larger = S>,

pub fn into_arrow(self) -> ArrayRef

pub fn to_standard_layout(self) -> Self

pub fn map<F, O>(&self, f: F) -> Tensor<O, S>

where O: TensorValue, F: Fn(T) -> O,

Trait Implementations

impl<T, S> Add<&Tensor<T, S>> for f32

where f32: TensorOp<T>, T: TensorValue<Unmasked = f32>, <f32 as TensorOp<T>>::Output<f32>: TensorValue, S: Shape,

type Output = Tensor<<f32 as TensorOp<T>>::Output<f32>, S>

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the + operation.

impl<T, S> Add<&Tensor<T, S>> for f64

where f64: TensorOp<T>, T: TensorValue<Unmasked = f64>, <f64 as TensorOp<T>>::Output<f64>: TensorValue, S: Shape,

type Output = Tensor<<f64 as TensorOp<T>>::Output<f64>, S>

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the + operation.

impl<T, S> Add<&Tensor<T, S>> for i16

where i16: TensorOp<T>, T: TensorValue<Unmasked = i16>, <i16 as TensorOp<T>>::Output<i16>: TensorValue, S: Shape,

type Output = Tensor<<i16 as TensorOp<T>>::Output<i16>, S>

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the + operation.

impl<T, S> Add<&Tensor<T, S>> for i32

where i32: TensorOp<T>, T: TensorValue<Unmasked = i32>, <i32 as TensorOp<T>>::Output<i32>: TensorValue, S: Shape,

type Output = Tensor<<i32 as TensorOp<T>>::Output<i32>, S>

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the + operation.

impl<T, S> Add<&Tensor<T, S>> for i64

where i64: TensorOp<T>, T: TensorValue<Unmasked = i64>, <i64 as TensorOp<T>>::Output<i64>: TensorValue, S: Shape,

type Output = Tensor<<i64 as TensorOp<T>>::Output<i64>, S>

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the + operation.

impl<T, S> Add<&Tensor<T, S>> for i8

where i8: TensorOp<T>, T: TensorValue<Unmasked = i8>, <i8 as TensorOp<T>>::Output<i8>: TensorValue, S: Shape,

type Output = Tensor<<i8 as TensorOp<T>>::Output<i8>, S>

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the + operation.

impl<T, S> Add<&Tensor<T, S>> for u16

where u16: TensorOp<T>, T: TensorValue<Unmasked = u16>, <u16 as TensorOp<T>>::Output<u16>: TensorValue, S: Shape,

type Output = Tensor<<u16 as TensorOp<T>>::Output<u16>, S>

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the + operation.

impl<T, S> Add<&Tensor<T, S>> for u32

where u32: TensorOp<T>, T: TensorValue<Unmasked = u32>, <u32 as TensorOp<T>>::Output<u32>: TensorValue, S: Shape,

type Output = Tensor<<u32 as TensorOp<T>>::Output<u32>, S>

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the + operation.

impl<T, S> Add<&Tensor<T, S>> for u64

where u64: TensorOp<T>, T: TensorValue<Unmasked = u64>, <u64 as TensorOp<T>>::Output<u64>: TensorValue, S: Shape,

type Output = Tensor<<u64 as TensorOp<T>>::Output<u64>, S>

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the + operation.

impl<T, S> Add<&Tensor<T, S>> for u8

where u8: TensorOp<T>, T: TensorValue<Unmasked = u8>, <u8 as TensorOp<T>>::Output<u8>: TensorValue, S: Shape,

type Output = Tensor<<u8 as TensorOp<T>>::Output<u8>, S>

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the + operation.

impl<T1, T2, S1, S2> Add<&Tensor<T2, S2>> for &Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: Add<T2::Unmasked>, <T1::Unmasked as Add<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as Add<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as Add<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor<T2, S2>) -> Self::Output

Performs the + operation.

impl<T1, T2, S1, S2> Add<&Tensor<T2, S2>> for Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: Add<T2::Unmasked>, <T1::Unmasked as Add<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as Add<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as Add<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor<T2, S2>) -> Self::Output

Performs the + operation.

impl<T, S> Add<Tensor<T, S>> for f32

where f32: TensorOp<T>, T: TensorValue<Unmasked = f32>, <f32 as TensorOp<T>>::Output<f32>: TensorValue, S: Shape,

type Output = Tensor<<f32 as TensorOp<T>>::Output<f32>, S>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<T, S>) -> Self::Output

Performs the + operation.

impl<T, S> Add<Tensor<T, S>> for f64

where f64: TensorOp<T>, T: TensorValue<Unmasked = f64>, <f64 as TensorOp<T>>::Output<f64>: TensorValue, S: Shape,

type Output = Tensor<<f64 as TensorOp<T>>::Output<f64>, S>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<T, S>) -> Self::Output

Performs the + operation.

impl<T, S> Add<Tensor<T, S>> for i16

where i16: TensorOp<T>, T: TensorValue<Unmasked = i16>, <i16 as TensorOp<T>>::Output<i16>: TensorValue, S: Shape,

type Output = Tensor<<i16 as TensorOp<T>>::Output<i16>, S>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<T, S>) -> Self::Output

Performs the + operation.

impl<T, S> Add<Tensor<T, S>> for i32

where i32: TensorOp<T>, T: TensorValue<Unmasked = i32>, <i32 as TensorOp<T>>::Output<i32>: TensorValue, S: Shape,

type Output = Tensor<<i32 as TensorOp<T>>::Output<i32>, S>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<T, S>) -> Self::Output

Performs the + operation.

impl<T, S> Add<Tensor<T, S>> for i64

where i64: TensorOp<T>, T: TensorValue<Unmasked = i64>, <i64 as TensorOp<T>>::Output<i64>: TensorValue, S: Shape,

type Output = Tensor<<i64 as TensorOp<T>>::Output<i64>, S>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<T, S>) -> Self::Output

Performs the + operation.

impl<T, S> Add<Tensor<T, S>> for i8

where i8: TensorOp<T>, T: TensorValue<Unmasked = i8>, <i8 as TensorOp<T>>::Output<i8>: TensorValue, S: Shape,

type Output = Tensor<<i8 as TensorOp<T>>::Output<i8>, S>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<T, S>) -> Self::Output

Performs the + operation.

impl<T, S> Add<Tensor<T, S>> for u16

where u16: TensorOp<T>, T: TensorValue<Unmasked = u16>, <u16 as TensorOp<T>>::Output<u16>: TensorValue, S: Shape,

type Output = Tensor<<u16 as TensorOp<T>>::Output<u16>, S>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<T, S>) -> Self::Output

Performs the + operation.

impl<T, S> Add<Tensor<T, S>> for u32

where u32: TensorOp<T>, T: TensorValue<Unmasked = u32>, <u32 as TensorOp<T>>::Output<u32>: TensorValue, S: Shape,

type Output = Tensor<<u32 as TensorOp<T>>::Output<u32>, S>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<T, S>) -> Self::Output

Performs the + operation.

impl<T, S> Add<Tensor<T, S>> for u64

where u64: TensorOp<T>, T: TensorValue<Unmasked = u64>, <u64 as TensorOp<T>>::Output<u64>: TensorValue, S: Shape,

type Output = Tensor<<u64 as TensorOp<T>>::Output<u64>, S>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<T, S>) -> Self::Output

Performs the + operation.

impl<T, S> Add<Tensor<T, S>> for u8

where u8: TensorOp<T>, T: TensorValue<Unmasked = u8>, <u8 as TensorOp<T>>::Output<u8>: TensorValue, S: Shape,

type Output = Tensor<<u8 as TensorOp<T>>::Output<u8>, S>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<T, S>) -> Self::Output

Performs the + operation.

impl<T1, T2, S1, S2> Add<Tensor<T2, S2>> for &Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: Add<T2::Unmasked>, <T1::Unmasked as Add<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as Add<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as Add<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<T2, S2>) -> Self::Output

Performs the + operation.

impl<T1, T2, S1, S2> Add<Tensor<T2, S2>> for Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: Add<T2::Unmasked>, <T1::Unmasked as Add<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as Add<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as Add<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<T2, S2>) -> Self::Output

Performs the + operation.

impl<T, S> Add<f32> for &Tensor<T, S>

where T: TensorOp<f32>, T::Unmasked: Add<f32>, <T::Unmasked as Add<f32>>::Output: TensorValue, T::Output<<T::Unmasked as Add<f32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<f32>>::Output<<<T as TensorValue>::Unmasked as Add<f32>>::Output>, S>

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Self::Output

Performs the + operation.

impl<T, S> Add<f32> for Tensor<T, S>

where T: TensorOp<f32>, T::Unmasked: Add<f32>, <T::Unmasked as Add<f32>>::Output: TensorValue, T::Output<<T::Unmasked as Add<f32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<f32>>::Output<<<T as TensorValue>::Unmasked as Add<f32>>::Output>, S>

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Self::Output

Performs the + operation.

impl<T, S> Add<f64> for &Tensor<T, S>

where T: TensorOp<f64>, T::Unmasked: Add<f64>, <T::Unmasked as Add<f64>>::Output: TensorValue, T::Output<<T::Unmasked as Add<f64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<f64>>::Output<<<T as TensorValue>::Unmasked as Add<f64>>::Output>, S>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Self::Output

Performs the + operation.

impl<T, S> Add<f64> for Tensor<T, S>

where T: TensorOp<f64>, T::Unmasked: Add<f64>, <T::Unmasked as Add<f64>>::Output: TensorValue, T::Output<<T::Unmasked as Add<f64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<f64>>::Output<<<T as TensorValue>::Unmasked as Add<f64>>::Output>, S>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Self::Output

Performs the + operation.

impl<T, S> Add<i16> for &Tensor<T, S>

where T: TensorOp<i16>, T::Unmasked: Add<i16>, <T::Unmasked as Add<i16>>::Output: TensorValue, T::Output<<T::Unmasked as Add<i16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i16>>::Output<<<T as TensorValue>::Unmasked as Add<i16>>::Output>, S>

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> Self::Output

Performs the + operation.

impl<T, S> Add<i16> for Tensor<T, S>

where T: TensorOp<i16>, T::Unmasked: Add<i16>, <T::Unmasked as Add<i16>>::Output: TensorValue, T::Output<<T::Unmasked as Add<i16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i16>>::Output<<<T as TensorValue>::Unmasked as Add<i16>>::Output>, S>

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> Self::Output

Performs the + operation.

impl<T, S> Add<i32> for &Tensor<T, S>

where T: TensorOp<i32>, T::Unmasked: Add<i32>, <T::Unmasked as Add<i32>>::Output: TensorValue, T::Output<<T::Unmasked as Add<i32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i32>>::Output<<<T as TensorValue>::Unmasked as Add<i32>>::Output>, S>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Self::Output

Performs the + operation.

impl<T, S> Add<i32> for Tensor<T, S>

where T: TensorOp<i32>, T::Unmasked: Add<i32>, <T::Unmasked as Add<i32>>::Output: TensorValue, T::Output<<T::Unmasked as Add<i32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i32>>::Output<<<T as TensorValue>::Unmasked as Add<i32>>::Output>, S>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Self::Output

Performs the + operation.

impl<T, S> Add<i64> for &Tensor<T, S>

where T: TensorOp<i64>, T::Unmasked: Add<i64>, <T::Unmasked as Add<i64>>::Output: TensorValue, T::Output<<T::Unmasked as Add<i64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i64>>::Output<<<T as TensorValue>::Unmasked as Add<i64>>::Output>, S>

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> Self::Output

Performs the + operation.

impl<T, S> Add<i64> for Tensor<T, S>

where T: TensorOp<i64>, T::Unmasked: Add<i64>, <T::Unmasked as Add<i64>>::Output: TensorValue, T::Output<<T::Unmasked as Add<i64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i64>>::Output<<<T as TensorValue>::Unmasked as Add<i64>>::Output>, S>

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> Self::Output

Performs the + operation.

impl<T, S> Add<i8> for &Tensor<T, S>

where T: TensorOp<i8>, T::Unmasked: Add<i8>, <T::Unmasked as Add<i8>>::Output: TensorValue, T::Output<<T::Unmasked as Add<i8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i8>>::Output<<<T as TensorValue>::Unmasked as Add<i8>>::Output>, S>

The resulting type after applying the + operator.

fn add(self, rhs: i8) -> Self::Output

Performs the + operation.

impl<T, S> Add<i8> for Tensor<T, S>

where T: TensorOp<i8>, T::Unmasked: Add<i8>, <T::Unmasked as Add<i8>>::Output: TensorValue, T::Output<<T::Unmasked as Add<i8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i8>>::Output<<<T as TensorValue>::Unmasked as Add<i8>>::Output>, S>

The resulting type after applying the + operator.

fn add(self, rhs: i8) -> Self::Output

Performs the + operation.

impl<T, S> Add<u16> for &Tensor<T, S>

where T: TensorOp<u16>, T::Unmasked: Add<u16>, <T::Unmasked as Add<u16>>::Output: TensorValue, T::Output<<T::Unmasked as Add<u16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u16>>::Output<<<T as TensorValue>::Unmasked as Add<u16>>::Output>, S>

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> Self::Output

Performs the + operation.

impl<T, S> Add<u16> for Tensor<T, S>

where T: TensorOp<u16>, T::Unmasked: Add<u16>, <T::Unmasked as Add<u16>>::Output: TensorValue, T::Output<<T::Unmasked as Add<u16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u16>>::Output<<<T as TensorValue>::Unmasked as Add<u16>>::Output>, S>

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> Self::Output

Performs the + operation.

impl<T, S> Add<u32> for &Tensor<T, S>

where T: TensorOp<u32>, T::Unmasked: Add<u32>, <T::Unmasked as Add<u32>>::Output: TensorValue, T::Output<<T::Unmasked as Add<u32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u32>>::Output<<<T as TensorValue>::Unmasked as Add<u32>>::Output>, S>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> Self::Output

Performs the + operation.

impl<T, S> Add<u32> for Tensor<T, S>

where T: TensorOp<u32>, T::Unmasked: Add<u32>, <T::Unmasked as Add<u32>>::Output: TensorValue, T::Output<<T::Unmasked as Add<u32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u32>>::Output<<<T as TensorValue>::Unmasked as Add<u32>>::Output>, S>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> Self::Output

Performs the + operation.

impl<T, S> Add<u64> for &Tensor<T, S>

where T: TensorOp<u64>, T::Unmasked: Add<u64>, <T::Unmasked as Add<u64>>::Output: TensorValue, T::Output<<T::Unmasked as Add<u64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u64>>::Output<<<T as TensorValue>::Unmasked as Add<u64>>::Output>, S>

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> Self::Output

Performs the + operation.

impl<T, S> Add<u64> for Tensor<T, S>

where T: TensorOp<u64>, T::Unmasked: Add<u64>, <T::Unmasked as Add<u64>>::Output: TensorValue, T::Output<<T::Unmasked as Add<u64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u64>>::Output<<<T as TensorValue>::Unmasked as Add<u64>>::Output>, S>

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> Self::Output

Performs the + operation.

impl<T, S> Add<u8> for &Tensor<T, S>

where T: TensorOp<u8>, T::Unmasked: Add<u8>, <T::Unmasked as Add<u8>>::Output: TensorValue, T::Output<<T::Unmasked as Add<u8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u8>>::Output<<<T as TensorValue>::Unmasked as Add<u8>>::Output>, S>

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> Self::Output

Performs the + operation.

impl<T, S> Add<u8> for Tensor<T, S>

where T: TensorOp<u8>, T::Unmasked: Add<u8>, <T::Unmasked as Add<u8>>::Output: TensorValue, T::Output<<T::Unmasked as Add<u8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u8>>::Output<<<T as TensorValue>::Unmasked as Add<u8>>::Output>, S>

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> Self::Output

Performs the + operation.

impl<T, S> BitAnd<&Tensor<T, S>> for bool

where bool: TensorOp<T>, T: TensorValue<Unmasked = bool>, <bool as TensorOp<T>>::Output<bool>: TensorValue, S: Shape,

type Output = Tensor<<bool as TensorOp<T>>::Output<bool>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<&Tensor<T, S>> for i16

where i16: TensorOp<T>, T: TensorValue<Unmasked = i16>, <i16 as TensorOp<T>>::Output<i16>: TensorValue, S: Shape,

type Output = Tensor<<i16 as TensorOp<T>>::Output<i16>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<&Tensor<T, S>> for i32

where i32: TensorOp<T>, T: TensorValue<Unmasked = i32>, <i32 as TensorOp<T>>::Output<i32>: TensorValue, S: Shape,

type Output = Tensor<<i32 as TensorOp<T>>::Output<i32>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<&Tensor<T, S>> for i64

where i64: TensorOp<T>, T: TensorValue<Unmasked = i64>, <i64 as TensorOp<T>>::Output<i64>: TensorValue, S: Shape,

type Output = Tensor<<i64 as TensorOp<T>>::Output<i64>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<&Tensor<T, S>> for i8

where i8: TensorOp<T>, T: TensorValue<Unmasked = i8>, <i8 as TensorOp<T>>::Output<i8>: TensorValue, S: Shape,

type Output = Tensor<<i8 as TensorOp<T>>::Output<i8>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<&Tensor<T, S>> for u16

where u16: TensorOp<T>, T: TensorValue<Unmasked = u16>, <u16 as TensorOp<T>>::Output<u16>: TensorValue, S: Shape,

type Output = Tensor<<u16 as TensorOp<T>>::Output<u16>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<&Tensor<T, S>> for u32

where u32: TensorOp<T>, T: TensorValue<Unmasked = u32>, <u32 as TensorOp<T>>::Output<u32>: TensorValue, S: Shape,

type Output = Tensor<<u32 as TensorOp<T>>::Output<u32>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<&Tensor<T, S>> for u64

where u64: TensorOp<T>, T: TensorValue<Unmasked = u64>, <u64 as TensorOp<T>>::Output<u64>: TensorValue, S: Shape,

type Output = Tensor<<u64 as TensorOp<T>>::Output<u64>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<&Tensor<T, S>> for u8

where u8: TensorOp<T>, T: TensorValue<Unmasked = u8>, <u8 as TensorOp<T>>::Output<u8>: TensorValue, S: Shape,

type Output = Tensor<<u8 as TensorOp<T>>::Output<u8>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the & operation.

impl<T1, T2, S1, S2> BitAnd<&Tensor<T2, S2>> for &Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: BitAnd<T2::Unmasked>, <T1::Unmasked as BitAnd<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as BitAnd<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as BitAnd<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Tensor<T2, S2>) -> Self::Output

Performs the & operation.

impl<T1, T2, S1, S2> BitAnd<&Tensor<T2, S2>> for Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: BitAnd<T2::Unmasked>, <T1::Unmasked as BitAnd<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as BitAnd<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as BitAnd<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Tensor<T2, S2>) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<Tensor<T, S>> for bool

where bool: TensorOp<T>, T: TensorValue<Unmasked = bool>, <bool as TensorOp<T>>::Output<bool>: TensorValue, S: Shape,

type Output = Tensor<<bool as TensorOp<T>>::Output<bool>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: Tensor<T, S>) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<Tensor<T, S>> for i16

where i16: TensorOp<T>, T: TensorValue<Unmasked = i16>, <i16 as TensorOp<T>>::Output<i16>: TensorValue, S: Shape,

type Output = Tensor<<i16 as TensorOp<T>>::Output<i16>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: Tensor<T, S>) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<Tensor<T, S>> for i32

where i32: TensorOp<T>, T: TensorValue<Unmasked = i32>, <i32 as TensorOp<T>>::Output<i32>: TensorValue, S: Shape,

type Output = Tensor<<i32 as TensorOp<T>>::Output<i32>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: Tensor<T, S>) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<Tensor<T, S>> for i64

where i64: TensorOp<T>, T: TensorValue<Unmasked = i64>, <i64 as TensorOp<T>>::Output<i64>: TensorValue, S: Shape,

type Output = Tensor<<i64 as TensorOp<T>>::Output<i64>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: Tensor<T, S>) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<Tensor<T, S>> for i8

where i8: TensorOp<T>, T: TensorValue<Unmasked = i8>, <i8 as TensorOp<T>>::Output<i8>: TensorValue, S: Shape,

type Output = Tensor<<i8 as TensorOp<T>>::Output<i8>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: Tensor<T, S>) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<Tensor<T, S>> for u16

where u16: TensorOp<T>, T: TensorValue<Unmasked = u16>, <u16 as TensorOp<T>>::Output<u16>: TensorValue, S: Shape,

type Output = Tensor<<u16 as TensorOp<T>>::Output<u16>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: Tensor<T, S>) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<Tensor<T, S>> for u32

where u32: TensorOp<T>, T: TensorValue<Unmasked = u32>, <u32 as TensorOp<T>>::Output<u32>: TensorValue, S: Shape,

type Output = Tensor<<u32 as TensorOp<T>>::Output<u32>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: Tensor<T, S>) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<Tensor<T, S>> for u64

where u64: TensorOp<T>, T: TensorValue<Unmasked = u64>, <u64 as TensorOp<T>>::Output<u64>: TensorValue, S: Shape,

type Output = Tensor<<u64 as TensorOp<T>>::Output<u64>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: Tensor<T, S>) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<Tensor<T, S>> for u8

where u8: TensorOp<T>, T: TensorValue<Unmasked = u8>, <u8 as TensorOp<T>>::Output<u8>: TensorValue, S: Shape,

type Output = Tensor<<u8 as TensorOp<T>>::Output<u8>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: Tensor<T, S>) -> Self::Output

Performs the & operation.

impl<T1, T2, S1, S2> BitAnd<Tensor<T2, S2>> for &Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: BitAnd<T2::Unmasked>, <T1::Unmasked as BitAnd<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as BitAnd<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as BitAnd<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the & operator.

fn bitand(self, rhs: Tensor<T2, S2>) -> Self::Output

Performs the & operation.

impl<T1, T2, S1, S2> BitAnd<Tensor<T2, S2>> for Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: BitAnd<T2::Unmasked>, <T1::Unmasked as BitAnd<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as BitAnd<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as BitAnd<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the & operator.

fn bitand(self, rhs: Tensor<T2, S2>) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<bool> for &Tensor<T, S>

where T: TensorOp<bool>, T::Unmasked: BitAnd<bool>, <T::Unmasked as BitAnd<bool>>::Output: TensorValue, T::Output<<T::Unmasked as BitAnd<bool>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<bool>>::Output<<<T as TensorValue>::Unmasked as BitAnd<bool>>::Output>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: bool) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<bool> for Tensor<T, S>

where T: TensorOp<bool>, T::Unmasked: BitAnd<bool>, <T::Unmasked as BitAnd<bool>>::Output: TensorValue, T::Output<<T::Unmasked as BitAnd<bool>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<bool>>::Output<<<T as TensorValue>::Unmasked as BitAnd<bool>>::Output>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: bool) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<i16> for &Tensor<T, S>

where T: TensorOp<i16>, T::Unmasked: BitAnd<i16>, <T::Unmasked as BitAnd<i16>>::Output: TensorValue, T::Output<<T::Unmasked as BitAnd<i16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i16>>::Output<<<T as TensorValue>::Unmasked as BitAnd<i16>>::Output>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: i16) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<i16> for Tensor<T, S>

where T: TensorOp<i16>, T::Unmasked: BitAnd<i16>, <T::Unmasked as BitAnd<i16>>::Output: TensorValue, T::Output<<T::Unmasked as BitAnd<i16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i16>>::Output<<<T as TensorValue>::Unmasked as BitAnd<i16>>::Output>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: i16) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<i32> for &Tensor<T, S>

where T: TensorOp<i32>, T::Unmasked: BitAnd<i32>, <T::Unmasked as BitAnd<i32>>::Output: TensorValue, T::Output<<T::Unmasked as BitAnd<i32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i32>>::Output<<<T as TensorValue>::Unmasked as BitAnd<i32>>::Output>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: i32) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<i32> for Tensor<T, S>

where T: TensorOp<i32>, T::Unmasked: BitAnd<i32>, <T::Unmasked as BitAnd<i32>>::Output: TensorValue, T::Output<<T::Unmasked as BitAnd<i32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i32>>::Output<<<T as TensorValue>::Unmasked as BitAnd<i32>>::Output>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: i32) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<i64> for &Tensor<T, S>

where T: TensorOp<i64>, T::Unmasked: BitAnd<i64>, <T::Unmasked as BitAnd<i64>>::Output: TensorValue, T::Output<<T::Unmasked as BitAnd<i64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i64>>::Output<<<T as TensorValue>::Unmasked as BitAnd<i64>>::Output>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: i64) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<i64> for Tensor<T, S>

where T: TensorOp<i64>, T::Unmasked: BitAnd<i64>, <T::Unmasked as BitAnd<i64>>::Output: TensorValue, T::Output<<T::Unmasked as BitAnd<i64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i64>>::Output<<<T as TensorValue>::Unmasked as BitAnd<i64>>::Output>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: i64) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<i8> for &Tensor<T, S>

where T: TensorOp<i8>, T::Unmasked: BitAnd<i8>, <T::Unmasked as BitAnd<i8>>::Output: TensorValue, T::Output<<T::Unmasked as BitAnd<i8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i8>>::Output<<<T as TensorValue>::Unmasked as BitAnd<i8>>::Output>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: i8) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<i8> for Tensor<T, S>

where T: TensorOp<i8>, T::Unmasked: BitAnd<i8>, <T::Unmasked as BitAnd<i8>>::Output: TensorValue, T::Output<<T::Unmasked as BitAnd<i8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i8>>::Output<<<T as TensorValue>::Unmasked as BitAnd<i8>>::Output>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: i8) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<u16> for &Tensor<T, S>

where T: TensorOp<u16>, T::Unmasked: BitAnd<u16>, <T::Unmasked as BitAnd<u16>>::Output: TensorValue, T::Output<<T::Unmasked as BitAnd<u16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u16>>::Output<<<T as TensorValue>::Unmasked as BitAnd<u16>>::Output>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: u16) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<u16> for Tensor<T, S>

where T: TensorOp<u16>, T::Unmasked: BitAnd<u16>, <T::Unmasked as BitAnd<u16>>::Output: TensorValue, T::Output<<T::Unmasked as BitAnd<u16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u16>>::Output<<<T as TensorValue>::Unmasked as BitAnd<u16>>::Output>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: u16) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<u32> for &Tensor<T, S>

where T: TensorOp<u32>, T::Unmasked: BitAnd<u32>, <T::Unmasked as BitAnd<u32>>::Output: TensorValue, T::Output<<T::Unmasked as BitAnd<u32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u32>>::Output<<<T as TensorValue>::Unmasked as BitAnd<u32>>::Output>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: u32) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<u32> for Tensor<T, S>

where T: TensorOp<u32>, T::Unmasked: BitAnd<u32>, <T::Unmasked as BitAnd<u32>>::Output: TensorValue, T::Output<<T::Unmasked as BitAnd<u32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u32>>::Output<<<T as TensorValue>::Unmasked as BitAnd<u32>>::Output>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: u32) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<u64> for &Tensor<T, S>

where T: TensorOp<u64>, T::Unmasked: BitAnd<u64>, <T::Unmasked as BitAnd<u64>>::Output: TensorValue, T::Output<<T::Unmasked as BitAnd<u64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u64>>::Output<<<T as TensorValue>::Unmasked as BitAnd<u64>>::Output>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: u64) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<u64> for Tensor<T, S>

where T: TensorOp<u64>, T::Unmasked: BitAnd<u64>, <T::Unmasked as BitAnd<u64>>::Output: TensorValue, T::Output<<T::Unmasked as BitAnd<u64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u64>>::Output<<<T as TensorValue>::Unmasked as BitAnd<u64>>::Output>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: u64) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<u8> for &Tensor<T, S>

where T: TensorOp<u8>, T::Unmasked: BitAnd<u8>, <T::Unmasked as BitAnd<u8>>::Output: TensorValue, T::Output<<T::Unmasked as BitAnd<u8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u8>>::Output<<<T as TensorValue>::Unmasked as BitAnd<u8>>::Output>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: u8) -> Self::Output

Performs the & operation.

impl<T, S> BitAnd<u8> for Tensor<T, S>

where T: TensorOp<u8>, T::Unmasked: BitAnd<u8>, <T::Unmasked as BitAnd<u8>>::Output: TensorValue, T::Output<<T::Unmasked as BitAnd<u8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u8>>::Output<<<T as TensorValue>::Unmasked as BitAnd<u8>>::Output>, S>

The resulting type after applying the & operator.

fn bitand(self, rhs: u8) -> Self::Output

Performs the & operation.

impl<T, S> BitOr<&Tensor<T, S>> for bool

where bool: TensorOp<T>, T: TensorValue<Unmasked = bool>, <bool as TensorOp<T>>::Output<bool>: TensorValue, S: Shape,

type Output = Tensor<<bool as TensorOp<T>>::Output<bool>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<&Tensor<T, S>> for i16

where i16: TensorOp<T>, T: TensorValue<Unmasked = i16>, <i16 as TensorOp<T>>::Output<i16>: TensorValue, S: Shape,

type Output = Tensor<<i16 as TensorOp<T>>::Output<i16>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<&Tensor<T, S>> for i32

where i32: TensorOp<T>, T: TensorValue<Unmasked = i32>, <i32 as TensorOp<T>>::Output<i32>: TensorValue, S: Shape,

type Output = Tensor<<i32 as TensorOp<T>>::Output<i32>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<&Tensor<T, S>> for i64

where i64: TensorOp<T>, T: TensorValue<Unmasked = i64>, <i64 as TensorOp<T>>::Output<i64>: TensorValue, S: Shape,

type Output = Tensor<<i64 as TensorOp<T>>::Output<i64>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<&Tensor<T, S>> for i8

where i8: TensorOp<T>, T: TensorValue<Unmasked = i8>, <i8 as TensorOp<T>>::Output<i8>: TensorValue, S: Shape,

type Output = Tensor<<i8 as TensorOp<T>>::Output<i8>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<&Tensor<T, S>> for u16

where u16: TensorOp<T>, T: TensorValue<Unmasked = u16>, <u16 as TensorOp<T>>::Output<u16>: TensorValue, S: Shape,

type Output = Tensor<<u16 as TensorOp<T>>::Output<u16>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<&Tensor<T, S>> for u32

where u32: TensorOp<T>, T: TensorValue<Unmasked = u32>, <u32 as TensorOp<T>>::Output<u32>: TensorValue, S: Shape,

type Output = Tensor<<u32 as TensorOp<T>>::Output<u32>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<&Tensor<T, S>> for u64

where u64: TensorOp<T>, T: TensorValue<Unmasked = u64>, <u64 as TensorOp<T>>::Output<u64>: TensorValue, S: Shape,

type Output = Tensor<<u64 as TensorOp<T>>::Output<u64>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<&Tensor<T, S>> for u8

where u8: TensorOp<T>, T: TensorValue<Unmasked = u8>, <u8 as TensorOp<T>>::Output<u8>: TensorValue, S: Shape,

type Output = Tensor<<u8 as TensorOp<T>>::Output<u8>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the | operation.

impl<T1, T2, S1, S2> BitOr<&Tensor<T2, S2>> for &Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: BitOr<T2::Unmasked>, <T1::Unmasked as BitOr<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as BitOr<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as BitOr<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Tensor<T2, S2>) -> Self::Output

Performs the | operation.

impl<T1, T2, S1, S2> BitOr<&Tensor<T2, S2>> for Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: BitOr<T2::Unmasked>, <T1::Unmasked as BitOr<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as BitOr<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as BitOr<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Tensor<T2, S2>) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<Tensor<T, S>> for bool

where bool: TensorOp<T>, T: TensorValue<Unmasked = bool>, <bool as TensorOp<T>>::Output<bool>: TensorValue, S: Shape,

type Output = Tensor<<bool as TensorOp<T>>::Output<bool>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: Tensor<T, S>) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<Tensor<T, S>> for i16

where i16: TensorOp<T>, T: TensorValue<Unmasked = i16>, <i16 as TensorOp<T>>::Output<i16>: TensorValue, S: Shape,

type Output = Tensor<<i16 as TensorOp<T>>::Output<i16>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: Tensor<T, S>) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<Tensor<T, S>> for i32

where i32: TensorOp<T>, T: TensorValue<Unmasked = i32>, <i32 as TensorOp<T>>::Output<i32>: TensorValue, S: Shape,

type Output = Tensor<<i32 as TensorOp<T>>::Output<i32>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: Tensor<T, S>) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<Tensor<T, S>> for i64

where i64: TensorOp<T>, T: TensorValue<Unmasked = i64>, <i64 as TensorOp<T>>::Output<i64>: TensorValue, S: Shape,

type Output = Tensor<<i64 as TensorOp<T>>::Output<i64>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: Tensor<T, S>) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<Tensor<T, S>> for i8

where i8: TensorOp<T>, T: TensorValue<Unmasked = i8>, <i8 as TensorOp<T>>::Output<i8>: TensorValue, S: Shape,

type Output = Tensor<<i8 as TensorOp<T>>::Output<i8>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: Tensor<T, S>) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<Tensor<T, S>> for u16

where u16: TensorOp<T>, T: TensorValue<Unmasked = u16>, <u16 as TensorOp<T>>::Output<u16>: TensorValue, S: Shape,

type Output = Tensor<<u16 as TensorOp<T>>::Output<u16>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: Tensor<T, S>) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<Tensor<T, S>> for u32

where u32: TensorOp<T>, T: TensorValue<Unmasked = u32>, <u32 as TensorOp<T>>::Output<u32>: TensorValue, S: Shape,

type Output = Tensor<<u32 as TensorOp<T>>::Output<u32>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: Tensor<T, S>) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<Tensor<T, S>> for u64

where u64: TensorOp<T>, T: TensorValue<Unmasked = u64>, <u64 as TensorOp<T>>::Output<u64>: TensorValue, S: Shape,

type Output = Tensor<<u64 as TensorOp<T>>::Output<u64>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: Tensor<T, S>) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<Tensor<T, S>> for u8

where u8: TensorOp<T>, T: TensorValue<Unmasked = u8>, <u8 as TensorOp<T>>::Output<u8>: TensorValue, S: Shape,

type Output = Tensor<<u8 as TensorOp<T>>::Output<u8>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: Tensor<T, S>) -> Self::Output

Performs the | operation.

impl<T1, T2, S1, S2> BitOr<Tensor<T2, S2>> for &Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: BitOr<T2::Unmasked>, <T1::Unmasked as BitOr<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as BitOr<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as BitOr<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the | operator.

fn bitor(self, rhs: Tensor<T2, S2>) -> Self::Output

Performs the | operation.

impl<T1, T2, S1, S2> BitOr<Tensor<T2, S2>> for Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: BitOr<T2::Unmasked>, <T1::Unmasked as BitOr<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as BitOr<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as BitOr<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the | operator.

fn bitor(self, rhs: Tensor<T2, S2>) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<bool> for &Tensor<T, S>

where T: TensorOp<bool>, T::Unmasked: BitOr<bool>, <T::Unmasked as BitOr<bool>>::Output: TensorValue, T::Output<<T::Unmasked as BitOr<bool>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<bool>>::Output<<<T as TensorValue>::Unmasked as BitOr<bool>>::Output>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: bool) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<bool> for Tensor<T, S>

where T: TensorOp<bool>, T::Unmasked: BitOr<bool>, <T::Unmasked as BitOr<bool>>::Output: TensorValue, T::Output<<T::Unmasked as BitOr<bool>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<bool>>::Output<<<T as TensorValue>::Unmasked as BitOr<bool>>::Output>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: bool) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<i16> for &Tensor<T, S>

where T: TensorOp<i16>, T::Unmasked: BitOr<i16>, <T::Unmasked as BitOr<i16>>::Output: TensorValue, T::Output<<T::Unmasked as BitOr<i16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i16>>::Output<<<T as TensorValue>::Unmasked as BitOr<i16>>::Output>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: i16) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<i16> for Tensor<T, S>

where T: TensorOp<i16>, T::Unmasked: BitOr<i16>, <T::Unmasked as BitOr<i16>>::Output: TensorValue, T::Output<<T::Unmasked as BitOr<i16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i16>>::Output<<<T as TensorValue>::Unmasked as BitOr<i16>>::Output>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: i16) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<i32> for &Tensor<T, S>

where T: TensorOp<i32>, T::Unmasked: BitOr<i32>, <T::Unmasked as BitOr<i32>>::Output: TensorValue, T::Output<<T::Unmasked as BitOr<i32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i32>>::Output<<<T as TensorValue>::Unmasked as BitOr<i32>>::Output>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: i32) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<i32> for Tensor<T, S>

where T: TensorOp<i32>, T::Unmasked: BitOr<i32>, <T::Unmasked as BitOr<i32>>::Output: TensorValue, T::Output<<T::Unmasked as BitOr<i32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i32>>::Output<<<T as TensorValue>::Unmasked as BitOr<i32>>::Output>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: i32) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<i64> for &Tensor<T, S>

where T: TensorOp<i64>, T::Unmasked: BitOr<i64>, <T::Unmasked as BitOr<i64>>::Output: TensorValue, T::Output<<T::Unmasked as BitOr<i64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i64>>::Output<<<T as TensorValue>::Unmasked as BitOr<i64>>::Output>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: i64) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<i64> for Tensor<T, S>

where T: TensorOp<i64>, T::Unmasked: BitOr<i64>, <T::Unmasked as BitOr<i64>>::Output: TensorValue, T::Output<<T::Unmasked as BitOr<i64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i64>>::Output<<<T as TensorValue>::Unmasked as BitOr<i64>>::Output>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: i64) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<i8> for &Tensor<T, S>

where T: TensorOp<i8>, T::Unmasked: BitOr<i8>, <T::Unmasked as BitOr<i8>>::Output: TensorValue, T::Output<<T::Unmasked as BitOr<i8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i8>>::Output<<<T as TensorValue>::Unmasked as BitOr<i8>>::Output>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: i8) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<i8> for Tensor<T, S>

where T: TensorOp<i8>, T::Unmasked: BitOr<i8>, <T::Unmasked as BitOr<i8>>::Output: TensorValue, T::Output<<T::Unmasked as BitOr<i8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i8>>::Output<<<T as TensorValue>::Unmasked as BitOr<i8>>::Output>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: i8) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<u16> for &Tensor<T, S>

where T: TensorOp<u16>, T::Unmasked: BitOr<u16>, <T::Unmasked as BitOr<u16>>::Output: TensorValue, T::Output<<T::Unmasked as BitOr<u16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u16>>::Output<<<T as TensorValue>::Unmasked as BitOr<u16>>::Output>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: u16) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<u16> for Tensor<T, S>

where T: TensorOp<u16>, T::Unmasked: BitOr<u16>, <T::Unmasked as BitOr<u16>>::Output: TensorValue, T::Output<<T::Unmasked as BitOr<u16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u16>>::Output<<<T as TensorValue>::Unmasked as BitOr<u16>>::Output>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: u16) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<u32> for &Tensor<T, S>

where T: TensorOp<u32>, T::Unmasked: BitOr<u32>, <T::Unmasked as BitOr<u32>>::Output: TensorValue, T::Output<<T::Unmasked as BitOr<u32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u32>>::Output<<<T as TensorValue>::Unmasked as BitOr<u32>>::Output>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: u32) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<u32> for Tensor<T, S>

where T: TensorOp<u32>, T::Unmasked: BitOr<u32>, <T::Unmasked as BitOr<u32>>::Output: TensorValue, T::Output<<T::Unmasked as BitOr<u32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u32>>::Output<<<T as TensorValue>::Unmasked as BitOr<u32>>::Output>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: u32) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<u64> for &Tensor<T, S>

where T: TensorOp<u64>, T::Unmasked: BitOr<u64>, <T::Unmasked as BitOr<u64>>::Output: TensorValue, T::Output<<T::Unmasked as BitOr<u64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u64>>::Output<<<T as TensorValue>::Unmasked as BitOr<u64>>::Output>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: u64) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<u64> for Tensor<T, S>

where T: TensorOp<u64>, T::Unmasked: BitOr<u64>, <T::Unmasked as BitOr<u64>>::Output: TensorValue, T::Output<<T::Unmasked as BitOr<u64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u64>>::Output<<<T as TensorValue>::Unmasked as BitOr<u64>>::Output>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: u64) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<u8> for &Tensor<T, S>

where T: TensorOp<u8>, T::Unmasked: BitOr<u8>, <T::Unmasked as BitOr<u8>>::Output: TensorValue, T::Output<<T::Unmasked as BitOr<u8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u8>>::Output<<<T as TensorValue>::Unmasked as BitOr<u8>>::Output>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: u8) -> Self::Output

Performs the | operation.

impl<T, S> BitOr<u8> for Tensor<T, S>

where T: TensorOp<u8>, T::Unmasked: BitOr<u8>, <T::Unmasked as BitOr<u8>>::Output: TensorValue, T::Output<<T::Unmasked as BitOr<u8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u8>>::Output<<<T as TensorValue>::Unmasked as BitOr<u8>>::Output>, S>

The resulting type after applying the | operator.

fn bitor(self, rhs: u8) -> Self::Output

Performs the | operation.

impl<T, S> BitXor<&Tensor<T, S>> for bool

where bool: TensorOp<T>, T: TensorValue<Unmasked = bool>, <bool as TensorOp<T>>::Output<bool>: TensorValue, S: Shape,

type Output = Tensor<<bool as TensorOp<T>>::Output<bool>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<&Tensor<T, S>> for i16

where i16: TensorOp<T>, T: TensorValue<Unmasked = i16>, <i16 as TensorOp<T>>::Output<i16>: TensorValue, S: Shape,

type Output = Tensor<<i16 as TensorOp<T>>::Output<i16>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<&Tensor<T, S>> for i32

where i32: TensorOp<T>, T: TensorValue<Unmasked = i32>, <i32 as TensorOp<T>>::Output<i32>: TensorValue, S: Shape,

type Output = Tensor<<i32 as TensorOp<T>>::Output<i32>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<&Tensor<T, S>> for i64

where i64: TensorOp<T>, T: TensorValue<Unmasked = i64>, <i64 as TensorOp<T>>::Output<i64>: TensorValue, S: Shape,

type Output = Tensor<<i64 as TensorOp<T>>::Output<i64>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<&Tensor<T, S>> for i8

where i8: TensorOp<T>, T: TensorValue<Unmasked = i8>, <i8 as TensorOp<T>>::Output<i8>: TensorValue, S: Shape,

type Output = Tensor<<i8 as TensorOp<T>>::Output<i8>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<&Tensor<T, S>> for u16

where u16: TensorOp<T>, T: TensorValue<Unmasked = u16>, <u16 as TensorOp<T>>::Output<u16>: TensorValue, S: Shape,

type Output = Tensor<<u16 as TensorOp<T>>::Output<u16>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<&Tensor<T, S>> for u32

where u32: TensorOp<T>, T: TensorValue<Unmasked = u32>, <u32 as TensorOp<T>>::Output<u32>: TensorValue, S: Shape,

type Output = Tensor<<u32 as TensorOp<T>>::Output<u32>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<&Tensor<T, S>> for u64

where u64: TensorOp<T>, T: TensorValue<Unmasked = u64>, <u64 as TensorOp<T>>::Output<u64>: TensorValue, S: Shape,

type Output = Tensor<<u64 as TensorOp<T>>::Output<u64>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<&Tensor<T, S>> for u8

where u8: TensorOp<T>, T: TensorValue<Unmasked = u8>, <u8 as TensorOp<T>>::Output<u8>: TensorValue, S: Shape,

type Output = Tensor<<u8 as TensorOp<T>>::Output<u8>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the ^ operation.

impl<T1, T2, S1, S2> BitXor<&Tensor<T2, S2>> for &Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: BitXor<T2::Unmasked>, <T1::Unmasked as BitXor<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as BitXor<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as BitXor<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Tensor<T2, S2>) -> Self::Output

Performs the ^ operation.

impl<T1, T2, S1, S2> BitXor<&Tensor<T2, S2>> for Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: BitXor<T2::Unmasked>, <T1::Unmasked as BitXor<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as BitXor<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as BitXor<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Tensor<T2, S2>) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<Tensor<T, S>> for bool

where bool: TensorOp<T>, T: TensorValue<Unmasked = bool>, <bool as TensorOp<T>>::Output<bool>: TensorValue, S: Shape,

type Output = Tensor<<bool as TensorOp<T>>::Output<bool>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Tensor<T, S>) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<Tensor<T, S>> for i16

where i16: TensorOp<T>, T: TensorValue<Unmasked = i16>, <i16 as TensorOp<T>>::Output<i16>: TensorValue, S: Shape,

type Output = Tensor<<i16 as TensorOp<T>>::Output<i16>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Tensor<T, S>) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<Tensor<T, S>> for i32

where i32: TensorOp<T>, T: TensorValue<Unmasked = i32>, <i32 as TensorOp<T>>::Output<i32>: TensorValue, S: Shape,

type Output = Tensor<<i32 as TensorOp<T>>::Output<i32>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Tensor<T, S>) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<Tensor<T, S>> for i64

where i64: TensorOp<T>, T: TensorValue<Unmasked = i64>, <i64 as TensorOp<T>>::Output<i64>: TensorValue, S: Shape,

type Output = Tensor<<i64 as TensorOp<T>>::Output<i64>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Tensor<T, S>) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<Tensor<T, S>> for i8

where i8: TensorOp<T>, T: TensorValue<Unmasked = i8>, <i8 as TensorOp<T>>::Output<i8>: TensorValue, S: Shape,

type Output = Tensor<<i8 as TensorOp<T>>::Output<i8>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Tensor<T, S>) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<Tensor<T, S>> for u16

where u16: TensorOp<T>, T: TensorValue<Unmasked = u16>, <u16 as TensorOp<T>>::Output<u16>: TensorValue, S: Shape,

type Output = Tensor<<u16 as TensorOp<T>>::Output<u16>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Tensor<T, S>) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<Tensor<T, S>> for u32

where u32: TensorOp<T>, T: TensorValue<Unmasked = u32>, <u32 as TensorOp<T>>::Output<u32>: TensorValue, S: Shape,

type Output = Tensor<<u32 as TensorOp<T>>::Output<u32>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Tensor<T, S>) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<Tensor<T, S>> for u64

where u64: TensorOp<T>, T: TensorValue<Unmasked = u64>, <u64 as TensorOp<T>>::Output<u64>: TensorValue, S: Shape,

type Output = Tensor<<u64 as TensorOp<T>>::Output<u64>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Tensor<T, S>) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<Tensor<T, S>> for u8

where u8: TensorOp<T>, T: TensorValue<Unmasked = u8>, <u8 as TensorOp<T>>::Output<u8>: TensorValue, S: Shape,

type Output = Tensor<<u8 as TensorOp<T>>::Output<u8>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Tensor<T, S>) -> Self::Output

Performs the ^ operation.

impl<T1, T2, S1, S2> BitXor<Tensor<T2, S2>> for &Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: BitXor<T2::Unmasked>, <T1::Unmasked as BitXor<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as BitXor<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as BitXor<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Tensor<T2, S2>) -> Self::Output

Performs the ^ operation.

impl<T1, T2, S1, S2> BitXor<Tensor<T2, S2>> for Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: BitXor<T2::Unmasked>, <T1::Unmasked as BitXor<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as BitXor<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as BitXor<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Tensor<T2, S2>) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<bool> for &Tensor<T, S>

where T: TensorOp<bool>, T::Unmasked: BitXor<bool>, <T::Unmasked as BitXor<bool>>::Output: TensorValue, T::Output<<T::Unmasked as BitXor<bool>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<bool>>::Output<<<T as TensorValue>::Unmasked as BitXor<bool>>::Output>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: bool) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<bool> for Tensor<T, S>

where T: TensorOp<bool>, T::Unmasked: BitXor<bool>, <T::Unmasked as BitXor<bool>>::Output: TensorValue, T::Output<<T::Unmasked as BitXor<bool>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<bool>>::Output<<<T as TensorValue>::Unmasked as BitXor<bool>>::Output>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: bool) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<i16> for &Tensor<T, S>

where T: TensorOp<i16>, T::Unmasked: BitXor<i16>, <T::Unmasked as BitXor<i16>>::Output: TensorValue, T::Output<<T::Unmasked as BitXor<i16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i16>>::Output<<<T as TensorValue>::Unmasked as BitXor<i16>>::Output>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i16) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<i16> for Tensor<T, S>

where T: TensorOp<i16>, T::Unmasked: BitXor<i16>, <T::Unmasked as BitXor<i16>>::Output: TensorValue, T::Output<<T::Unmasked as BitXor<i16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i16>>::Output<<<T as TensorValue>::Unmasked as BitXor<i16>>::Output>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i16) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<i32> for &Tensor<T, S>

where T: TensorOp<i32>, T::Unmasked: BitXor<i32>, <T::Unmasked as BitXor<i32>>::Output: TensorValue, T::Output<<T::Unmasked as BitXor<i32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i32>>::Output<<<T as TensorValue>::Unmasked as BitXor<i32>>::Output>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i32) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<i32> for Tensor<T, S>

where T: TensorOp<i32>, T::Unmasked: BitXor<i32>, <T::Unmasked as BitXor<i32>>::Output: TensorValue, T::Output<<T::Unmasked as BitXor<i32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i32>>::Output<<<T as TensorValue>::Unmasked as BitXor<i32>>::Output>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i32) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<i64> for &Tensor<T, S>

where T: TensorOp<i64>, T::Unmasked: BitXor<i64>, <T::Unmasked as BitXor<i64>>::Output: TensorValue, T::Output<<T::Unmasked as BitXor<i64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i64>>::Output<<<T as TensorValue>::Unmasked as BitXor<i64>>::Output>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i64) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<i64> for Tensor<T, S>

where T: TensorOp<i64>, T::Unmasked: BitXor<i64>, <T::Unmasked as BitXor<i64>>::Output: TensorValue, T::Output<<T::Unmasked as BitXor<i64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i64>>::Output<<<T as TensorValue>::Unmasked as BitXor<i64>>::Output>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i64) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<i8> for &Tensor<T, S>

where T: TensorOp<i8>, T::Unmasked: BitXor<i8>, <T::Unmasked as BitXor<i8>>::Output: TensorValue, T::Output<<T::Unmasked as BitXor<i8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i8>>::Output<<<T as TensorValue>::Unmasked as BitXor<i8>>::Output>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i8) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<i8> for Tensor<T, S>

where T: TensorOp<i8>, T::Unmasked: BitXor<i8>, <T::Unmasked as BitXor<i8>>::Output: TensorValue, T::Output<<T::Unmasked as BitXor<i8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i8>>::Output<<<T as TensorValue>::Unmasked as BitXor<i8>>::Output>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i8) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<u16> for &Tensor<T, S>

where T: TensorOp<u16>, T::Unmasked: BitXor<u16>, <T::Unmasked as BitXor<u16>>::Output: TensorValue, T::Output<<T::Unmasked as BitXor<u16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u16>>::Output<<<T as TensorValue>::Unmasked as BitXor<u16>>::Output>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u16) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<u16> for Tensor<T, S>

where T: TensorOp<u16>, T::Unmasked: BitXor<u16>, <T::Unmasked as BitXor<u16>>::Output: TensorValue, T::Output<<T::Unmasked as BitXor<u16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u16>>::Output<<<T as TensorValue>::Unmasked as BitXor<u16>>::Output>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u16) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<u32> for &Tensor<T, S>

where T: TensorOp<u32>, T::Unmasked: BitXor<u32>, <T::Unmasked as BitXor<u32>>::Output: TensorValue, T::Output<<T::Unmasked as BitXor<u32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u32>>::Output<<<T as TensorValue>::Unmasked as BitXor<u32>>::Output>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u32) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<u32> for Tensor<T, S>

where T: TensorOp<u32>, T::Unmasked: BitXor<u32>, <T::Unmasked as BitXor<u32>>::Output: TensorValue, T::Output<<T::Unmasked as BitXor<u32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u32>>::Output<<<T as TensorValue>::Unmasked as BitXor<u32>>::Output>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u32) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<u64> for &Tensor<T, S>

where T: TensorOp<u64>, T::Unmasked: BitXor<u64>, <T::Unmasked as BitXor<u64>>::Output: TensorValue, T::Output<<T::Unmasked as BitXor<u64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u64>>::Output<<<T as TensorValue>::Unmasked as BitXor<u64>>::Output>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u64) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<u64> for Tensor<T, S>

where T: TensorOp<u64>, T::Unmasked: BitXor<u64>, <T::Unmasked as BitXor<u64>>::Output: TensorValue, T::Output<<T::Unmasked as BitXor<u64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u64>>::Output<<<T as TensorValue>::Unmasked as BitXor<u64>>::Output>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u64) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<u8> for &Tensor<T, S>

where T: TensorOp<u8>, T::Unmasked: BitXor<u8>, <T::Unmasked as BitXor<u8>>::Output: TensorValue, T::Output<<T::Unmasked as BitXor<u8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u8>>::Output<<<T as TensorValue>::Unmasked as BitXor<u8>>::Output>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u8) -> Self::Output

Performs the ^ operation.

impl<T, S> BitXor<u8> for Tensor<T, S>

where T: TensorOp<u8>, T::Unmasked: BitXor<u8>, <T::Unmasked as BitXor<u8>>::Output: TensorValue, T::Output<<T::Unmasked as BitXor<u8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u8>>::Output<<<T as TensorValue>::Unmasked as BitXor<u8>>::Output>, S>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u8) -> Self::Output

Performs the ^ operation.

impl<T: Clone + TensorValue, S: Clone> Clone for Tensor<T, S>

where T::Array: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, S> Column for Tensor<T, S>

where T: TensorValue, S: Shape,

fn tensor_type(&self) -> TensorType

fn shape(&self) -> Dyn

fn strides(&self) -> Dyn

fn nullable(&self) -> bool

fn to_arrow(&self) -> ArrayRef

fn data(&self) -> ArrayData

fn arrow_type(&self) -> DataType

fn row_shape(&self) -> Option<Dyn>

impl<T, S> Debug for Tensor<T, S>

where T: TensorValue, S: Shape,

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

Formats the value using the given formatter.

impl<T, S> Div<&Tensor<T, S>> for f32

where f32: TensorOp<T>, T: TensorValue<Unmasked = f32>, <f32 as TensorOp<T>>::Output<f32>: TensorValue, S: Shape,

type Output = Tensor<<f32 as TensorOp<T>>::Output<f32>, S>

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the / operation.

impl<T, S> Div<&Tensor<T, S>> for f64

where f64: TensorOp<T>, T: TensorValue<Unmasked = f64>, <f64 as TensorOp<T>>::Output<f64>: TensorValue, S: Shape,

type Output = Tensor<<f64 as TensorOp<T>>::Output<f64>, S>

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the / operation.

impl<T, S> Div<&Tensor<T, S>> for i16

where i16: TensorOp<T>, T: TensorValue<Unmasked = i16>, <i16 as TensorOp<T>>::Output<i16>: TensorValue, S: Shape,

type Output = Tensor<<i16 as TensorOp<T>>::Output<i16>, S>

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the / operation.

impl<T, S> Div<&Tensor<T, S>> for i32

where i32: TensorOp<T>, T: TensorValue<Unmasked = i32>, <i32 as TensorOp<T>>::Output<i32>: TensorValue, S: Shape,

type Output = Tensor<<i32 as TensorOp<T>>::Output<i32>, S>

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the / operation.

impl<T, S> Div<&Tensor<T, S>> for i64

where i64: TensorOp<T>, T: TensorValue<Unmasked = i64>, <i64 as TensorOp<T>>::Output<i64>: TensorValue, S: Shape,

type Output = Tensor<<i64 as TensorOp<T>>::Output<i64>, S>

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the / operation.

impl<T, S> Div<&Tensor<T, S>> for i8

where i8: TensorOp<T>, T: TensorValue<Unmasked = i8>, <i8 as TensorOp<T>>::Output<i8>: TensorValue, S: Shape,

type Output = Tensor<<i8 as TensorOp<T>>::Output<i8>, S>

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the / operation.

impl<T, S> Div<&Tensor<T, S>> for u16

where u16: TensorOp<T>, T: TensorValue<Unmasked = u16>, <u16 as TensorOp<T>>::Output<u16>: TensorValue, S: Shape,

type Output = Tensor<<u16 as TensorOp<T>>::Output<u16>, S>

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the / operation.

impl<T, S> Div<&Tensor<T, S>> for u32

where u32: TensorOp<T>, T: TensorValue<Unmasked = u32>, <u32 as TensorOp<T>>::Output<u32>: TensorValue, S: Shape,

type Output = Tensor<<u32 as TensorOp<T>>::Output<u32>, S>

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the / operation.

impl<T, S> Div<&Tensor<T, S>> for u64

where u64: TensorOp<T>, T: TensorValue<Unmasked = u64>, <u64 as TensorOp<T>>::Output<u64>: TensorValue, S: Shape,

type Output = Tensor<<u64 as TensorOp<T>>::Output<u64>, S>

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the / operation.

impl<T, S> Div<&Tensor<T, S>> for u8

where u8: TensorOp<T>, T: TensorValue<Unmasked = u8>, <u8 as TensorOp<T>>::Output<u8>: TensorValue, S: Shape,

type Output = Tensor<<u8 as TensorOp<T>>::Output<u8>, S>

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the / operation.

impl<T1, T2, S1, S2> Div<&Tensor<T2, S2>> for &Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: Div<T2::Unmasked>, <T1::Unmasked as Div<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as Div<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as Div<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor<T2, S2>) -> Self::Output

Performs the / operation.

impl<T1, T2, S1, S2> Div<&Tensor<T2, S2>> for Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: Div<T2::Unmasked>, <T1::Unmasked as Div<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as Div<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as Div<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor<T2, S2>) -> Self::Output

Performs the / operation.

impl<T, S> Div<Tensor<T, S>> for f32

where f32: TensorOp<T>, T: TensorValue<Unmasked = f32>, <f32 as TensorOp<T>>::Output<f32>: TensorValue, S: Shape,

type Output = Tensor<<f32 as TensorOp<T>>::Output<f32>, S>

The resulting type after applying the / operator.

fn div(self, rhs: Tensor<T, S>) -> Self::Output

Performs the / operation.

impl<T, S> Div<Tensor<T, S>> for f64

where f64: TensorOp<T>, T: TensorValue<Unmasked = f64>, <f64 as TensorOp<T>>::Output<f64>: TensorValue, S: Shape,

type Output = Tensor<<f64 as TensorOp<T>>::Output<f64>, S>

The resulting type after applying the / operator.

fn div(self, rhs: Tensor<T, S>) -> Self::Output

Performs the / operation.

impl<T, S> Div<Tensor<T, S>> for i16

where i16: TensorOp<T>, T: TensorValue<Unmasked = i16>, <i16 as TensorOp<T>>::Output<i16>: TensorValue, S: Shape,

type Output = Tensor<<i16 as TensorOp<T>>::Output<i16>, S>

The resulting type after applying the / operator.

fn div(self, rhs: Tensor<T, S>) -> Self::Output

Performs the / operation.

impl<T, S> Div<Tensor<T, S>> for i32

where i32: TensorOp<T>, T: TensorValue<Unmasked = i32>, <i32 as TensorOp<T>>::Output<i32>: TensorValue, S: Shape,

type Output = Tensor<<i32 as TensorOp<T>>::Output<i32>, S>

The resulting type after applying the / operator.

fn div(self, rhs: Tensor<T, S>) -> Self::Output

Performs the / operation.

impl<T, S> Div<Tensor<T, S>> for i64

where i64: TensorOp<T>, T: TensorValue<Unmasked = i64>, <i64 as TensorOp<T>>::Output<i64>: TensorValue, S: Shape,

type Output = Tensor<<i64 as TensorOp<T>>::Output<i64>, S>

The resulting type after applying the / operator.

fn div(self, rhs: Tensor<T, S>) -> Self::Output

Performs the / operation.

impl<T, S> Div<Tensor<T, S>> for i8

where i8: TensorOp<T>, T: TensorValue<Unmasked = i8>, <i8 as TensorOp<T>>::Output<i8>: TensorValue, S: Shape,

type Output = Tensor<<i8 as TensorOp<T>>::Output<i8>, S>

The resulting type after applying the / operator.

fn div(self, rhs: Tensor<T, S>) -> Self::Output

Performs the / operation.

impl<T, S> Div<Tensor<T, S>> for u16

where u16: TensorOp<T>, T: TensorValue<Unmasked = u16>, <u16 as TensorOp<T>>::Output<u16>: TensorValue, S: Shape,

type Output = Tensor<<u16 as TensorOp<T>>::Output<u16>, S>

The resulting type after applying the / operator.

fn div(self, rhs: Tensor<T, S>) -> Self::Output

Performs the / operation.

impl<T, S> Div<Tensor<T, S>> for u32

where u32: TensorOp<T>, T: TensorValue<Unmasked = u32>, <u32 as TensorOp<T>>::Output<u32>: TensorValue, S: Shape,

type Output = Tensor<<u32 as TensorOp<T>>::Output<u32>, S>

The resulting type after applying the / operator.

fn div(self, rhs: Tensor<T, S>) -> Self::Output

Performs the / operation.

impl<T, S> Div<Tensor<T, S>> for u64

where u64: TensorOp<T>, T: TensorValue<Unmasked = u64>, <u64 as TensorOp<T>>::Output<u64>: TensorValue, S: Shape,

type Output = Tensor<<u64 as TensorOp<T>>::Output<u64>, S>

The resulting type after applying the / operator.

fn div(self, rhs: Tensor<T, S>) -> Self::Output

Performs the / operation.

impl<T, S> Div<Tensor<T, S>> for u8

where u8: TensorOp<T>, T: TensorValue<Unmasked = u8>, <u8 as TensorOp<T>>::Output<u8>: TensorValue, S: Shape,

type Output = Tensor<<u8 as TensorOp<T>>::Output<u8>, S>

The resulting type after applying the / operator.

fn div(self, rhs: Tensor<T, S>) -> Self::Output

Performs the / operation.

impl<T1, T2, S1, S2> Div<Tensor<T2, S2>> for &Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: Div<T2::Unmasked>, <T1::Unmasked as Div<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as Div<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as Div<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: Tensor<T2, S2>) -> Self::Output

Performs the / operation.

impl<T1, T2, S1, S2> Div<Tensor<T2, S2>> for Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: Div<T2::Unmasked>, <T1::Unmasked as Div<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as Div<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as Div<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: Tensor<T2, S2>) -> Self::Output

Performs the / operation.

impl<T, S> Div<f32> for &Tensor<T, S>

where T: TensorOp<f32>, T::Unmasked: Div<f32>, <T::Unmasked as Div<f32>>::Output: TensorValue, T::Output<<T::Unmasked as Div<f32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<f32>>::Output<<<T as TensorValue>::Unmasked as Div<f32>>::Output>, S>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self::Output

Performs the / operation.

impl<T, S> Div<f32> for Tensor<T, S>

where T: TensorOp<f32>, T::Unmasked: Div<f32>, <T::Unmasked as Div<f32>>::Output: TensorValue, T::Output<<T::Unmasked as Div<f32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<f32>>::Output<<<T as TensorValue>::Unmasked as Div<f32>>::Output>, S>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self::Output

Performs the / operation.

impl<T, S> Div<f64> for &Tensor<T, S>

where T: TensorOp<f64>, T::Unmasked: Div<f64>, <T::Unmasked as Div<f64>>::Output: TensorValue, T::Output<<T::Unmasked as Div<f64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<f64>>::Output<<<T as TensorValue>::Unmasked as Div<f64>>::Output>, S>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Performs the / operation.

impl<T, S> Div<f64> for Tensor<T, S>

where T: TensorOp<f64>, T::Unmasked: Div<f64>, <T::Unmasked as Div<f64>>::Output: TensorValue, T::Output<<T::Unmasked as Div<f64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<f64>>::Output<<<T as TensorValue>::Unmasked as Div<f64>>::Output>, S>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Performs the / operation.

impl<T, S> Div<i16> for &Tensor<T, S>

where T: TensorOp<i16>, T::Unmasked: Div<i16>, <T::Unmasked as Div<i16>>::Output: TensorValue, T::Output<<T::Unmasked as Div<i16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i16>>::Output<<<T as TensorValue>::Unmasked as Div<i16>>::Output>, S>

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> Self::Output

Performs the / operation.

impl<T, S> Div<i16> for Tensor<T, S>

where T: TensorOp<i16>, T::Unmasked: Div<i16>, <T::Unmasked as Div<i16>>::Output: TensorValue, T::Output<<T::Unmasked as Div<i16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i16>>::Output<<<T as TensorValue>::Unmasked as Div<i16>>::Output>, S>

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> Self::Output

Performs the / operation.

impl<T, S> Div<i32> for &Tensor<T, S>

where T: TensorOp<i32>, T::Unmasked: Div<i32>, <T::Unmasked as Div<i32>>::Output: TensorValue, T::Output<<T::Unmasked as Div<i32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i32>>::Output<<<T as TensorValue>::Unmasked as Div<i32>>::Output>, S>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self::Output

Performs the / operation.

impl<T, S> Div<i32> for Tensor<T, S>

where T: TensorOp<i32>, T::Unmasked: Div<i32>, <T::Unmasked as Div<i32>>::Output: TensorValue, T::Output<<T::Unmasked as Div<i32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i32>>::Output<<<T as TensorValue>::Unmasked as Div<i32>>::Output>, S>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self::Output

Performs the / operation.

impl<T, S> Div<i64> for &Tensor<T, S>

where T: TensorOp<i64>, T::Unmasked: Div<i64>, <T::Unmasked as Div<i64>>::Output: TensorValue, T::Output<<T::Unmasked as Div<i64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i64>>::Output<<<T as TensorValue>::Unmasked as Div<i64>>::Output>, S>

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> Self::Output

Performs the / operation.

impl<T, S> Div<i64> for Tensor<T, S>

where T: TensorOp<i64>, T::Unmasked: Div<i64>, <T::Unmasked as Div<i64>>::Output: TensorValue, T::Output<<T::Unmasked as Div<i64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i64>>::Output<<<T as TensorValue>::Unmasked as Div<i64>>::Output>, S>

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> Self::Output

Performs the / operation.

impl<T, S> Div<i8> for &Tensor<T, S>

where T: TensorOp<i8>, T::Unmasked: Div<i8>, <T::Unmasked as Div<i8>>::Output: TensorValue, T::Output<<T::Unmasked as Div<i8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i8>>::Output<<<T as TensorValue>::Unmasked as Div<i8>>::Output>, S>

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> Self::Output

Performs the / operation.

impl<T, S> Div<i8> for Tensor<T, S>

where T: TensorOp<i8>, T::Unmasked: Div<i8>, <T::Unmasked as Div<i8>>::Output: TensorValue, T::Output<<T::Unmasked as Div<i8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i8>>::Output<<<T as TensorValue>::Unmasked as Div<i8>>::Output>, S>

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> Self::Output

Performs the / operation.

impl<T, S> Div<u16> for &Tensor<T, S>

where T: TensorOp<u16>, T::Unmasked: Div<u16>, <T::Unmasked as Div<u16>>::Output: TensorValue, T::Output<<T::Unmasked as Div<u16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u16>>::Output<<<T as TensorValue>::Unmasked as Div<u16>>::Output>, S>

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> Self::Output

Performs the / operation.

impl<T, S> Div<u16> for Tensor<T, S>

where T: TensorOp<u16>, T::Unmasked: Div<u16>, <T::Unmasked as Div<u16>>::Output: TensorValue, T::Output<<T::Unmasked as Div<u16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u16>>::Output<<<T as TensorValue>::Unmasked as Div<u16>>::Output>, S>

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> Self::Output

Performs the / operation.

impl<T, S> Div<u32> for &Tensor<T, S>

where T: TensorOp<u32>, T::Unmasked: Div<u32>, <T::Unmasked as Div<u32>>::Output: TensorValue, T::Output<<T::Unmasked as Div<u32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u32>>::Output<<<T as TensorValue>::Unmasked as Div<u32>>::Output>, S>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> Self::Output

Performs the / operation.

impl<T, S> Div<u32> for Tensor<T, S>

where T: TensorOp<u32>, T::Unmasked: Div<u32>, <T::Unmasked as Div<u32>>::Output: TensorValue, T::Output<<T::Unmasked as Div<u32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u32>>::Output<<<T as TensorValue>::Unmasked as Div<u32>>::Output>, S>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> Self::Output

Performs the / operation.

impl<T, S> Div<u64> for &Tensor<T, S>

where T: TensorOp<u64>, T::Unmasked: Div<u64>, <T::Unmasked as Div<u64>>::Output: TensorValue, T::Output<<T::Unmasked as Div<u64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u64>>::Output<<<T as TensorValue>::Unmasked as Div<u64>>::Output>, S>

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> Self::Output

Performs the / operation.

impl<T, S> Div<u64> for Tensor<T, S>

where T: TensorOp<u64>, T::Unmasked: Div<u64>, <T::Unmasked as Div<u64>>::Output: TensorValue, T::Output<<T::Unmasked as Div<u64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u64>>::Output<<<T as TensorValue>::Unmasked as Div<u64>>::Output>, S>

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> Self::Output

Performs the / operation.

impl<T, S> Div<u8> for &Tensor<T, S>

where T: TensorOp<u8>, T::Unmasked: Div<u8>, <T::Unmasked as Div<u8>>::Output: TensorValue, T::Output<<T::Unmasked as Div<u8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u8>>::Output<<<T as TensorValue>::Unmasked as Div<u8>>::Output>, S>

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> Self::Output

Performs the / operation.

impl<T, S> Div<u8> for Tensor<T, S>

where T: TensorOp<u8>, T::Unmasked: Div<u8>, <T::Unmasked as Div<u8>>::Output: TensorValue, T::Output<<T::Unmasked as Div<u8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u8>>::Output<<<T as TensorValue>::Unmasked as Div<u8>>::Output>, S>

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> Self::Output

Performs the / operation.

impl<S: Shape> From<&Tensor<bool, S>> for Mask<S>

fn from(t: &Tensor<bool, S>) -> Self

Converts to this type from the input type.

impl<S: Shape> From<Mask<S>> for Tensor<bool, S>

fn from(m: Mask<S>) -> Self

Converts to this type from the input type.

impl<T> From<T> for Tensor<T, Const<0>>

where T: TensorValue,

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: TensorValue> From<Tensor<T, Const<1>>> for Vec<T>

fn from(value: Tensor<T, Const<1>>) -> Self

Converts to this type from the input type.

impl<S: Shape> From<Tensor<bool, S>> for Mask<S>

fn from(t: Tensor<bool, S>) -> Self

Converts to this type from the input type.

impl<T, const D1: usize, const D2: usize> From<Vec<[[T; D2]; D1]>> for Tensor<T, Const<3>>

where T: TensorValue,

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

Converts to this type from the input type.

impl<T, const D: usize> From<Vec<[T; D]>> for Tensor<T, Const<2>>

where T: TensorValue,

fn from(value: Vec<[T; D]>) -> Self

Converts to this type from the input type.

impl<T> From<Vec<T>> for Tensor<T, Const<1>>

where T: TensorValue,

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

Converts to this type from the input type.

impl<T> FromIterator<T> for Tensor<T, Const<1>>

where T: TensorValue,

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a, T, S> IntoIterator for &'a Tensor<T, S>

where T: TensorValue, S: Shape,

type Item = T

The type of the elements being iterated over.

type IntoIter = TensorIter<T, S>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, S> IntoIterator for Tensor<T, S>

where T: TensorValue, S: Shape,

type Item = T

The type of the elements being iterated over.

type IntoIter = TensorIter<T, S>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, S> Mul<&Tensor<T, S>> for f32

where f32: TensorOp<T>, T: TensorValue<Unmasked = f32>, <f32 as TensorOp<T>>::Output<f32>: TensorValue, S: Shape,

type Output = Tensor<<f32 as TensorOp<T>>::Output<f32>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the * operation.

impl<T, S> Mul<&Tensor<T, S>> for f64

where f64: TensorOp<T>, T: TensorValue<Unmasked = f64>, <f64 as TensorOp<T>>::Output<f64>: TensorValue, S: Shape,

type Output = Tensor<<f64 as TensorOp<T>>::Output<f64>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the * operation.

impl<T, S> Mul<&Tensor<T, S>> for i16

where i16: TensorOp<T>, T: TensorValue<Unmasked = i16>, <i16 as TensorOp<T>>::Output<i16>: TensorValue, S: Shape,

type Output = Tensor<<i16 as TensorOp<T>>::Output<i16>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the * operation.

impl<T, S> Mul<&Tensor<T, S>> for i32

where i32: TensorOp<T>, T: TensorValue<Unmasked = i32>, <i32 as TensorOp<T>>::Output<i32>: TensorValue, S: Shape,

type Output = Tensor<<i32 as TensorOp<T>>::Output<i32>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the * operation.

impl<T, S> Mul<&Tensor<T, S>> for i64

where i64: TensorOp<T>, T: TensorValue<Unmasked = i64>, <i64 as TensorOp<T>>::Output<i64>: TensorValue, S: Shape,

type Output = Tensor<<i64 as TensorOp<T>>::Output<i64>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the * operation.

impl<T, S> Mul<&Tensor<T, S>> for i8

where i8: TensorOp<T>, T: TensorValue<Unmasked = i8>, <i8 as TensorOp<T>>::Output<i8>: TensorValue, S: Shape,

type Output = Tensor<<i8 as TensorOp<T>>::Output<i8>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the * operation.

impl<T, S> Mul<&Tensor<T, S>> for u16

where u16: TensorOp<T>, T: TensorValue<Unmasked = u16>, <u16 as TensorOp<T>>::Output<u16>: TensorValue, S: Shape,

type Output = Tensor<<u16 as TensorOp<T>>::Output<u16>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the * operation.

impl<T, S> Mul<&Tensor<T, S>> for u32

where u32: TensorOp<T>, T: TensorValue<Unmasked = u32>, <u32 as TensorOp<T>>::Output<u32>: TensorValue, S: Shape,

type Output = Tensor<<u32 as TensorOp<T>>::Output<u32>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the * operation.

impl<T, S> Mul<&Tensor<T, S>> for u64

where u64: TensorOp<T>, T: TensorValue<Unmasked = u64>, <u64 as TensorOp<T>>::Output<u64>: TensorValue, S: Shape,

type Output = Tensor<<u64 as TensorOp<T>>::Output<u64>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the * operation.

impl<T, S> Mul<&Tensor<T, S>> for u8

where u8: TensorOp<T>, T: TensorValue<Unmasked = u8>, <u8 as TensorOp<T>>::Output<u8>: TensorValue, S: Shape,

type Output = Tensor<<u8 as TensorOp<T>>::Output<u8>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the * operation.

impl<T1, T2, S1, S2> Mul<&Tensor<T2, S2>> for &Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: Mul<T2::Unmasked>, <T1::Unmasked as Mul<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as Mul<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as Mul<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor<T2, S2>) -> Self::Output

Performs the * operation.

impl<T1, T2, S1, S2> Mul<&Tensor<T2, S2>> for Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: Mul<T2::Unmasked>, <T1::Unmasked as Mul<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as Mul<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as Mul<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor<T2, S2>) -> Self::Output

Performs the * operation.

impl<T, S> Mul<Tensor<T, S>> for f32

where f32: TensorOp<T>, T: TensorValue<Unmasked = f32>, <f32 as TensorOp<T>>::Output<f32>: TensorValue, S: Shape,

type Output = Tensor<<f32 as TensorOp<T>>::Output<f32>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<T, S>) -> Self::Output

Performs the * operation.

impl<T, S> Mul<Tensor<T, S>> for f64

where f64: TensorOp<T>, T: TensorValue<Unmasked = f64>, <f64 as TensorOp<T>>::Output<f64>: TensorValue, S: Shape,

type Output = Tensor<<f64 as TensorOp<T>>::Output<f64>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<T, S>) -> Self::Output

Performs the * operation.

impl<T, S> Mul<Tensor<T, S>> for i16

where i16: TensorOp<T>, T: TensorValue<Unmasked = i16>, <i16 as TensorOp<T>>::Output<i16>: TensorValue, S: Shape,

type Output = Tensor<<i16 as TensorOp<T>>::Output<i16>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<T, S>) -> Self::Output

Performs the * operation.

impl<T, S> Mul<Tensor<T, S>> for i32

where i32: TensorOp<T>, T: TensorValue<Unmasked = i32>, <i32 as TensorOp<T>>::Output<i32>: TensorValue, S: Shape,

type Output = Tensor<<i32 as TensorOp<T>>::Output<i32>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<T, S>) -> Self::Output

Performs the * operation.

impl<T, S> Mul<Tensor<T, S>> for i64

where i64: TensorOp<T>, T: TensorValue<Unmasked = i64>, <i64 as TensorOp<T>>::Output<i64>: TensorValue, S: Shape,

type Output = Tensor<<i64 as TensorOp<T>>::Output<i64>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<T, S>) -> Self::Output

Performs the * operation.

impl<T, S> Mul<Tensor<T, S>> for i8

where i8: TensorOp<T>, T: TensorValue<Unmasked = i8>, <i8 as TensorOp<T>>::Output<i8>: TensorValue, S: Shape,

type Output = Tensor<<i8 as TensorOp<T>>::Output<i8>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<T, S>) -> Self::Output

Performs the * operation.

impl<T, S> Mul<Tensor<T, S>> for u16

where u16: TensorOp<T>, T: TensorValue<Unmasked = u16>, <u16 as TensorOp<T>>::Output<u16>: TensorValue, S: Shape,

type Output = Tensor<<u16 as TensorOp<T>>::Output<u16>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<T, S>) -> Self::Output

Performs the * operation.

impl<T, S> Mul<Tensor<T, S>> for u32

where u32: TensorOp<T>, T: TensorValue<Unmasked = u32>, <u32 as TensorOp<T>>::Output<u32>: TensorValue, S: Shape,

type Output = Tensor<<u32 as TensorOp<T>>::Output<u32>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<T, S>) -> Self::Output

Performs the * operation.

impl<T, S> Mul<Tensor<T, S>> for u64

where u64: TensorOp<T>, T: TensorValue<Unmasked = u64>, <u64 as TensorOp<T>>::Output<u64>: TensorValue, S: Shape,

type Output = Tensor<<u64 as TensorOp<T>>::Output<u64>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<T, S>) -> Self::Output

Performs the * operation.

impl<T, S> Mul<Tensor<T, S>> for u8

where u8: TensorOp<T>, T: TensorValue<Unmasked = u8>, <u8 as TensorOp<T>>::Output<u8>: TensorValue, S: Shape,

type Output = Tensor<<u8 as TensorOp<T>>::Output<u8>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<T, S>) -> Self::Output

Performs the * operation.

impl<T1, T2, S1, S2> Mul<Tensor<T2, S2>> for &Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: Mul<T2::Unmasked>, <T1::Unmasked as Mul<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as Mul<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as Mul<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<T2, S2>) -> Self::Output

Performs the * operation.

impl<T1, T2, S1, S2> Mul<Tensor<T2, S2>> for Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: Mul<T2::Unmasked>, <T1::Unmasked as Mul<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as Mul<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as Mul<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<T2, S2>) -> Self::Output

Performs the * operation.

impl<T, S> Mul<f32> for &Tensor<T, S>

where T: TensorOp<f32>, T::Unmasked: Mul<f32>, <T::Unmasked as Mul<f32>>::Output: TensorValue, T::Output<<T::Unmasked as Mul<f32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<f32>>::Output<<<T as TensorValue>::Unmasked as Mul<f32>>::Output>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self::Output

Performs the * operation.

impl<T, S> Mul<f32> for Tensor<T, S>

where T: TensorOp<f32>, T::Unmasked: Mul<f32>, <T::Unmasked as Mul<f32>>::Output: TensorValue, T::Output<<T::Unmasked as Mul<f32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<f32>>::Output<<<T as TensorValue>::Unmasked as Mul<f32>>::Output>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self::Output

Performs the * operation.

impl<T, S> Mul<f64> for &Tensor<T, S>

where T: TensorOp<f64>, T::Unmasked: Mul<f64>, <T::Unmasked as Mul<f64>>::Output: TensorValue, T::Output<<T::Unmasked as Mul<f64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<f64>>::Output<<<T as TensorValue>::Unmasked as Mul<f64>>::Output>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Performs the * operation.

impl<T, S> Mul<f64> for Tensor<T, S>

where T: TensorOp<f64>, T::Unmasked: Mul<f64>, <T::Unmasked as Mul<f64>>::Output: TensorValue, T::Output<<T::Unmasked as Mul<f64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<f64>>::Output<<<T as TensorValue>::Unmasked as Mul<f64>>::Output>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Performs the * operation.

impl<T, S> Mul<i16> for &Tensor<T, S>

where T: TensorOp<i16>, T::Unmasked: Mul<i16>, <T::Unmasked as Mul<i16>>::Output: TensorValue, T::Output<<T::Unmasked as Mul<i16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i16>>::Output<<<T as TensorValue>::Unmasked as Mul<i16>>::Output>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> Self::Output

Performs the * operation.

impl<T, S> Mul<i16> for Tensor<T, S>

where T: TensorOp<i16>, T::Unmasked: Mul<i16>, <T::Unmasked as Mul<i16>>::Output: TensorValue, T::Output<<T::Unmasked as Mul<i16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i16>>::Output<<<T as TensorValue>::Unmasked as Mul<i16>>::Output>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> Self::Output

Performs the * operation.

impl<T, S> Mul<i32> for &Tensor<T, S>

where T: TensorOp<i32>, T::Unmasked: Mul<i32>, <T::Unmasked as Mul<i32>>::Output: TensorValue, T::Output<<T::Unmasked as Mul<i32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i32>>::Output<<<T as TensorValue>::Unmasked as Mul<i32>>::Output>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl<T, S> Mul<i32> for Tensor<T, S>

where T: TensorOp<i32>, T::Unmasked: Mul<i32>, <T::Unmasked as Mul<i32>>::Output: TensorValue, T::Output<<T::Unmasked as Mul<i32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i32>>::Output<<<T as TensorValue>::Unmasked as Mul<i32>>::Output>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl<T, S> Mul<i64> for &Tensor<T, S>

where T: TensorOp<i64>, T::Unmasked: Mul<i64>, <T::Unmasked as Mul<i64>>::Output: TensorValue, T::Output<<T::Unmasked as Mul<i64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i64>>::Output<<<T as TensorValue>::Unmasked as Mul<i64>>::Output>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> Self::Output

Performs the * operation.

impl<T, S> Mul<i64> for Tensor<T, S>

where T: TensorOp<i64>, T::Unmasked: Mul<i64>, <T::Unmasked as Mul<i64>>::Output: TensorValue, T::Output<<T::Unmasked as Mul<i64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i64>>::Output<<<T as TensorValue>::Unmasked as Mul<i64>>::Output>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> Self::Output

Performs the * operation.

impl<T, S> Mul<i8> for &Tensor<T, S>

where T: TensorOp<i8>, T::Unmasked: Mul<i8>, <T::Unmasked as Mul<i8>>::Output: TensorValue, T::Output<<T::Unmasked as Mul<i8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i8>>::Output<<<T as TensorValue>::Unmasked as Mul<i8>>::Output>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> Self::Output

Performs the * operation.

impl<T, S> Mul<i8> for Tensor<T, S>

where T: TensorOp<i8>, T::Unmasked: Mul<i8>, <T::Unmasked as Mul<i8>>::Output: TensorValue, T::Output<<T::Unmasked as Mul<i8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i8>>::Output<<<T as TensorValue>::Unmasked as Mul<i8>>::Output>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> Self::Output

Performs the * operation.

impl<T, S> Mul<u16> for &Tensor<T, S>

where T: TensorOp<u16>, T::Unmasked: Mul<u16>, <T::Unmasked as Mul<u16>>::Output: TensorValue, T::Output<<T::Unmasked as Mul<u16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u16>>::Output<<<T as TensorValue>::Unmasked as Mul<u16>>::Output>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> Self::Output

Performs the * operation.

impl<T, S> Mul<u16> for Tensor<T, S>

where T: TensorOp<u16>, T::Unmasked: Mul<u16>, <T::Unmasked as Mul<u16>>::Output: TensorValue, T::Output<<T::Unmasked as Mul<u16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u16>>::Output<<<T as TensorValue>::Unmasked as Mul<u16>>::Output>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> Self::Output

Performs the * operation.

impl<T, S> Mul<u32> for &Tensor<T, S>

where T: TensorOp<u32>, T::Unmasked: Mul<u32>, <T::Unmasked as Mul<u32>>::Output: TensorValue, T::Output<<T::Unmasked as Mul<u32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u32>>::Output<<<T as TensorValue>::Unmasked as Mul<u32>>::Output>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Self::Output

Performs the * operation.

impl<T, S> Mul<u32> for Tensor<T, S>

where T: TensorOp<u32>, T::Unmasked: Mul<u32>, <T::Unmasked as Mul<u32>>::Output: TensorValue, T::Output<<T::Unmasked as Mul<u32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u32>>::Output<<<T as TensorValue>::Unmasked as Mul<u32>>::Output>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Self::Output

Performs the * operation.

impl<T, S> Mul<u64> for &Tensor<T, S>

where T: TensorOp<u64>, T::Unmasked: Mul<u64>, <T::Unmasked as Mul<u64>>::Output: TensorValue, T::Output<<T::Unmasked as Mul<u64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u64>>::Output<<<T as TensorValue>::Unmasked as Mul<u64>>::Output>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> Self::Output

Performs the * operation.

impl<T, S> Mul<u64> for Tensor<T, S>

where T: TensorOp<u64>, T::Unmasked: Mul<u64>, <T::Unmasked as Mul<u64>>::Output: TensorValue, T::Output<<T::Unmasked as Mul<u64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u64>>::Output<<<T as TensorValue>::Unmasked as Mul<u64>>::Output>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> Self::Output

Performs the * operation.

impl<T, S> Mul<u8> for &Tensor<T, S>

where T: TensorOp<u8>, T::Unmasked: Mul<u8>, <T::Unmasked as Mul<u8>>::Output: TensorValue, T::Output<<T::Unmasked as Mul<u8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u8>>::Output<<<T as TensorValue>::Unmasked as Mul<u8>>::Output>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> Self::Output

Performs the * operation.

impl<T, S> Mul<u8> for Tensor<T, S>

where T: TensorOp<u8>, T::Unmasked: Mul<u8>, <T::Unmasked as Mul<u8>>::Output: TensorValue, T::Output<<T::Unmasked as Mul<u8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u8>>::Output<<<T as TensorValue>::Unmasked as Mul<u8>>::Output>, S>

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> Self::Output

Performs the * operation.

impl<T, S> Rem<&Tensor<T, S>> for f32

where f32: TensorOp<T>, T: TensorValue<Unmasked = f32>, <f32 as TensorOp<T>>::Output<f32>: TensorValue, S: Shape,

type Output = Tensor<<f32 as TensorOp<T>>::Output<f32>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the % operation.

impl<T, S> Rem<&Tensor<T, S>> for f64

where f64: TensorOp<T>, T: TensorValue<Unmasked = f64>, <f64 as TensorOp<T>>::Output<f64>: TensorValue, S: Shape,

type Output = Tensor<<f64 as TensorOp<T>>::Output<f64>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the % operation.

impl<T, S> Rem<&Tensor<T, S>> for i16

where i16: TensorOp<T>, T: TensorValue<Unmasked = i16>, <i16 as TensorOp<T>>::Output<i16>: TensorValue, S: Shape,

type Output = Tensor<<i16 as TensorOp<T>>::Output<i16>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the % operation.

impl<T, S> Rem<&Tensor<T, S>> for i32

where i32: TensorOp<T>, T: TensorValue<Unmasked = i32>, <i32 as TensorOp<T>>::Output<i32>: TensorValue, S: Shape,

type Output = Tensor<<i32 as TensorOp<T>>::Output<i32>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the % operation.

impl<T, S> Rem<&Tensor<T, S>> for i64

where i64: TensorOp<T>, T: TensorValue<Unmasked = i64>, <i64 as TensorOp<T>>::Output<i64>: TensorValue, S: Shape,

type Output = Tensor<<i64 as TensorOp<T>>::Output<i64>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the % operation.

impl<T, S> Rem<&Tensor<T, S>> for i8

where i8: TensorOp<T>, T: TensorValue<Unmasked = i8>, <i8 as TensorOp<T>>::Output<i8>: TensorValue, S: Shape,

type Output = Tensor<<i8 as TensorOp<T>>::Output<i8>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the % operation.

impl<T, S> Rem<&Tensor<T, S>> for u16

where u16: TensorOp<T>, T: TensorValue<Unmasked = u16>, <u16 as TensorOp<T>>::Output<u16>: TensorValue, S: Shape,

type Output = Tensor<<u16 as TensorOp<T>>::Output<u16>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the % operation.

impl<T, S> Rem<&Tensor<T, S>> for u32

where u32: TensorOp<T>, T: TensorValue<Unmasked = u32>, <u32 as TensorOp<T>>::Output<u32>: TensorValue, S: Shape,

type Output = Tensor<<u32 as TensorOp<T>>::Output<u32>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the % operation.

impl<T, S> Rem<&Tensor<T, S>> for u64

where u64: TensorOp<T>, T: TensorValue<Unmasked = u64>, <u64 as TensorOp<T>>::Output<u64>: TensorValue, S: Shape,

type Output = Tensor<<u64 as TensorOp<T>>::Output<u64>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the % operation.

impl<T, S> Rem<&Tensor<T, S>> for u8

where u8: TensorOp<T>, T: TensorValue<Unmasked = u8>, <u8 as TensorOp<T>>::Output<u8>: TensorValue, S: Shape,

type Output = Tensor<<u8 as TensorOp<T>>::Output<u8>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the % operation.

impl<T1, T2, S1, S2> Rem<&Tensor<T2, S2>> for &Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: Rem<T2::Unmasked>, <T1::Unmasked as Rem<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as Rem<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as Rem<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the % operator.

fn rem(self, rhs: &Tensor<T2, S2>) -> Self::Output

Performs the % operation.

impl<T1, T2, S1, S2> Rem<&Tensor<T2, S2>> for Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: Rem<T2::Unmasked>, <T1::Unmasked as Rem<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as Rem<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as Rem<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the % operator.

fn rem(self, rhs: &Tensor<T2, S2>) -> Self::Output

Performs the % operation.

impl<T, S> Rem<Tensor<T, S>> for f32

where f32: TensorOp<T>, T: TensorValue<Unmasked = f32>, <f32 as TensorOp<T>>::Output<f32>: TensorValue, S: Shape,

type Output = Tensor<<f32 as TensorOp<T>>::Output<f32>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: Tensor<T, S>) -> Self::Output

Performs the % operation.

impl<T, S> Rem<Tensor<T, S>> for f64

where f64: TensorOp<T>, T: TensorValue<Unmasked = f64>, <f64 as TensorOp<T>>::Output<f64>: TensorValue, S: Shape,

type Output = Tensor<<f64 as TensorOp<T>>::Output<f64>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: Tensor<T, S>) -> Self::Output

Performs the % operation.

impl<T, S> Rem<Tensor<T, S>> for i16

where i16: TensorOp<T>, T: TensorValue<Unmasked = i16>, <i16 as TensorOp<T>>::Output<i16>: TensorValue, S: Shape,

type Output = Tensor<<i16 as TensorOp<T>>::Output<i16>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: Tensor<T, S>) -> Self::Output

Performs the % operation.

impl<T, S> Rem<Tensor<T, S>> for i32

where i32: TensorOp<T>, T: TensorValue<Unmasked = i32>, <i32 as TensorOp<T>>::Output<i32>: TensorValue, S: Shape,

type Output = Tensor<<i32 as TensorOp<T>>::Output<i32>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: Tensor<T, S>) -> Self::Output

Performs the % operation.

impl<T, S> Rem<Tensor<T, S>> for i64

where i64: TensorOp<T>, T: TensorValue<Unmasked = i64>, <i64 as TensorOp<T>>::Output<i64>: TensorValue, S: Shape,

type Output = Tensor<<i64 as TensorOp<T>>::Output<i64>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: Tensor<T, S>) -> Self::Output

Performs the % operation.

impl<T, S> Rem<Tensor<T, S>> for i8

where i8: TensorOp<T>, T: TensorValue<Unmasked = i8>, <i8 as TensorOp<T>>::Output<i8>: TensorValue, S: Shape,

type Output = Tensor<<i8 as TensorOp<T>>::Output<i8>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: Tensor<T, S>) -> Self::Output

Performs the % operation.

impl<T, S> Rem<Tensor<T, S>> for u16

where u16: TensorOp<T>, T: TensorValue<Unmasked = u16>, <u16 as TensorOp<T>>::Output<u16>: TensorValue, S: Shape,

type Output = Tensor<<u16 as TensorOp<T>>::Output<u16>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: Tensor<T, S>) -> Self::Output

Performs the % operation.

impl<T, S> Rem<Tensor<T, S>> for u32

where u32: TensorOp<T>, T: TensorValue<Unmasked = u32>, <u32 as TensorOp<T>>::Output<u32>: TensorValue, S: Shape,

type Output = Tensor<<u32 as TensorOp<T>>::Output<u32>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: Tensor<T, S>) -> Self::Output

Performs the % operation.

impl<T, S> Rem<Tensor<T, S>> for u64

where u64: TensorOp<T>, T: TensorValue<Unmasked = u64>, <u64 as TensorOp<T>>::Output<u64>: TensorValue, S: Shape,

type Output = Tensor<<u64 as TensorOp<T>>::Output<u64>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: Tensor<T, S>) -> Self::Output

Performs the % operation.

impl<T, S> Rem<Tensor<T, S>> for u8

where u8: TensorOp<T>, T: TensorValue<Unmasked = u8>, <u8 as TensorOp<T>>::Output<u8>: TensorValue, S: Shape,

type Output = Tensor<<u8 as TensorOp<T>>::Output<u8>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: Tensor<T, S>) -> Self::Output

Performs the % operation.

impl<T1, T2, S1, S2> Rem<Tensor<T2, S2>> for &Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: Rem<T2::Unmasked>, <T1::Unmasked as Rem<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as Rem<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as Rem<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the % operator.

fn rem(self, rhs: Tensor<T2, S2>) -> Self::Output

Performs the % operation.

impl<T1, T2, S1, S2> Rem<Tensor<T2, S2>> for Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: Rem<T2::Unmasked>, <T1::Unmasked as Rem<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as Rem<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as Rem<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the % operator.

fn rem(self, rhs: Tensor<T2, S2>) -> Self::Output

Performs the % operation.

impl<T, S> Rem<f32> for &Tensor<T, S>

where T: TensorOp<f32>, T::Unmasked: Rem<f32>, <T::Unmasked as Rem<f32>>::Output: TensorValue, T::Output<<T::Unmasked as Rem<f32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<f32>>::Output<<<T as TensorValue>::Unmasked as Rem<f32>>::Output>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> Self::Output

Performs the % operation.

impl<T, S> Rem<f32> for Tensor<T, S>

where T: TensorOp<f32>, T::Unmasked: Rem<f32>, <T::Unmasked as Rem<f32>>::Output: TensorValue, T::Output<<T::Unmasked as Rem<f32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<f32>>::Output<<<T as TensorValue>::Unmasked as Rem<f32>>::Output>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> Self::Output

Performs the % operation.

impl<T, S> Rem<f64> for &Tensor<T, S>

where T: TensorOp<f64>, T::Unmasked: Rem<f64>, <T::Unmasked as Rem<f64>>::Output: TensorValue, T::Output<<T::Unmasked as Rem<f64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<f64>>::Output<<<T as TensorValue>::Unmasked as Rem<f64>>::Output>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: f64) -> Self::Output

Performs the % operation.

impl<T, S> Rem<f64> for Tensor<T, S>

where T: TensorOp<f64>, T::Unmasked: Rem<f64>, <T::Unmasked as Rem<f64>>::Output: TensorValue, T::Output<<T::Unmasked as Rem<f64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<f64>>::Output<<<T as TensorValue>::Unmasked as Rem<f64>>::Output>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: f64) -> Self::Output

Performs the % operation.

impl<T, S> Rem<i16> for &Tensor<T, S>

where T: TensorOp<i16>, T::Unmasked: Rem<i16>, <T::Unmasked as Rem<i16>>::Output: TensorValue, T::Output<<T::Unmasked as Rem<i16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i16>>::Output<<<T as TensorValue>::Unmasked as Rem<i16>>::Output>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: i16) -> Self::Output

Performs the % operation.

impl<T, S> Rem<i16> for Tensor<T, S>

where T: TensorOp<i16>, T::Unmasked: Rem<i16>, <T::Unmasked as Rem<i16>>::Output: TensorValue, T::Output<<T::Unmasked as Rem<i16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i16>>::Output<<<T as TensorValue>::Unmasked as Rem<i16>>::Output>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: i16) -> Self::Output

Performs the % operation.

impl<T, S> Rem<i32> for &Tensor<T, S>

where T: TensorOp<i32>, T::Unmasked: Rem<i32>, <T::Unmasked as Rem<i32>>::Output: TensorValue, T::Output<<T::Unmasked as Rem<i32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i32>>::Output<<<T as TensorValue>::Unmasked as Rem<i32>>::Output>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> Self::Output

Performs the % operation.

impl<T, S> Rem<i32> for Tensor<T, S>

where T: TensorOp<i32>, T::Unmasked: Rem<i32>, <T::Unmasked as Rem<i32>>::Output: TensorValue, T::Output<<T::Unmasked as Rem<i32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i32>>::Output<<<T as TensorValue>::Unmasked as Rem<i32>>::Output>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> Self::Output

Performs the % operation.

impl<T, S> Rem<i64> for &Tensor<T, S>

where T: TensorOp<i64>, T::Unmasked: Rem<i64>, <T::Unmasked as Rem<i64>>::Output: TensorValue, T::Output<<T::Unmasked as Rem<i64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i64>>::Output<<<T as TensorValue>::Unmasked as Rem<i64>>::Output>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: i64) -> Self::Output

Performs the % operation.

impl<T, S> Rem<i64> for Tensor<T, S>

where T: TensorOp<i64>, T::Unmasked: Rem<i64>, <T::Unmasked as Rem<i64>>::Output: TensorValue, T::Output<<T::Unmasked as Rem<i64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i64>>::Output<<<T as TensorValue>::Unmasked as Rem<i64>>::Output>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: i64) -> Self::Output

Performs the % operation.

impl<T, S> Rem<i8> for &Tensor<T, S>

where T: TensorOp<i8>, T::Unmasked: Rem<i8>, <T::Unmasked as Rem<i8>>::Output: TensorValue, T::Output<<T::Unmasked as Rem<i8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i8>>::Output<<<T as TensorValue>::Unmasked as Rem<i8>>::Output>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: i8) -> Self::Output

Performs the % operation.

impl<T, S> Rem<i8> for Tensor<T, S>

where T: TensorOp<i8>, T::Unmasked: Rem<i8>, <T::Unmasked as Rem<i8>>::Output: TensorValue, T::Output<<T::Unmasked as Rem<i8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i8>>::Output<<<T as TensorValue>::Unmasked as Rem<i8>>::Output>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: i8) -> Self::Output

Performs the % operation.

impl<T, S> Rem<u16> for &Tensor<T, S>

where T: TensorOp<u16>, T::Unmasked: Rem<u16>, <T::Unmasked as Rem<u16>>::Output: TensorValue, T::Output<<T::Unmasked as Rem<u16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u16>>::Output<<<T as TensorValue>::Unmasked as Rem<u16>>::Output>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: u16) -> Self::Output

Performs the % operation.

impl<T, S> Rem<u16> for Tensor<T, S>

where T: TensorOp<u16>, T::Unmasked: Rem<u16>, <T::Unmasked as Rem<u16>>::Output: TensorValue, T::Output<<T::Unmasked as Rem<u16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u16>>::Output<<<T as TensorValue>::Unmasked as Rem<u16>>::Output>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: u16) -> Self::Output

Performs the % operation.

impl<T, S> Rem<u32> for &Tensor<T, S>

where T: TensorOp<u32>, T::Unmasked: Rem<u32>, <T::Unmasked as Rem<u32>>::Output: TensorValue, T::Output<<T::Unmasked as Rem<u32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u32>>::Output<<<T as TensorValue>::Unmasked as Rem<u32>>::Output>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> Self::Output

Performs the % operation.

impl<T, S> Rem<u32> for Tensor<T, S>

where T: TensorOp<u32>, T::Unmasked: Rem<u32>, <T::Unmasked as Rem<u32>>::Output: TensorValue, T::Output<<T::Unmasked as Rem<u32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u32>>::Output<<<T as TensorValue>::Unmasked as Rem<u32>>::Output>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> Self::Output

Performs the % operation.

impl<T, S> Rem<u64> for &Tensor<T, S>

where T: TensorOp<u64>, T::Unmasked: Rem<u64>, <T::Unmasked as Rem<u64>>::Output: TensorValue, T::Output<<T::Unmasked as Rem<u64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u64>>::Output<<<T as TensorValue>::Unmasked as Rem<u64>>::Output>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: u64) -> Self::Output

Performs the % operation.

impl<T, S> Rem<u64> for Tensor<T, S>

where T: TensorOp<u64>, T::Unmasked: Rem<u64>, <T::Unmasked as Rem<u64>>::Output: TensorValue, T::Output<<T::Unmasked as Rem<u64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u64>>::Output<<<T as TensorValue>::Unmasked as Rem<u64>>::Output>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: u64) -> Self::Output

Performs the % operation.

impl<T, S> Rem<u8> for &Tensor<T, S>

where T: TensorOp<u8>, T::Unmasked: Rem<u8>, <T::Unmasked as Rem<u8>>::Output: TensorValue, T::Output<<T::Unmasked as Rem<u8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u8>>::Output<<<T as TensorValue>::Unmasked as Rem<u8>>::Output>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: u8) -> Self::Output

Performs the % operation.

impl<T, S> Rem<u8> for Tensor<T, S>

where T: TensorOp<u8>, T::Unmasked: Rem<u8>, <T::Unmasked as Rem<u8>>::Output: TensorValue, T::Output<<T::Unmasked as Rem<u8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u8>>::Output<<<T as TensorValue>::Unmasked as Rem<u8>>::Output>, S>

The resulting type after applying the % operator.

fn rem(self, rhs: u8) -> Self::Output

Performs the % operation.

impl<T, S> RowBatchBuilder<Tensor<T, S>> for TensorBuilder<T, S>

where T: TensorValue, S: Shape,

fn len(&self) -> usize

fn push(&mut self, row: Tensor<T, S>)

fn build_columns(&mut self) -> Result<Vec<ArrayRef>>

fn is_empty(&self) -> bool

fn build(&mut self, schema: Arc<Schema>) -> Result<RecordBatch, Error>

impl<T, S> RowFormat for Tensor<T, S>

where T: TensorValue, S: Shape,

const COLUMNS: usize = 1usize

type Builder = TensorBuilder<T, S>

type View = TensorRowView<T, S>

fn builder(fields: &[Arc<Field>]) -> Result<Self::Builder>

fn view( rows: usize, fields: &[Arc<Field>], arrays: &[ArrayRef], ) -> Result<Self::View>

impl<T, S> RowFormatView<Tensor<T, S>> for TensorRowView<T, S>

where T: TensorValue, S: Shape,

fn len(&self) -> usize

Returns the number of wrapped rows.

fn row(&self, i: usize) -> Tensor<T, S>

Returns the ith row.

unsafe fn row_unchecked(&self, i: usize) -> Tensor<T, S>

Returns the ith row without bounds checking.

fn is_empty(&self) -> bool

Returns true if the view contains 0 rows.

fn iter(&self) -> RowViewIter<R, Self>

Returns an iterator over the rows in this view.

impl<T, S> Sub<&Tensor<T, S>> for f32

where f32: TensorOp<T>, T: TensorValue<Unmasked = f32>, <f32 as TensorOp<T>>::Output<f32>: TensorValue, S: Shape,

type Output = Tensor<<f32 as TensorOp<T>>::Output<f32>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the - operation.

impl<T, S> Sub<&Tensor<T, S>> for f64

where f64: TensorOp<T>, T: TensorValue<Unmasked = f64>, <f64 as TensorOp<T>>::Output<f64>: TensorValue, S: Shape,

type Output = Tensor<<f64 as TensorOp<T>>::Output<f64>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the - operation.

impl<T, S> Sub<&Tensor<T, S>> for i16

where i16: TensorOp<T>, T: TensorValue<Unmasked = i16>, <i16 as TensorOp<T>>::Output<i16>: TensorValue, S: Shape,

type Output = Tensor<<i16 as TensorOp<T>>::Output<i16>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the - operation.

impl<T, S> Sub<&Tensor<T, S>> for i32

where i32: TensorOp<T>, T: TensorValue<Unmasked = i32>, <i32 as TensorOp<T>>::Output<i32>: TensorValue, S: Shape,

type Output = Tensor<<i32 as TensorOp<T>>::Output<i32>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the - operation.

impl<T, S> Sub<&Tensor<T, S>> for i64

where i64: TensorOp<T>, T: TensorValue<Unmasked = i64>, <i64 as TensorOp<T>>::Output<i64>: TensorValue, S: Shape,

type Output = Tensor<<i64 as TensorOp<T>>::Output<i64>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the - operation.

impl<T, S> Sub<&Tensor<T, S>> for i8

where i8: TensorOp<T>, T: TensorValue<Unmasked = i8>, <i8 as TensorOp<T>>::Output<i8>: TensorValue, S: Shape,

type Output = Tensor<<i8 as TensorOp<T>>::Output<i8>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the - operation.

impl<T, S> Sub<&Tensor<T, S>> for u16

where u16: TensorOp<T>, T: TensorValue<Unmasked = u16>, <u16 as TensorOp<T>>::Output<u16>: TensorValue, S: Shape,

type Output = Tensor<<u16 as TensorOp<T>>::Output<u16>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the - operation.

impl<T, S> Sub<&Tensor<T, S>> for u32

where u32: TensorOp<T>, T: TensorValue<Unmasked = u32>, <u32 as TensorOp<T>>::Output<u32>: TensorValue, S: Shape,

type Output = Tensor<<u32 as TensorOp<T>>::Output<u32>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the - operation.

impl<T, S> Sub<&Tensor<T, S>> for u64

where u64: TensorOp<T>, T: TensorValue<Unmasked = u64>, <u64 as TensorOp<T>>::Output<u64>: TensorValue, S: Shape,

type Output = Tensor<<u64 as TensorOp<T>>::Output<u64>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the - operation.

impl<T, S> Sub<&Tensor<T, S>> for u8

where u8: TensorOp<T>, T: TensorValue<Unmasked = u8>, <u8 as TensorOp<T>>::Output<u8>: TensorValue, S: Shape,

type Output = Tensor<<u8 as TensorOp<T>>::Output<u8>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor<T, S>) -> Self::Output

Performs the - operation.

impl<T1, T2, S1, S2> Sub<&Tensor<T2, S2>> for &Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: Sub<T2::Unmasked>, <T1::Unmasked as Sub<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as Sub<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as Sub<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor<T2, S2>) -> Self::Output

Performs the - operation.

impl<T1, T2, S1, S2> Sub<&Tensor<T2, S2>> for Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: Sub<T2::Unmasked>, <T1::Unmasked as Sub<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as Sub<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as Sub<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor<T2, S2>) -> Self::Output

Performs the - operation.

impl<T, S> Sub<Tensor<T, S>> for f32

where f32: TensorOp<T>, T: TensorValue<Unmasked = f32>, <f32 as TensorOp<T>>::Output<f32>: TensorValue, S: Shape,

type Output = Tensor<<f32 as TensorOp<T>>::Output<f32>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<T, S>) -> Self::Output

Performs the - operation.

impl<T, S> Sub<Tensor<T, S>> for f64

where f64: TensorOp<T>, T: TensorValue<Unmasked = f64>, <f64 as TensorOp<T>>::Output<f64>: TensorValue, S: Shape,

type Output = Tensor<<f64 as TensorOp<T>>::Output<f64>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<T, S>) -> Self::Output

Performs the - operation.

impl<T, S> Sub<Tensor<T, S>> for i16

where i16: TensorOp<T>, T: TensorValue<Unmasked = i16>, <i16 as TensorOp<T>>::Output<i16>: TensorValue, S: Shape,

type Output = Tensor<<i16 as TensorOp<T>>::Output<i16>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<T, S>) -> Self::Output

Performs the - operation.

impl<T, S> Sub<Tensor<T, S>> for i32

where i32: TensorOp<T>, T: TensorValue<Unmasked = i32>, <i32 as TensorOp<T>>::Output<i32>: TensorValue, S: Shape,

type Output = Tensor<<i32 as TensorOp<T>>::Output<i32>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<T, S>) -> Self::Output

Performs the - operation.

impl<T, S> Sub<Tensor<T, S>> for i64

where i64: TensorOp<T>, T: TensorValue<Unmasked = i64>, <i64 as TensorOp<T>>::Output<i64>: TensorValue, S: Shape,

type Output = Tensor<<i64 as TensorOp<T>>::Output<i64>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<T, S>) -> Self::Output

Performs the - operation.

impl<T, S> Sub<Tensor<T, S>> for i8

where i8: TensorOp<T>, T: TensorValue<Unmasked = i8>, <i8 as TensorOp<T>>::Output<i8>: TensorValue, S: Shape,

type Output = Tensor<<i8 as TensorOp<T>>::Output<i8>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<T, S>) -> Self::Output

Performs the - operation.

impl<T, S> Sub<Tensor<T, S>> for u16

where u16: TensorOp<T>, T: TensorValue<Unmasked = u16>, <u16 as TensorOp<T>>::Output<u16>: TensorValue, S: Shape,

type Output = Tensor<<u16 as TensorOp<T>>::Output<u16>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<T, S>) -> Self::Output

Performs the - operation.

impl<T, S> Sub<Tensor<T, S>> for u32

where u32: TensorOp<T>, T: TensorValue<Unmasked = u32>, <u32 as TensorOp<T>>::Output<u32>: TensorValue, S: Shape,

type Output = Tensor<<u32 as TensorOp<T>>::Output<u32>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<T, S>) -> Self::Output

Performs the - operation.

impl<T, S> Sub<Tensor<T, S>> for u64

where u64: TensorOp<T>, T: TensorValue<Unmasked = u64>, <u64 as TensorOp<T>>::Output<u64>: TensorValue, S: Shape,

type Output = Tensor<<u64 as TensorOp<T>>::Output<u64>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<T, S>) -> Self::Output

Performs the - operation.

impl<T, S> Sub<Tensor<T, S>> for u8

where u8: TensorOp<T>, T: TensorValue<Unmasked = u8>, <u8 as TensorOp<T>>::Output<u8>: TensorValue, S: Shape,

type Output = Tensor<<u8 as TensorOp<T>>::Output<u8>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<T, S>) -> Self::Output

Performs the - operation.

impl<T1, T2, S1, S2> Sub<Tensor<T2, S2>> for &Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: Sub<T2::Unmasked>, <T1::Unmasked as Sub<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as Sub<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as Sub<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<T2, S2>) -> Self::Output

Performs the - operation.

impl<T1, T2, S1, S2> Sub<Tensor<T2, S2>> for Tensor<T1, S1>

where T1: TensorOp<T2>, T2: TensorValue, T1::Unmasked: Sub<T2::Unmasked>, <T1::Unmasked as Sub<T2::Unmasked>>::Output: TensorValue, T1::Output<<T1::Unmasked as Sub<T2::Unmasked>>::Output>: TensorValue, S1: Shape + NdimMax<S2>, S2: Shape,

type Output = Tensor<<T1 as TensorOp<T2>>::Output<<<T1 as TensorValue>::Unmasked as Sub<<T2 as TensorValue>::Unmasked>>::Output>, <S1 as NdimMax<S2>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<T2, S2>) -> Self::Output

Performs the - operation.

impl<T, S> Sub<f32> for &Tensor<T, S>

where T: TensorOp<f32>, T::Unmasked: Sub<f32>, <T::Unmasked as Sub<f32>>::Output: TensorValue, T::Output<<T::Unmasked as Sub<f32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<f32>>::Output<<<T as TensorValue>::Unmasked as Sub<f32>>::Output>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Self::Output

Performs the - operation.

impl<T, S> Sub<f32> for Tensor<T, S>

where T: TensorOp<f32>, T::Unmasked: Sub<f32>, <T::Unmasked as Sub<f32>>::Output: TensorValue, T::Output<<T::Unmasked as Sub<f32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<f32>>::Output<<<T as TensorValue>::Unmasked as Sub<f32>>::Output>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Self::Output

Performs the - operation.

impl<T, S> Sub<f64> for &Tensor<T, S>

where T: TensorOp<f64>, T::Unmasked: Sub<f64>, <T::Unmasked as Sub<f64>>::Output: TensorValue, T::Output<<T::Unmasked as Sub<f64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<f64>>::Output<<<T as TensorValue>::Unmasked as Sub<f64>>::Output>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Performs the - operation.

impl<T, S> Sub<f64> for Tensor<T, S>

where T: TensorOp<f64>, T::Unmasked: Sub<f64>, <T::Unmasked as Sub<f64>>::Output: TensorValue, T::Output<<T::Unmasked as Sub<f64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<f64>>::Output<<<T as TensorValue>::Unmasked as Sub<f64>>::Output>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Performs the - operation.

impl<T, S> Sub<i16> for &Tensor<T, S>

where T: TensorOp<i16>, T::Unmasked: Sub<i16>, <T::Unmasked as Sub<i16>>::Output: TensorValue, T::Output<<T::Unmasked as Sub<i16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i16>>::Output<<<T as TensorValue>::Unmasked as Sub<i16>>::Output>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> Self::Output

Performs the - operation.

impl<T, S> Sub<i16> for Tensor<T, S>

where T: TensorOp<i16>, T::Unmasked: Sub<i16>, <T::Unmasked as Sub<i16>>::Output: TensorValue, T::Output<<T::Unmasked as Sub<i16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i16>>::Output<<<T as TensorValue>::Unmasked as Sub<i16>>::Output>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> Self::Output

Performs the - operation.

impl<T, S> Sub<i32> for &Tensor<T, S>

where T: TensorOp<i32>, T::Unmasked: Sub<i32>, <T::Unmasked as Sub<i32>>::Output: TensorValue, T::Output<<T::Unmasked as Sub<i32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i32>>::Output<<<T as TensorValue>::Unmasked as Sub<i32>>::Output>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl<T, S> Sub<i32> for Tensor<T, S>

where T: TensorOp<i32>, T::Unmasked: Sub<i32>, <T::Unmasked as Sub<i32>>::Output: TensorValue, T::Output<<T::Unmasked as Sub<i32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i32>>::Output<<<T as TensorValue>::Unmasked as Sub<i32>>::Output>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl<T, S> Sub<i64> for &Tensor<T, S>

where T: TensorOp<i64>, T::Unmasked: Sub<i64>, <T::Unmasked as Sub<i64>>::Output: TensorValue, T::Output<<T::Unmasked as Sub<i64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i64>>::Output<<<T as TensorValue>::Unmasked as Sub<i64>>::Output>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> Self::Output

Performs the - operation.

impl<T, S> Sub<i64> for Tensor<T, S>

where T: TensorOp<i64>, T::Unmasked: Sub<i64>, <T::Unmasked as Sub<i64>>::Output: TensorValue, T::Output<<T::Unmasked as Sub<i64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i64>>::Output<<<T as TensorValue>::Unmasked as Sub<i64>>::Output>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> Self::Output

Performs the - operation.

impl<T, S> Sub<i8> for &Tensor<T, S>

where T: TensorOp<i8>, T::Unmasked: Sub<i8>, <T::Unmasked as Sub<i8>>::Output: TensorValue, T::Output<<T::Unmasked as Sub<i8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i8>>::Output<<<T as TensorValue>::Unmasked as Sub<i8>>::Output>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> Self::Output

Performs the - operation.

impl<T, S> Sub<i8> for Tensor<T, S>

where T: TensorOp<i8>, T::Unmasked: Sub<i8>, <T::Unmasked as Sub<i8>>::Output: TensorValue, T::Output<<T::Unmasked as Sub<i8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<i8>>::Output<<<T as TensorValue>::Unmasked as Sub<i8>>::Output>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> Self::Output

Performs the - operation.

impl<T, S> Sub<u16> for &Tensor<T, S>

where T: TensorOp<u16>, T::Unmasked: Sub<u16>, <T::Unmasked as Sub<u16>>::Output: TensorValue, T::Output<<T::Unmasked as Sub<u16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u16>>::Output<<<T as TensorValue>::Unmasked as Sub<u16>>::Output>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> Self::Output

Performs the - operation.

impl<T, S> Sub<u16> for Tensor<T, S>

where T: TensorOp<u16>, T::Unmasked: Sub<u16>, <T::Unmasked as Sub<u16>>::Output: TensorValue, T::Output<<T::Unmasked as Sub<u16>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u16>>::Output<<<T as TensorValue>::Unmasked as Sub<u16>>::Output>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> Self::Output

Performs the - operation.

impl<T, S> Sub<u32> for &Tensor<T, S>

where T: TensorOp<u32>, T::Unmasked: Sub<u32>, <T::Unmasked as Sub<u32>>::Output: TensorValue, T::Output<<T::Unmasked as Sub<u32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u32>>::Output<<<T as TensorValue>::Unmasked as Sub<u32>>::Output>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self::Output

Performs the - operation.

impl<T, S> Sub<u32> for Tensor<T, S>

where T: TensorOp<u32>, T::Unmasked: Sub<u32>, <T::Unmasked as Sub<u32>>::Output: TensorValue, T::Output<<T::Unmasked as Sub<u32>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u32>>::Output<<<T as TensorValue>::Unmasked as Sub<u32>>::Output>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self::Output

Performs the - operation.

impl<T, S> Sub<u64> for &Tensor<T, S>

where T: TensorOp<u64>, T::Unmasked: Sub<u64>, <T::Unmasked as Sub<u64>>::Output: TensorValue, T::Output<<T::Unmasked as Sub<u64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u64>>::Output<<<T as TensorValue>::Unmasked as Sub<u64>>::Output>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> Self::Output

Performs the - operation.

impl<T, S> Sub<u64> for Tensor<T, S>

where T: TensorOp<u64>, T::Unmasked: Sub<u64>, <T::Unmasked as Sub<u64>>::Output: TensorValue, T::Output<<T::Unmasked as Sub<u64>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u64>>::Output<<<T as TensorValue>::Unmasked as Sub<u64>>::Output>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> Self::Output

Performs the - operation.

impl<T, S> Sub<u8> for &Tensor<T, S>

where T: TensorOp<u8>, T::Unmasked: Sub<u8>, <T::Unmasked as Sub<u8>>::Output: TensorValue, T::Output<<T::Unmasked as Sub<u8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u8>>::Output<<<T as TensorValue>::Unmasked as Sub<u8>>::Output>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> Self::Output

Performs the - operation.

impl<T, S> Sub<u8> for Tensor<T, S>

where T: TensorOp<u8>, T::Unmasked: Sub<u8>, <T::Unmasked as Sub<u8>>::Output: TensorValue, T::Output<<T::Unmasked as Sub<u8>>::Output>: TensorValue, S: Shape,

type Output = Tensor<<T as TensorOp<u8>>::Output<<<T as TensorValue>::Unmasked as Sub<u8>>::Output>, S>

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> Self::Output

Performs the - operation.