Trait caffe2_imports::Shr
1.0.0 · source · pub trait Shr<Rhs = Self> {
type Output;
// Required method
fn shr(self, rhs: Rhs) -> Self::Output;
}Expand description
The right shift operator >>. Note that because this trait is implemented
for all integer types with multiple right-hand-side types, Rust’s type
checker has special handling for _ >> _, setting the result type for
integer operations to the type of the left-hand-side operand. This means
that though a >> b and a.shr(b) are one and the same from an evaluation
standpoint, they are different when it comes to type inference.
Examples
An implementation of Shr that lifts the >> operation on integers to a
wrapper around usize.
use std::ops::Shr;
#[derive(PartialEq, Debug)]
struct Scalar(usize);
impl Shr<Scalar> for Scalar {
type Output = Self;
fn shr(self, Self(rhs): Self) -> Self::Output {
let Self(lhs) = self;
Self(lhs >> rhs)
}
}
assert_eq!(Scalar(16) >> Scalar(2), Scalar(4));An implementation of Shr that spins a vector rightward by a given amount.
use std::ops::Shr;
#[derive(PartialEq, Debug)]
struct SpinVector<T: Clone> {
vec: Vec<T>,
}
impl<T: Clone> Shr<usize> for SpinVector<T> {
type Output = Self;
fn shr(self, rhs: usize) -> Self::Output {
// Rotate the vector by `rhs` places.
let (a, b) = self.vec.split_at(self.vec.len() - rhs);
let mut spun_vector = vec![];
spun_vector.extend_from_slice(b);
spun_vector.extend_from_slice(a);
Self { vec: spun_vector }
}
}
assert_eq!(SpinVector { vec: vec![0, 1, 2, 3, 4] } >> 2,
SpinVector { vec: vec![3, 4, 0, 1, 2] });Required Associated Types§
Required Methods§
Implementors§
source§impl Shr<usize> for Saturating<i8>
impl Shr<usize> for Saturating<i8>
type Output = Saturating<i8>
source§impl Shr<usize> for Saturating<i16>
impl Shr<usize> for Saturating<i16>
type Output = Saturating<i16>
source§impl Shr<usize> for Saturating<i32>
impl Shr<usize> for Saturating<i32>
type Output = Saturating<i32>
source§impl Shr<usize> for Saturating<i64>
impl Shr<usize> for Saturating<i64>
type Output = Saturating<i64>
source§impl Shr<usize> for Saturating<i128>
impl Shr<usize> for Saturating<i128>
type Output = Saturating<i128>
source§impl Shr<usize> for Saturating<isize>
impl Shr<usize> for Saturating<isize>
type Output = Saturating<isize>
source§impl Shr<usize> for Saturating<u8>
impl Shr<usize> for Saturating<u8>
type Output = Saturating<u8>
source§impl Shr<usize> for Saturating<u16>
impl Shr<usize> for Saturating<u16>
type Output = Saturating<u16>
source§impl Shr<usize> for Saturating<u32>
impl Shr<usize> for Saturating<u32>
type Output = Saturating<u32>
source§impl Shr<usize> for Saturating<u64>
impl Shr<usize> for Saturating<u64>
type Output = Saturating<u64>
source§impl Shr<usize> for Saturating<u128>
impl Shr<usize> for Saturating<u128>
type Output = Saturating<u128>
source§impl Shr<usize> for Saturating<usize>
impl Shr<usize> for Saturating<usize>
type Output = Saturating<usize>
source§impl<'a, A, B, S, S2, D, E> Shr<&'a ArrayBase<S2, E>> for &'a ArrayBase<S, D>where
A: Clone + Shr<B, Output = A>,
B: Clone,
S: Data<Elem = A>,
S2: Data<Elem = B>,
D: Dimension + DimMax<E>,
E: Dimension,
impl<'a, A, B, S, S2, D, E> Shr<&'a ArrayBase<S2, E>> for &'a ArrayBase<S, D>where A: Clone + Shr<B, Output = A>, B: Clone, S: Data<Elem = A>, S2: Data<Elem = B>, D: Dimension + DimMax<E>, E: Dimension,
Perform elementwise
right shift
between references self and rhs,
and return the result as a new Array.
If their shapes disagree, self and rhs is broadcast to their broadcast shape,
cloning the data if needed.
Panics if broadcasting isn’t possible.
source§impl<'a, A, B, S, S2, D, E> Shr<&'a ArrayBase<S2, E>> for ArrayBase<S, D>where
A: Clone + Shr<B, Output = A>,
B: Clone,
S: DataOwned<Elem = A> + DataMut,
S2: Data<Elem = B>,
D: Dimension + DimMax<E>,
E: Dimension,
impl<'a, A, B, S, S2, D, E> Shr<&'a ArrayBase<S2, E>> for ArrayBase<S, D>where A: Clone + Shr<B, Output = A>, B: Clone, S: DataOwned<Elem = A> + DataMut, S2: Data<Elem = B>, D: Dimension + DimMax<E>, E: Dimension,
Perform elementwise
right shift
between self and reference rhs,
and return the result.
rhs must be an Array or ArcArray.
If their shapes disagree, self is broadcast to their broadcast shape,
cloning the data if needed.
Panics if broadcasting isn’t possible.
source§impl<'a, A, B, S, S2, D, E> Shr<ArrayBase<S2, E>> for &'a ArrayBase<S, D>where
A: Clone + Shr<B, Output = B>,
B: Clone,
S: Data<Elem = A>,
S2: DataOwned<Elem = B> + DataMut,
D: Dimension,
E: Dimension + DimMax<D>,
impl<'a, A, B, S, S2, D, E> Shr<ArrayBase<S2, E>> for &'a ArrayBase<S, D>where A: Clone + Shr<B, Output = B>, B: Clone, S: Data<Elem = A>, S2: DataOwned<Elem = B> + DataMut, D: Dimension, E: Dimension + DimMax<D>,
Perform elementwise
right shift
between reference self and rhs,
and return the result.
rhs must be an Array or ArcArray.
If their shapes disagree, self is broadcast to their broadcast shape,
cloning the data if needed.
Panics if broadcasting isn’t possible.
source§impl<'a, A, S, D, B> Shr<B> for &'a ArrayBase<S, D>where
A: Clone + Shr<B, Output = A>,
S: Data<Elem = A>,
D: Dimension,
B: ScalarOperand,
impl<'a, A, S, D, B> Shr<B> for &'a ArrayBase<S, D>where A: Clone + Shr<B, Output = A>, S: Data<Elem = A>, D: Dimension, B: ScalarOperand,
Perform elementwise
right shift
between the reference self and the scalar x,
and return the result as a new Array.
source§impl<'lhs, 'rhs, T, const LANES: usize> Shr<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Shr<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<'lhs, 'rhs, T, const LANES: usize> Shr<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where T: SimdElement, Simd<T, LANES>: Shr<Simd<T, LANES>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,
source§impl<A, B, S, S2, D, E> Shr<ArrayBase<S2, E>> for ArrayBase<S, D>where
A: Clone + Shr<B, Output = A>,
B: Clone,
S: DataOwned<Elem = A> + DataMut,
S2: Data<Elem = B>,
D: Dimension + DimMax<E>,
E: Dimension,
impl<A, B, S, S2, D, E> Shr<ArrayBase<S2, E>> for ArrayBase<S, D>where A: Clone + Shr<B, Output = A>, B: Clone, S: DataOwned<Elem = A> + DataMut, S2: Data<Elem = B>, D: Dimension + DimMax<E>, E: Dimension,
Perform elementwise
right shift
between self and rhs,
and return the result.
self must be an Array or ArcArray.
If their shapes disagree, self is broadcast to their broadcast shape.
Panics if broadcasting isn’t possible.
source§impl<A, S, D, B> Shr<B> for ArrayBase<S, D>where
A: Clone + Shr<B, Output = A>,
S: DataOwned<Elem = A> + DataMut,
D: Dimension,
B: ScalarOperand,
impl<A, S, D, B> Shr<B> for ArrayBase<S, D>where A: Clone + Shr<B, Output = A>, S: DataOwned<Elem = A> + DataMut, D: Dimension, B: ScalarOperand,
Perform elementwise
right shift
between self and the scalar x,
and return the result (based on self).
self must be an Array or ArcArray.
source§impl<S, D> Shr<ArrayBase<S, D>> for i16where
S: DataOwned<Elem = i16> + DataMut,
D: Dimension,
impl<S, D> Shr<ArrayBase<S, D>> for i16where S: DataOwned<Elem = i16> + DataMut, D: Dimension,
source§impl<S, D> Shr<ArrayBase<S, D>> for i32where
S: DataOwned<Elem = i32> + DataMut,
D: Dimension,
impl<S, D> Shr<ArrayBase<S, D>> for i32where S: DataOwned<Elem = i32> + DataMut, D: Dimension,
source§impl<S, D> Shr<ArrayBase<S, D>> for i64where
S: DataOwned<Elem = i64> + DataMut,
D: Dimension,
impl<S, D> Shr<ArrayBase<S, D>> for i64where S: DataOwned<Elem = i64> + DataMut, D: Dimension,
source§impl<S, D> Shr<ArrayBase<S, D>> for i128where
S: DataOwned<Elem = i128> + DataMut,
D: Dimension,
impl<S, D> Shr<ArrayBase<S, D>> for i128where S: DataOwned<Elem = i128> + DataMut, D: Dimension,
source§impl<S, D> Shr<ArrayBase<S, D>> for isizewhere
S: DataOwned<Elem = isize> + DataMut,
D: Dimension,
impl<S, D> Shr<ArrayBase<S, D>> for isizewhere S: DataOwned<Elem = isize> + DataMut, D: Dimension,
source§impl<S, D> Shr<ArrayBase<S, D>> for u16where
S: DataOwned<Elem = u16> + DataMut,
D: Dimension,
impl<S, D> Shr<ArrayBase<S, D>> for u16where S: DataOwned<Elem = u16> + DataMut, D: Dimension,
source§impl<S, D> Shr<ArrayBase<S, D>> for u32where
S: DataOwned<Elem = u32> + DataMut,
D: Dimension,
impl<S, D> Shr<ArrayBase<S, D>> for u32where S: DataOwned<Elem = u32> + DataMut, D: Dimension,
source§impl<S, D> Shr<ArrayBase<S, D>> for u64where
S: DataOwned<Elem = u64> + DataMut,
D: Dimension,
impl<S, D> Shr<ArrayBase<S, D>> for u64where S: DataOwned<Elem = u64> + DataMut, D: Dimension,
source§impl<S, D> Shr<ArrayBase<S, D>> for u128where
S: DataOwned<Elem = u128> + DataMut,
D: Dimension,
impl<S, D> Shr<ArrayBase<S, D>> for u128where S: DataOwned<Elem = u128> + DataMut, D: Dimension,
source§impl<S, D> Shr<ArrayBase<S, D>> for usizewhere
S: DataOwned<Elem = usize> + DataMut,
D: Dimension,
impl<S, D> Shr<ArrayBase<S, D>> for usizewhere S: DataOwned<Elem = usize> + DataMut, D: Dimension,
source§impl<T, const LANES: usize> Shr<&Simd<T, LANES>> for Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Shr<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Shr<&Simd<T, LANES>> for Simd<T, LANES>where T: SimdElement, Simd<T, LANES>: Shr<Simd<T, LANES>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,
source§impl<T, const LANES: usize> Shr<Simd<T, LANES>> for &Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Shr<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Shr<Simd<T, LANES>> for &Simd<T, LANES>where T: SimdElement, Simd<T, LANES>: Shr<Simd<T, LANES>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,
source§impl<U> Shr<U> for UTermwhere
U: Unsigned,
impl<U> Shr<U> for UTermwhere U: Unsigned,
Shifting right a UTerm by an unsigned integer: UTerm >> U = UTerm
source§impl<U, B> Shr<B0> for UInt<U, B>where
U: Unsigned,
B: Bit,
impl<U, B> Shr<B0> for UInt<U, B>where U: Unsigned, B: Bit,
Shifting right any unsigned by a zero bit: U >> B0 = U
source§impl<U, B> Shr<B1> for UInt<U, B>where
U: Unsigned,
B: Bit,
impl<U, B> Shr<B1> for UInt<U, B>where U: Unsigned, B: Bit,
Shifting right a UInt by a 1 bit: UInt<U, B> >> B1 = U
source§impl<U, B> Shr<UTerm> for UInt<U, B>where
U: Unsigned,
B: Bit,
impl<U, B> Shr<UTerm> for UInt<U, B>where U: Unsigned, B: Bit,
Shifting right UInt by UTerm: UInt<U, B> >> UTerm = UInt<U, B>
source§impl<U, B, Ur, Br> Shr<UInt<Ur, Br>> for UInt<U, B>where
U: Unsigned + Shr<<UInt<Ur, Br> as Sub<B1>>::Output>,
B: Bit,
Ur: Unsigned,
Br: Bit,
UInt<Ur, Br>: Sub<B1>,
impl<U, B, Ur, Br> Shr<UInt<Ur, Br>> for UInt<U, B>where U: Unsigned + Shr<<UInt<Ur, Br> as Sub<B1>>::Output>, B: Bit, Ur: Unsigned, Br: Bit, UInt<Ur, Br>: Sub<B1>,
Shifting right UInt by UInt: UInt(U, B) >> Y = U >> (Y - 1)