Trait tract_hir::internal::tract_downcast_rs::__std::ops::Shr

#[lang = "shr"]pub trait Shr<Rhs = Self> {
    type Output;
#[must_use]    pub fn shr(self, rhs: Rhs) -> Self::Output;
}

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] });

Associated Types

type Output

The resulting type after applying the >> operator.

Loading content...

Required methods

#[must_use]pub fn shr(self, rhs: Rhs) -> Self::Output

Performs the >> operation.

Examples

assert_eq!(5u8 >> 1, 2);
assert_eq!(2u8 >> 1, 1);

Loading content...

Implementations on Foreign Types

impl Shr<i32> for u128

type Output = u128

pub fn shr(self, other: i32) -> u128

impl<'a> Shr<i32> for &'a i32

type Output = <i32 as Shr<i32>>::Output

pub fn shr(self, other: i32) -> <i32 as Shr<i32>>::Output

impl<'_> Shr<&'_ i8> for u128

type Output = <u128 as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <u128 as Shr<i8>>::Output

impl<'a> Shr<i64> for &'a u16

type Output = <u16 as Shr<i64>>::Output

pub fn shr(self, other: i64) -> <u16 as Shr<i64>>::Output

impl<'_> Shr<&'_ isize> for i32

type Output = <i32 as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <i32 as Shr<isize>>::Output

impl<'a> Shr<u8> for &'a u8

type Output = <u8 as Shr<u8>>::Output

pub fn shr(self, other: u8) -> <u8 as Shr<u8>>::Output

impl<'_> Shr<&'_ usize> for u32

type Output = <u32 as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <u32 as Shr<usize>>::Output

impl<'_, '_> Shr<&'_ u128> for &'_ i128

type Output = <i128 as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <i128 as Shr<u128>>::Output

impl<'_> Shr<&'_ i16> for i32

type Output = <i32 as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <i32 as Shr<i16>>::Output

impl<'_, '_> Shr<&'_ u128> for &'_ u128

type Output = <u128 as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <u128 as Shr<u128>>::Output

impl Shr<u64> for u128

type Output = u128

pub fn shr(self, other: u64) -> u128

impl<'a> Shr<i16> for &'a i128

type Output = <i128 as Shr<i16>>::Output

pub fn shr(self, other: i16) -> <i128 as Shr<i16>>::Output

impl<'_> Shr<&'_ isize> for isize

type Output = <isize as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <isize as Shr<isize>>::Output

impl<'_, '_> Shr<&'_ i64> for &'_ usize

type Output = <usize as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <usize as Shr<i64>>::Output

impl<'_, '_> Shr<&'_ isize> for &'_ i128

type Output = <i128 as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <i128 as Shr<isize>>::Output

impl<'a> Shr<i8> for &'a i128

type Output = <i128 as Shr<i8>>::Output

pub fn shr(self, other: i8) -> <i128 as Shr<i8>>::Output

impl<'_> Shr<&'_ u128> for isize

type Output = <isize as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <isize as Shr<u128>>::Output

impl<'_, '_> Shr<&'_ u128> for &'_ i32

type Output = <i32 as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <i32 as Shr<u128>>::Output

impl<'_, '_> Shr<&'_ u32> for &'_ isize

type Output = <isize as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <isize as Shr<u32>>::Output

impl<'_> Shr<&'_ usize> for i8

type Output = <i8 as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <i8 as Shr<usize>>::Output

impl<'_, '_> Shr<&'_ usize> for &'_ u64

type Output = <u64 as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <u64 as Shr<usize>>::Output

impl Shr<isize> for i16

type Output = i16

pub fn shr(self, other: isize) -> i16

impl Shr<u32> for u8

type Output = u8

pub fn shr(self, other: u32) -> u8

impl<'_> Shr<&'_ u32> for i32

type Output = <i32 as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <i32 as Shr<u32>>::Output

impl<'_> Shr<&'_ i8> for i16

type Output = <i16 as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <i16 as Shr<i8>>::Output

impl<'_, '_> Shr<&'_ i8> for &'_ usize

type Output = <usize as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <usize as Shr<i8>>::Output

impl<'a> Shr<i8> for &'a i8

type Output = <i8 as Shr<i8>>::Output

pub fn shr(self, other: i8) -> <i8 as Shr<i8>>::Output

impl Shr<usize> for usize

type Output = usize

pub fn shr(self, other: usize) -> usize

impl<'_, '_> Shr<&'_ u16> for &'_ i64

type Output = <i64 as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <i64 as Shr<u16>>::Output

impl Shr<u16> for i16

type Output = i16

pub fn shr(self, other: u16) -> i16

impl<'_> Shr<&'_ u32> for usize

type Output = <usize as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <usize as Shr<u32>>::Output

impl Shr<i128> for u32

type Output = u32

pub fn shr(self, other: i128) -> u32

impl<'a> Shr<i32> for &'a i128

type Output = <i128 as Shr<i32>>::Output

pub fn shr(self, other: i32) -> <i128 as Shr<i32>>::Output

impl Shr<i128> for i16

type Output = i16

pub fn shr(self, other: i128) -> i16

impl<'_, '_> Shr<&'_ i16> for &'_ i16

type Output = <i16 as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <i16 as Shr<i16>>::Output

impl<'_, '_> Shr<&'_ i8> for &'_ i8

type Output = <i8 as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <i8 as Shr<i8>>::Output

impl<'a> Shr<u8> for &'a u128

type Output = <u128 as Shr<u8>>::Output

pub fn shr(self, other: u8) -> <u128 as Shr<u8>>::Output

impl<'a> Shr<i64> for &'a u8

type Output = <u8 as Shr<i64>>::Output

pub fn shr(self, other: i64) -> <u8 as Shr<i64>>::Output

impl Shr<i64> for usize

type Output = usize

pub fn shr(self, other: i64) -> usize

impl<'a> Shr<u128> for &'a u128

type Output = <u128 as Shr<u128>>::Output

pub fn shr(self, other: u128) -> <u128 as Shr<u128>>::Output

impl<'_, '_> Shr<&'_ usize> for &'_ u32

type Output = <u32 as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <u32 as Shr<usize>>::Output

impl Shr<u32> for i8

type Output = i8

pub fn shr(self, other: u32) -> i8

impl<'_, '_> Shr<&'_ u128> for &'_ u64

type Output = <u64 as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <u64 as Shr<u128>>::Output

impl<'a> Shr<i128> for &'a u32

type Output = <u32 as Shr<i128>>::Output

pub fn shr(self, other: i128) -> <u32 as Shr<i128>>::Output

impl Shr<i8> for u128

type Output = u128

pub fn shr(self, other: i8) -> u128

impl<'_, '_> Shr<&'_ i128> for &'_ u64

type Output = <u64 as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <u64 as Shr<i128>>::Output

impl Shr<u64> for i32

type Output = i32

pub fn shr(self, other: u64) -> i32

impl Shr<i8> for isize

type Output = isize

pub fn shr(self, other: i8) -> isize

impl<'_> Shr<&'_ i64> for u64

type Output = <u64 as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <u64 as Shr<i64>>::Output

impl<'a> Shr<i128> for &'a i16

type Output = <i16 as Shr<i128>>::Output

pub fn shr(self, other: i128) -> <i16 as Shr<i128>>::Output

impl<'_, '_> Shr<&'_ i32> for &'_ usize

type Output = <usize as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <usize as Shr<i32>>::Output

impl<'a> Shr<u16> for &'a i32

type Output = <i32 as Shr<u16>>::Output

pub fn shr(self, other: u16) -> <i32 as Shr<u16>>::Output

impl<'_> Shr<&'_ i128> for u32

type Output = <u32 as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <u32 as Shr<i128>>::Output

impl<'_> Shr<&'_ i128> for u8

type Output = <u8 as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <u8 as Shr<i128>>::Output

impl<'_, '_> Shr<&'_ u64> for &'_ i8

type Output = <i8 as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <i8 as Shr<u64>>::Output

impl<'_> Shr<&'_ u8> for usize

type Output = <usize as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <usize as Shr<u8>>::Output

impl<'_> Shr<&'_ i8> for i64

type Output = <i64 as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <i64 as Shr<i8>>::Output

impl<'a> Shr<usize> for &'a u16

type Output = <u16 as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <u16 as Shr<usize>>::Output

impl<'_, '_> Shr<&'_ u8> for &'_ u32

type Output = <u32 as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <u32 as Shr<u8>>::Output

impl<'_, '_> Shr<&'_ i16> for &'_ isize

type Output = <isize as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <isize as Shr<i16>>::Output

impl<'_> Shr<&'_ i128> for i16

type Output = <i16 as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <i16 as Shr<i128>>::Output

impl<'a> Shr<i8> for &'a usize

type Output = <usize as Shr<i8>>::Output

pub fn shr(self, other: i8) -> <usize as Shr<i8>>::Output

impl<'a> Shr<isize> for &'a u32

type Output = <u32 as Shr<isize>>::Output

pub fn shr(self, other: isize) -> <u32 as Shr<isize>>::Output

impl<'_> Shr<&'_ usize> for i32

type Output = <i32 as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <i32 as Shr<usize>>::Output

impl Shr<u16> for u128

type Output = u128

pub fn shr(self, other: u16) -> u128

impl Shr<i128> for isize

type Output = isize

pub fn shr(self, other: i128) -> isize

impl<'a> Shr<u128> for &'a i16

type Output = <i16 as Shr<u128>>::Output

pub fn shr(self, other: u128) -> <i16 as Shr<u128>>::Output

impl<'_, '_> Shr<&'_ i8> for &'_ i128

type Output = <i128 as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <i128 as Shr<i8>>::Output

impl<'a> Shr<isize> for &'a isize

type Output = <isize as Shr<isize>>::Output

pub fn shr(self, other: isize) -> <isize as Shr<isize>>::Output

impl<'_, '_> Shr<&'_ isize> for &'_ usize

type Output = <usize as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <usize as Shr<isize>>::Output

impl<'a> Shr<isize> for &'a u8

type Output = <u8 as Shr<isize>>::Output

pub fn shr(self, other: isize) -> <u8 as Shr<isize>>::Output

impl<'_> Shr<&'_ i8> for i32

type Output = <i32 as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <i32 as Shr<i8>>::Output

impl<'_, '_> Shr<&'_ usize> for &'_ i64

type Output = <i64 as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <i64 as Shr<usize>>::Output

impl<'_, '_> Shr<&'_ i8> for &'_ i16

type Output = <i16 as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <i16 as Shr<i8>>::Output

impl<'a> Shr<u16> for &'a u32

type Output = <u32 as Shr<u16>>::Output

pub fn shr(self, other: u16) -> <u32 as Shr<u16>>::Output

impl Shr<u8> for i8

type Output = i8

pub fn shr(self, other: u8) -> i8

impl<'_, '_> Shr<&'_ i128> for &'_ i128

type Output = <i128 as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <i128 as Shr<i128>>::Output

impl<'_> Shr<&'_ i16> for u64

type Output = <u64 as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <u64 as Shr<i16>>::Output

impl Shr<i32> for u16

type Output = u16

pub fn shr(self, other: i32) -> u16

impl<'a> Shr<i128> for &'a u64

type Output = <u64 as Shr<i128>>::Output

pub fn shr(self, other: i128) -> <u64 as Shr<i128>>::Output

impl<'_> Shr<&'_ i16> for u16

type Output = <u16 as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <u16 as Shr<i16>>::Output

impl Shr<i16> for i32

type Output = i32

pub fn shr(self, other: i16) -> i32

impl<'a> Shr<i128> for &'a i32

type Output = <i32 as Shr<i128>>::Output

pub fn shr(self, other: i128) -> <i32 as Shr<i128>>::Output

impl Shr<i32> for i16

type Output = i16

pub fn shr(self, other: i32) -> i16

impl Shr<u16> for u8

type Output = u8

pub fn shr(self, other: u16) -> u8

impl<'_, '_> Shr<&'_ u64> for &'_ u32

type Output = <u32 as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <u32 as Shr<u64>>::Output

impl<'_> Shr<&'_ u16> for usize

type Output = <usize as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <usize as Shr<u16>>::Output

impl<'_, '_> Shr<&'_ isize> for &'_ u8

type Output = <u8 as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <u8 as Shr<isize>>::Output

impl Shr<u8> for u128

type Output = u128

pub fn shr(self, other: u8) -> u128

impl<'a> Shr<i32> for &'a u32

type Output = <u32 as Shr<i32>>::Output

pub fn shr(self, other: i32) -> <u32 as Shr<i32>>::Output

impl<'_, '_> Shr<&'_ i32> for &'_ i8

type Output = <i8 as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <i8 as Shr<i32>>::Output

impl<'a> Shr<u8> for &'a usize

type Output = <usize as Shr<u8>>::Output

pub fn shr(self, other: u8) -> <usize as Shr<u8>>::Output

impl Shr<u64> for i128

type Output = i128

pub fn shr(self, other: u64) -> i128

impl<'a> Shr<u8> for &'a i16

type Output = <i16 as Shr<u8>>::Output

pub fn shr(self, other: u8) -> <i16 as Shr<u8>>::Output

impl<'_, '_> Shr<&'_ i16> for &'_ u128

type Output = <u128 as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <u128 as Shr<i16>>::Output

impl<'_, '_> Shr<&'_ u16> for &'_ u32

type Output = <u32 as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <u32 as Shr<u16>>::Output

impl<'a> Shr<i8> for &'a i32

type Output = <i32 as Shr<i8>>::Output

pub fn shr(self, other: i8) -> <i32 as Shr<i8>>::Output

impl Shr<u128> for usize

type Output = usize

pub fn shr(self, other: u128) -> usize

impl<'_> Shr<&'_ i128> for i128

type Output = <i128 as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <i128 as Shr<i128>>::Output

impl Shr<i64> for i32

type Output = i32

pub fn shr(self, other: i64) -> i32

impl<'a> Shr<isize> for &'a i16

type Output = <i16 as Shr<isize>>::Output

pub fn shr(self, other: isize) -> <i16 as Shr<isize>>::Output

impl<'_, '_> Shr<&'_ i64> for &'_ i64

type Output = <i64 as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <i64 as Shr<i64>>::Output

impl Shr<u16> for i8

type Output = i8

pub fn shr(self, other: u16) -> i8

impl<'_> Shr<&'_ usize> for usize

type Output = <usize as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <usize as Shr<usize>>::Output

impl<'_> Shr<&'_ u16> for i128

type Output = <i128 as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <i128 as Shr<u16>>::Output

impl<'_> Shr<&'_ u8> for isize

type Output = <isize as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <isize as Shr<u8>>::Output

impl Shr<u64> for u16

type Output = u16

pub fn shr(self, other: u64) -> u16

impl<'_, '_> Shr<&'_ isize> for &'_ isize

type Output = <isize as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <isize as Shr<isize>>::Output

impl<'_, '_> Shr<&'_ u16> for &'_ i16

type Output = <i16 as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <i16 as Shr<u16>>::Output

impl<'_, '_> Shr<&'_ isize> for &'_ u128

type Output = <u128 as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <u128 as Shr<isize>>::Output

impl<'a> Shr<i32> for &'a u128

type Output = <u128 as Shr<i32>>::Output

pub fn shr(self, other: i32) -> <u128 as Shr<i32>>::Output

impl<'_, '_> Shr<&'_ i8> for &'_ i32

type Output = <i32 as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <i32 as Shr<i8>>::Output

impl Shr<i128> for u16

type Output = u16

pub fn shr(self, other: i128) -> u16

impl<'a> Shr<u8> for &'a i128

type Output = <i128 as Shr<u8>>::Output

pub fn shr(self, other: u8) -> <i128 as Shr<u8>>::Output

impl<'a> Shr<u16> for &'a isize

type Output = <isize as Shr<u16>>::Output

pub fn shr(self, other: u16) -> <isize as Shr<u16>>::Output

impl<'_, '_> Shr<&'_ u128> for &'_ isize

type Output = <isize as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <isize as Shr<u128>>::Output

impl<'a> Shr<i8> for &'a i16

type Output = <i16 as Shr<i8>>::Output

pub fn shr(self, other: i8) -> <i16 as Shr<i8>>::Output

impl<'_> Shr<&'_ u128> for u64

type Output = <u64 as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <u64 as Shr<u128>>::Output

impl<'_> Shr<&'_ u128> for i16

type Output = <i16 as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <i16 as Shr<u128>>::Output

impl<'_> Shr<&'_ u64> for i16

type Output = <i16 as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <i16 as Shr<u64>>::Output

impl<'a> Shr<u64> for &'a u16

type Output = <u16 as Shr<u64>>::Output

pub fn shr(self, other: u64) -> <u16 as Shr<u64>>::Output

impl<'_, '_> Shr<&'_ i32> for &'_ u8

type Output = <u8 as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <u8 as Shr<i32>>::Output

impl Shr<i8> for i8

type Output = i8

pub fn shr(self, other: i8) -> i8

impl Shr<i16> for u8

type Output = u8

pub fn shr(self, other: i16) -> u8

impl<'a> Shr<i32> for &'a i8

type Output = <i8 as Shr<i32>>::Output

pub fn shr(self, other: i32) -> <i8 as Shr<i32>>::Output

impl<'_, '_> Shr<&'_ i16> for &'_ u8

type Output = <u8 as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <u8 as Shr<i16>>::Output

impl Shr<u32> for isize

type Output = isize

pub fn shr(self, other: u32) -> isize

impl Shr<i32> for usize

type Output = usize

pub fn shr(self, other: i32) -> usize

impl<'_> Shr<&'_ u16> for u32

type Output = <u32 as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <u32 as Shr<u16>>::Output

impl<'_> Shr<&'_ usize> for u64

type Output = <u64 as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <u64 as Shr<usize>>::Output

impl<'_, '_> Shr<&'_ u128> for &'_ i16

type Output = <i16 as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <i16 as Shr<u128>>::Output

impl<'a> Shr<u128> for &'a isize

type Output = <isize as Shr<u128>>::Output

pub fn shr(self, other: u128) -> <isize as Shr<u128>>::Output

impl<'a> Shr<i16> for &'a i32

type Output = <i32 as Shr<i16>>::Output

pub fn shr(self, other: i16) -> <i32 as Shr<i16>>::Output

impl Shr<u32> for i64

type Output = i64

pub fn shr(self, other: u32) -> i64

impl<'a> Shr<i16> for &'a u16

type Output = <u16 as Shr<i16>>::Output

pub fn shr(self, other: i16) -> <u16 as Shr<i16>>::Output

impl<'_> Shr<&'_ usize> for i64

type Output = <i64 as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <i64 as Shr<usize>>::Output

impl<'_> Shr<&'_ u8> for u128

type Output = <u128 as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <u128 as Shr<u8>>::Output

impl<'_> Shr<&'_ usize> for i16

type Output = <i16 as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <i16 as Shr<usize>>::Output

impl<'_> Shr<&'_ u64> for i32

type Output = <i32 as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <i32 as Shr<u64>>::Output

impl<'a> Shr<i16> for &'a u32

type Output = <u32 as Shr<i16>>::Output

pub fn shr(self, other: i16) -> <u32 as Shr<i16>>::Output

impl<'a> Shr<u32> for &'a u128

type Output = <u128 as Shr<u32>>::Output

pub fn shr(self, other: u32) -> <u128 as Shr<u32>>::Output

impl<'a> Shr<i8> for &'a u8

type Output = <u8 as Shr<i8>>::Output

pub fn shr(self, other: i8) -> <u8 as Shr<i8>>::Output

impl Shr<i8> for usize

type Output = usize

pub fn shr(self, other: i8) -> usize

impl Shr<isize> for u128

type Output = u128

pub fn shr(self, other: isize) -> u128

impl<'_> Shr<&'_ u32> for u32

type Output = <u32 as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <u32 as Shr<u32>>::Output

impl<'a> Shr<i16> for &'a usize

type Output = <usize as Shr<i16>>::Output

pub fn shr(self, other: i16) -> <usize as Shr<i16>>::Output

impl<'_, '_> Shr<&'_ u8> for &'_ usize

type Output = <usize as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <usize as Shr<u8>>::Output

impl<'_> Shr<&'_ i64> for u16

type Output = <u16 as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <u16 as Shr<i64>>::Output

impl<'a> Shr<i64> for &'a i8

type Output = <i8 as Shr<i64>>::Output

pub fn shr(self, other: i64) -> <i8 as Shr<i64>>::Output

impl<'_> Shr<&'_ u8> for u64

type Output = <u64 as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <u64 as Shr<u8>>::Output

impl<'a> Shr<i128> for &'a u8

type Output = <u8 as Shr<i128>>::Output

pub fn shr(self, other: i128) -> <u8 as Shr<i128>>::Output

impl<'_, '_> Shr<&'_ i32> for &'_ isize

type Output = <isize as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <isize as Shr<i32>>::Output

impl<'_, '_> Shr<&'_ u8> for &'_ i8

type Output = <i8 as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <i8 as Shr<u8>>::Output

impl Shr<i8> for u64

type Output = u64

pub fn shr(self, other: i8) -> u64

impl<'_> Shr<&'_ u64> for i128

type Output = <i128 as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <i128 as Shr<u64>>::Output

impl<'_> Shr<&'_ u16> for u128

type Output = <u128 as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <u128 as Shr<u16>>::Output

impl<'_, '_> Shr<&'_ i16> for &'_ i8

type Output = <i8 as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <i8 as Shr<i16>>::Output

impl<'_> Shr<&'_ u16> for u16

type Output = <u16 as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <u16 as Shr<u16>>::Output

impl<'_, '_> Shr<&'_ i128> for &'_ i16

type Output = <i16 as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <i16 as Shr<i128>>::Output

impl<'_, '_> Shr<&'_ i16> for &'_ u64

type Output = <u64 as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <u64 as Shr<i16>>::Output

impl Shr<u16> for u32

type Output = u32

pub fn shr(self, other: u16) -> u32

impl<'a> Shr<u16> for &'a u64

type Output = <u64 as Shr<u16>>::Output

pub fn shr(self, other: u16) -> <u64 as Shr<u16>>::Output

impl Shr<u128> for u16

type Output = u16

pub fn shr(self, other: u128) -> u16

impl<'a> Shr<i32> for &'a usize

type Output = <usize as Shr<i32>>::Output

pub fn shr(self, other: i32) -> <usize as Shr<i32>>::Output

impl<'_, '_> Shr<&'_ i128> for &'_ u8

type Output = <u8 as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <u8 as Shr<i128>>::Output

impl<'_, '_> Shr<&'_ i8> for &'_ isize

type Output = <isize as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <isize as Shr<i8>>::Output

impl<'_> Shr<&'_ u32> for i64

type Output = <i64 as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <i64 as Shr<u32>>::Output

impl<'_> Shr<&'_ i16> for u128

type Output = <u128 as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <u128 as Shr<i16>>::Output

impl<'_> Shr<&'_ i64> for i8

type Output = <i8 as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <i8 as Shr<i64>>::Output

impl Shr<usize> for i8

type Output = i8

pub fn shr(self, other: usize) -> i8

impl<'_> Shr<&'_ usize> for isize

type Output = <isize as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <isize as Shr<usize>>::Output

impl<'a> Shr<i32> for &'a u8

type Output = <u8 as Shr<i32>>::Output

pub fn shr(self, other: i32) -> <u8 as Shr<i32>>::Output

impl<'_, '_> Shr<&'_ u8> for &'_ i64

type Output = <i64 as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <i64 as Shr<u8>>::Output

impl<'_> Shr<&'_ i8> for u32

type Output = <u32 as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <u32 as Shr<i8>>::Output

impl<'a> Shr<u64> for &'a i128

type Output = <i128 as Shr<u64>>::Output

pub fn shr(self, other: u64) -> <i128 as Shr<u64>>::Output

impl<'a> Shr<i128> for &'a i128

type Output = <i128 as Shr<i128>>::Output

pub fn shr(self, other: i128) -> <i128 as Shr<i128>>::Output

impl<'_> Shr<&'_ i32> for i32

type Output = <i32 as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <i32 as Shr<i32>>::Output

impl Shr<usize> for u32

type Output = u32

pub fn shr(self, other: usize) -> u32

impl<'a> Shr<i32> for &'a i16

type Output = <i16 as Shr<i32>>::Output

pub fn shr(self, other: i32) -> <i16 as Shr<i32>>::Output

impl<'_, '_> Shr<&'_ i8> for &'_ u128

type Output = <u128 as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <u128 as Shr<i8>>::Output

impl Shr<u128> for u128

type Output = u128

pub fn shr(self, other: u128) -> u128

impl<'_, '_> Shr<&'_ i16> for &'_ i32

type Output = <i32 as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <i32 as Shr<i16>>::Output

impl Shr<u64> for usize

type Output = usize

pub fn shr(self, other: u64) -> usize

impl<'a> Shr<u128> for &'a u8

type Output = <u8 as Shr<u128>>::Output

pub fn shr(self, other: u128) -> <u8 as Shr<u128>>::Output

impl<'a> Shr<u8> for &'a i8

type Output = <i8 as Shr<u8>>::Output

pub fn shr(self, other: u8) -> <i8 as Shr<u8>>::Output

impl<'_, '_> Shr<&'_ u64> for &'_ i64

type Output = <i64 as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <i64 as Shr<u64>>::Output

impl<'_, '_> Shr<&'_ i8> for &'_ u32

type Output = <u32 as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <u32 as Shr<i8>>::Output

impl Shr<u8> for usize

type Output = usize

pub fn shr(self, other: u8) -> usize

impl<'a> Shr<usize> for &'a i128

type Output = <i128 as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <i128 as Shr<usize>>::Output

impl<'a> Shr<u32> for &'a i16

type Output = <i16 as Shr<u32>>::Output

pub fn shr(self, other: u32) -> <i16 as Shr<u32>>::Output

impl Shr<u64> for u64

type Output = u64

pub fn shr(self, other: u64) -> u64

impl<'_, '_> Shr<&'_ u32> for &'_ usize

type Output = <usize as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <usize as Shr<u32>>::Output

impl<'_> Shr<&'_ usize> for u128

type Output = <u128 as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <u128 as Shr<usize>>::Output

impl<'_> Shr<&'_ u32> for i128

type Output = <i128 as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <i128 as Shr<u32>>::Output

impl<'_> Shr<&'_ i128> for isize

type Output = <isize as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <isize as Shr<i128>>::Output

impl<'a> Shr<i64> for &'a u32

type Output = <u32 as Shr<i64>>::Output

pub fn shr(self, other: i64) -> <u32 as Shr<i64>>::Output

impl<'a> Shr<u32> for &'a i8

type Output = <i8 as Shr<u32>>::Output

pub fn shr(self, other: u32) -> <i8 as Shr<u32>>::Output

impl<'a> Shr<u128> for &'a u32

type Output = <u32 as Shr<u128>>::Output

pub fn shr(self, other: u128) -> <u32 as Shr<u128>>::Output

impl Shr<i16> for u128

type Output = u128

pub fn shr(self, other: i16) -> u128

impl<'_> Shr<&'_ i128> for u128

type Output = <u128 as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <u128 as Shr<i128>>::Output

impl<'a> Shr<u64> for &'a i32

type Output = <i32 as Shr<u64>>::Output

pub fn shr(self, other: u64) -> <i32 as Shr<u64>>::Output

impl<'_, '_> Shr<&'_ u32> for &'_ i16

type Output = <i16 as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <i16 as Shr<u32>>::Output

impl<'_, '_> Shr<&'_ i64> for &'_ u64

type Output = <u64 as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <u64 as Shr<i64>>::Output

impl<'_, '_> Shr<&'_ i8> for &'_ u64

type Output = <u64 as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <u64 as Shr<i8>>::Output

impl Shr<u16> for u16

type Output = u16

pub fn shr(self, other: u16) -> u16

impl Shr<isize> for i64

type Output = i64

pub fn shr(self, other: isize) -> i64

impl Shr<i8> for u8

type Output = u8

pub fn shr(self, other: i8) -> u8

impl Shr<i8> for i64

type Output = i64

pub fn shr(self, other: i8) -> i64

impl<'_> Shr<&'_ i8> for u64

type Output = <u64 as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <u64 as Shr<i8>>::Output

impl<'_> Shr<&'_ u32> for u64

type Output = <u64 as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <u64 as Shr<u32>>::Output

impl<'a> Shr<isize> for &'a i64

type Output = <i64 as Shr<isize>>::Output

pub fn shr(self, other: isize) -> <i64 as Shr<isize>>::Output

impl Shr<u16> for i128

type Output = i128

pub fn shr(self, other: u16) -> i128

impl<'_, '_> Shr<&'_ u16> for &'_ i32

type Output = <i32 as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <i32 as Shr<u16>>::Output

impl<'_> Shr<&'_ i32> for i64

type Output = <i64 as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <i64 as Shr<i32>>::Output

impl Shr<u128> for isize

type Output = isize

pub fn shr(self, other: u128) -> isize

impl Shr<i128> for i8

type Output = i8

pub fn shr(self, other: i128) -> i8

impl<'_, '_> Shr<&'_ i8> for &'_ u8

type Output = <u8 as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <u8 as Shr<i8>>::Output

impl<'a> Shr<i8> for &'a isize

type Output = <isize as Shr<i8>>::Output

pub fn shr(self, other: i8) -> <isize as Shr<i8>>::Output

impl<'_> Shr<&'_ u32> for isize

type Output = <isize as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <isize as Shr<u32>>::Output

impl Shr<i16> for isize

type Output = isize

pub fn shr(self, other: i16) -> isize

impl<'_, '_> Shr<&'_ u64> for &'_ usize

type Output = <usize as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <usize as Shr<u64>>::Output

impl<'_> Shr<&'_ i16> for i128

type Output = <i128 as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <i128 as Shr<i16>>::Output

impl Shr<i16> for u32

type Output = u32

pub fn shr(self, other: i16) -> u32

impl<'a> Shr<u128> for &'a i128

type Output = <i128 as Shr<u128>>::Output

pub fn shr(self, other: u128) -> <i128 as Shr<u128>>::Output

impl<'_, '_> Shr<&'_ u8> for &'_ i16

type Output = <i16 as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <i16 as Shr<u8>>::Output

impl<'_, '_> Shr<&'_ u64> for &'_ isize

type Output = <isize as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <isize as Shr<u64>>::Output

impl<'_, '_> Shr<&'_ i16> for &'_ i64

type Output = <i64 as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <i64 as Shr<i16>>::Output

impl<'_> Shr<&'_ i8> for isize

type Output = <isize as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <isize as Shr<i8>>::Output

impl<'_> Shr<&'_ i8> for usize

type Output = <usize as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <usize as Shr<i8>>::Output

impl<'_> Shr<&'_ usize> for u8

type Output = <u8 as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <u8 as Shr<usize>>::Output

impl<'a> Shr<u64> for &'a i64

type Output = <i64 as Shr<u64>>::Output

pub fn shr(self, other: u64) -> <i64 as Shr<u64>>::Output

impl Shr<i32> for isize

type Output = isize

pub fn shr(self, other: i32) -> isize

impl<'a> Shr<u64> for &'a isize

type Output = <isize as Shr<u64>>::Output

pub fn shr(self, other: u64) -> <isize as Shr<u64>>::Output

impl<'a> Shr<i128> for &'a u128

type Output = <u128 as Shr<i128>>::Output

pub fn shr(self, other: i128) -> <u128 as Shr<i128>>::Output

impl<'a> Shr<u128> for &'a i32

type Output = <i32 as Shr<u128>>::Output

pub fn shr(self, other: u128) -> <i32 as Shr<u128>>::Output

impl<'a> Shr<u16> for &'a i64

type Output = <i64 as Shr<u16>>::Output

pub fn shr(self, other: u16) -> <i64 as Shr<u16>>::Output

impl<'a> Shr<u16> for &'a i16

type Output = <i16 as Shr<u16>>::Output

pub fn shr(self, other: u16) -> <i16 as Shr<u16>>::Output

impl<'_, '_> Shr<&'_ i32> for &'_ i16

type Output = <i16 as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <i16 as Shr<i32>>::Output

impl<'a> Shr<isize> for &'a u128

type Output = <u128 as Shr<isize>>::Output

pub fn shr(self, other: isize) -> <u128 as Shr<isize>>::Output

impl Shr<u8> for i32

type Output = i32

pub fn shr(self, other: u8) -> i32

impl<'a> Shr<usize> for &'a i8

type Output = <i8 as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <i8 as Shr<usize>>::Output

impl Shr<u32> for u128

type Output = u128

pub fn shr(self, other: u32) -> u128

impl<'_, '_> Shr<&'_ i128> for &'_ u16

type Output = <u16 as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <u16 as Shr<i128>>::Output

impl<'a> Shr<u32> for &'a i32

type Output = <i32 as Shr<u32>>::Output

pub fn shr(self, other: u32) -> <i32 as Shr<u32>>::Output

impl<'_> Shr<&'_ isize> for u128

type Output = <u128 as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <u128 as Shr<isize>>::Output

impl<'a> Shr<i32> for &'a u16

type Output = <u16 as Shr<i32>>::Output

pub fn shr(self, other: i32) -> <u16 as Shr<i32>>::Output

impl<'_, '_> Shr<&'_ u16> for &'_ u16

type Output = <u16 as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <u16 as Shr<u16>>::Output

impl<'_> Shr<&'_ i16> for i16

type Output = <i16 as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <i16 as Shr<i16>>::Output

impl Shr<usize> for isize

type Output = isize

pub fn shr(self, other: usize) -> isize

impl<'_, '_> Shr<&'_ isize> for &'_ u64

type Output = <u64 as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <u64 as Shr<isize>>::Output

impl<'_, '_> Shr<&'_ u16> for &'_ usize

type Output = <usize as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <usize as Shr<u16>>::Output

impl<'_> Shr<&'_ i128> for i64

type Output = <i64 as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <i64 as Shr<i128>>::Output

impl Shr<i32> for i128

type Output = i128

pub fn shr(self, other: i32) -> i128

impl Shr<i8> for i128

type Output = i128

pub fn shr(self, other: i8) -> i128

impl Shr<usize> for i16

type Output = i16

pub fn shr(self, other: usize) -> i16

impl Shr<i64> for u8

type Output = u8

pub fn shr(self, other: i64) -> u8

impl<'a> Shr<i8> for &'a i64

type Output = <i64 as Shr<i8>>::Output

pub fn shr(self, other: i8) -> <i64 as Shr<i8>>::Output

impl<'_> Shr<&'_ i32> for u32

type Output = <u32 as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <u32 as Shr<i32>>::Output

impl Shr<i8> for i16

type Output = i16

pub fn shr(self, other: i8) -> i16

impl<'_, '_> Shr<&'_ usize> for &'_ u16

type Output = <u16 as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <u16 as Shr<usize>>::Output

impl Shr<i64> for i128

type Output = i128

pub fn shr(self, other: i64) -> i128

impl<'_, '_> Shr<&'_ u32> for &'_ i64

type Output = <i64 as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <i64 as Shr<u32>>::Output

impl<'_, '_> Shr<&'_ u128> for &'_ usize

type Output = <usize as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <usize as Shr<u128>>::Output

impl<'_> Shr<&'_ isize> for u32

type Output = <u32 as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <u32 as Shr<isize>>::Output

impl<'a> Shr<u16> for &'a u128

type Output = <u128 as Shr<u16>>::Output

pub fn shr(self, other: u16) -> <u128 as Shr<u16>>::Output

impl<'a> Shr<u128> for &'a i64

type Output = <i64 as Shr<u128>>::Output

pub fn shr(self, other: u128) -> <i64 as Shr<u128>>::Output

impl<'a> Shr<u128> for &'a u64

type Output = <u64 as Shr<u128>>::Output

pub fn shr(self, other: u128) -> <u64 as Shr<u128>>::Output

impl<'_> Shr<&'_ i64> for usize

type Output = <usize as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <usize as Shr<i64>>::Output

impl<'_, '_> Shr<&'_ i128> for &'_ i32

type Output = <i32 as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <i32 as Shr<i128>>::Output

impl<'_> Shr<&'_ i64> for i64

type Output = <i64 as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <i64 as Shr<i64>>::Output

impl Shr<i32> for i32

type Output = i32

pub fn shr(self, other: i32) -> i32

impl Shr<u16> for usize

type Output = usize

pub fn shr(self, other: u16) -> usize

impl<'a> Shr<u16> for &'a i128

type Output = <i128 as Shr<u16>>::Output

pub fn shr(self, other: u16) -> <i128 as Shr<u16>>::Output

impl<'_, '_> Shr<&'_ u16> for &'_ u8

type Output = <u8 as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <u8 as Shr<u16>>::Output

impl<'_> Shr<&'_ i32> for u128

type Output = <u128 as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <u128 as Shr<i32>>::Output

impl Shr<i32> for u8

type Output = u8

pub fn shr(self, other: i32) -> u8

impl<'a> Shr<i16> for &'a u64

type Output = <u64 as Shr<i16>>::Output

pub fn shr(self, other: i16) -> <u64 as Shr<i16>>::Output

impl Shr<i128> for i64

type Output = i64

pub fn shr(self, other: i128) -> i64

impl Shr<u8> for i16

type Output = i16

pub fn shr(self, other: u8) -> i16

impl<'_, '_> Shr<&'_ u32> for &'_ u32

type Output = <u32 as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <u32 as Shr<u32>>::Output

impl<'a> Shr<usize> for &'a u64

type Output = <u64 as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <u64 as Shr<usize>>::Output

impl<'_, '_> Shr<&'_ i8> for &'_ i64

type Output = <i64 as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <i64 as Shr<i8>>::Output

impl<'_> Shr<&'_ isize> for i16

type Output = <i16 as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <i16 as Shr<isize>>::Output

impl<'a> Shr<u32> for &'a i128

type Output = <i128 as Shr<u32>>::Output

pub fn shr(self, other: u32) -> <i128 as Shr<u32>>::Output

impl<'a> Shr<u128> for &'a u16

type Output = <u16 as Shr<u128>>::Output

pub fn shr(self, other: u128) -> <u16 as Shr<u128>>::Output

impl<'a> Shr<u32> for &'a usize

type Output = <usize as Shr<u32>>::Output

pub fn shr(self, other: u32) -> <usize as Shr<u32>>::Output

impl<'_> Shr<&'_ i64> for i16

type Output = <i16 as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <i16 as Shr<i64>>::Output

impl<'_, '_> Shr<&'_ u8> for &'_ i32

type Output = <i32 as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <i32 as Shr<u8>>::Output

impl Shr<u64> for u8

type Output = u8

pub fn shr(self, other: u64) -> u8

impl<'_> Shr<&'_ u8> for i16

type Output = <i16 as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <i16 as Shr<u8>>::Output

impl<'a> Shr<i32> for &'a i64

type Output = <i64 as Shr<i32>>::Output

pub fn shr(self, other: i32) -> <i64 as Shr<i32>>::Output

impl<'a> Shr<i64> for &'a isize

type Output = <isize as Shr<i64>>::Output

pub fn shr(self, other: i64) -> <isize as Shr<i64>>::Output

impl Shr<i64> for i8

type Output = i8

pub fn shr(self, other: i64) -> i8

impl Shr<i64> for isize

type Output = isize

pub fn shr(self, other: i64) -> isize

impl<'_> Shr<&'_ u128> for i32

type Output = <i32 as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <i32 as Shr<u128>>::Output

impl<'_> Shr<&'_ u64> for u32

type Output = <u32 as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <u32 as Shr<u64>>::Output

impl<'_, '_> Shr<&'_ i64> for &'_ u8

type Output = <u8 as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <u8 as Shr<i64>>::Output

impl Shr<isize> for u64

type Output = u64

pub fn shr(self, other: isize) -> u64

impl Shr<isize> for u8

type Output = u8

pub fn shr(self, other: isize) -> u8

impl<'_, '_> Shr<&'_ u8> for &'_ u64

type Output = <u64 as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <u64 as Shr<u8>>::Output

impl<'_, '_> Shr<&'_ u8> for &'_ u128

type Output = <u128 as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <u128 as Shr<u8>>::Output

impl<'_> Shr<&'_ u128> for i8

type Output = <i8 as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <i8 as Shr<u128>>::Output

impl Shr<i32> for u32

type Output = u32

pub fn shr(self, other: i32) -> u32

impl<'_, '_> Shr<&'_ usize> for &'_ u128

type Output = <u128 as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <u128 as Shr<usize>>::Output

impl<'a> Shr<u64> for &'a u8

type Output = <u8 as Shr<u64>>::Output

pub fn shr(self, other: u64) -> <u8 as Shr<u64>>::Output

impl Shr<u16> for isize

type Output = isize

pub fn shr(self, other: u16) -> isize

impl<'_, '_> Shr<&'_ usize> for &'_ usize

type Output = <usize as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <usize as Shr<usize>>::Output

impl<'_> Shr<&'_ u8> for u16

type Output = <u16 as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <u16 as Shr<u8>>::Output

impl<'_, '_> Shr<&'_ u16> for &'_ i8

type Output = <i8 as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <i8 as Shr<u16>>::Output

impl<'_> Shr<&'_ i32> for usize

type Output = <usize as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <usize as Shr<i32>>::Output

impl Shr<i128> for usize

type Output = usize

pub fn shr(self, other: i128) -> usize

impl<'a> Shr<isize> for &'a i128

type Output = <i128 as Shr<isize>>::Output

pub fn shr(self, other: isize) -> <i128 as Shr<isize>>::Output

impl<'a> Shr<u16> for &'a u16

type Output = <u16 as Shr<u16>>::Output

pub fn shr(self, other: u16) -> <u16 as Shr<u16>>::Output

impl<'a> Shr<u8> for &'a u32

type Output = <u32 as Shr<u8>>::Output

pub fn shr(self, other: u8) -> <u32 as Shr<u8>>::Output

impl<'_> Shr<&'_ u64> for u16

type Output = <u16 as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <u16 as Shr<u64>>::Output

impl<'a> Shr<i128> for &'a u16

type Output = <u16 as Shr<i128>>::Output

pub fn shr(self, other: i128) -> <u16 as Shr<i128>>::Output

impl<'_> Shr<&'_ u16> for i8

type Output = <i8 as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <i8 as Shr<u16>>::Output

impl<'a> Shr<i64> for &'a u128

type Output = <u128 as Shr<i64>>::Output

pub fn shr(self, other: i64) -> <u128 as Shr<i64>>::Output

impl Shr<u8> for u16

type Output = u16

pub fn shr(self, other: u8) -> u16

impl Shr<i64> for u128

type Output = u128

pub fn shr(self, other: i64) -> u128

impl<'_> Shr<&'_ isize> for usize

type Output = <usize as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <usize as Shr<isize>>::Output

impl Shr<u128> for i32

type Output = i32

pub fn shr(self, other: u128) -> i32

impl Shr<i32> for i64

type Output = i64

pub fn shr(self, other: i32) -> i64

impl<'a> Shr<i16> for &'a u128

type Output = <u128 as Shr<i16>>::Output

pub fn shr(self, other: i16) -> <u128 as Shr<i16>>::Output

impl Shr<u16> for i64

type Output = i64

pub fn shr(self, other: u16) -> i64

impl Shr<u32> for i32

type Output = i32

pub fn shr(self, other: u32) -> i32

impl<'_> Shr<&'_ i128> for usize

type Output = <usize as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <usize as Shr<i128>>::Output

impl Shr<u16> for i32

type Output = i32

pub fn shr(self, other: u16) -> i32

impl<'a> Shr<usize> for &'a i64

type Output = <i64 as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <i64 as Shr<usize>>::Output

impl<'_, '_> Shr<&'_ u16> for &'_ u64

type Output = <u64 as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <u64 as Shr<u16>>::Output

impl<'_, '_> Shr<&'_ isize> for &'_ i16

type Output = <i16 as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <i16 as Shr<isize>>::Output

impl Shr<i32> for i8

type Output = i8

pub fn shr(self, other: i32) -> i8

impl Shr<usize> for u128

type Output = u128

pub fn shr(self, other: usize) -> u128

impl<'_, '_> Shr<&'_ u32> for &'_ u128

type Output = <u128 as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <u128 as Shr<u32>>::Output

impl<'_, '_> Shr<&'_ i32> for &'_ i64

type Output = <i64 as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <i64 as Shr<i32>>::Output

impl<'a> Shr<i64> for &'a i16

type Output = <i16 as Shr<i64>>::Output

pub fn shr(self, other: i64) -> <i16 as Shr<i64>>::Output

impl<'_> Shr<&'_ i32> for i128

type Output = <i128 as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <i128 as Shr<i32>>::Output

impl Shr<u128> for i16

type Output = i16

pub fn shr(self, other: u128) -> i16

impl Shr<u128> for i8

type Output = i8

pub fn shr(self, other: u128) -> i8

impl Shr<u64> for i16

type Output = i16

pub fn shr(self, other: u64) -> i16

impl<'_> Shr<&'_ u64> for u8

type Output = <u8 as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <u8 as Shr<u64>>::Output

impl<'_, '_> Shr<&'_ usize> for &'_ i8

type Output = <i8 as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <i8 as Shr<usize>>::Output

impl<'a> Shr<isize> for &'a i32

type Output = <i32 as Shr<isize>>::Output

pub fn shr(self, other: isize) -> <i32 as Shr<isize>>::Output

impl<'_, '_> Shr<&'_ i32> for &'_ i128

type Output = <i128 as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <i128 as Shr<i32>>::Output

impl<'_, '_> Shr<&'_ u128> for &'_ u32

type Output = <u32 as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <u32 as Shr<u128>>::Output

impl Shr<u128> for i128

type Output = i128

pub fn shr(self, other: u128) -> i128

impl Shr<u8> for isize

type Output = isize

pub fn shr(self, other: u8) -> isize

impl<'a> Shr<i8> for &'a u128

type Output = <u128 as Shr<i8>>::Output

pub fn shr(self, other: i8) -> <u128 as Shr<i8>>::Output

impl<'_, '_> Shr<&'_ isize> for &'_ i8

type Output = <i8 as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <i8 as Shr<isize>>::Output

impl Shr<isize> for i8

type Output = i8

pub fn shr(self, other: isize) -> i8

impl<'_> Shr<&'_ u16> for u64

type Output = <u64 as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <u64 as Shr<u16>>::Output

impl Shr<u32> for u32

type Output = u32

pub fn shr(self, other: u32) -> u32

impl<'a> Shr<i128> for &'a i8

type Output = <i8 as Shr<i128>>::Output

pub fn shr(self, other: i128) -> <i8 as Shr<i128>>::Output

impl<'_, '_> Shr<&'_ i128> for &'_ isize

type Output = <isize as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <isize as Shr<i128>>::Output

impl<'a> Shr<i8> for &'a u16

type Output = <u16 as Shr<i8>>::Output

pub fn shr(self, other: i8) -> <u16 as Shr<i8>>::Output

impl Shr<u16> for u64

type Output = u64

pub fn shr(self, other: u16) -> u64

impl Shr<u64> for u32

type Output = u32

pub fn shr(self, other: u64) -> u32

impl<'_, '_> Shr<&'_ u32> for &'_ i32

type Output = <i32 as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <i32 as Shr<u32>>::Output

impl Shr<u64> for i8

type Output = i8

pub fn shr(self, other: u64) -> i8

impl Shr<u32> for u64

type Output = u64

pub fn shr(self, other: u32) -> u64

impl<'_> Shr<&'_ i32> for i8

type Output = <i8 as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <i8 as Shr<i32>>::Output

impl<'_> Shr<&'_ i16> for usize

type Output = <usize as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <usize as Shr<i16>>::Output

impl<'_, '_> Shr<&'_ u32> for &'_ i8

type Output = <i8 as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <i8 as Shr<u32>>::Output

impl<'a> Shr<i8> for &'a u32

type Output = <u32 as Shr<i8>>::Output

pub fn shr(self, other: i8) -> <u32 as Shr<i8>>::Output

impl<'a> Shr<i64> for &'a i32

type Output = <i32 as Shr<i64>>::Output

pub fn shr(self, other: i64) -> <i32 as Shr<i64>>::Output

impl<'a> Shr<i16> for &'a i16

type Output = <i16 as Shr<i16>>::Output

pub fn shr(self, other: i16) -> <i16 as Shr<i16>>::Output

impl<'a> Shr<i16> for &'a i8

type Output = <i8 as Shr<i16>>::Output

pub fn shr(self, other: i16) -> <i8 as Shr<i16>>::Output

impl<'a> Shr<u16> for &'a i8

type Output = <i8 as Shr<u16>>::Output

pub fn shr(self, other: u16) -> <i8 as Shr<u16>>::Output

impl<'_, '_> Shr<&'_ u128> for &'_ i8

type Output = <i8 as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <i8 as Shr<u128>>::Output

impl<'_, '_> Shr<&'_ i16> for &'_ u16

type Output = <u16 as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <u16 as Shr<i16>>::Output

impl Shr<isize> for i128

type Output = i128

pub fn shr(self, other: isize) -> i128

impl<'_, '_> Shr<&'_ i64> for &'_ i128

type Output = <i128 as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <i128 as Shr<i64>>::Output

impl<'_, '_> Shr<&'_ usize> for &'_ isize

type Output = <isize as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <isize as Shr<usize>>::Output

impl<'_> Shr<&'_ i32> for u16

type Output = <u16 as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <u16 as Shr<i32>>::Output

impl<'_> Shr<&'_ i16> for u32

type Output = <u32 as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <u32 as Shr<i16>>::Output

impl<'_> Shr<&'_ i32> for u8

type Output = <u8 as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <u8 as Shr<i32>>::Output

impl Shr<u128> for u8

type Output = u8

pub fn shr(self, other: u128) -> u8

impl<'_> Shr<&'_ i128> for u64

type Output = <u64 as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <u64 as Shr<i128>>::Output

impl<'_, '_> Shr<&'_ u32> for &'_ i128

type Output = <i128 as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <i128 as Shr<u32>>::Output

impl<'a> Shr<u128> for &'a usize

type Output = <usize as Shr<u128>>::Output

pub fn shr(self, other: u128) -> <usize as Shr<u128>>::Output

impl<'_> Shr<&'_ i64> for i32

type Output = <i32 as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <i32 as Shr<i64>>::Output

impl<'a> Shr<u8> for &'a i32

type Output = <i32 as Shr<u8>>::Output

pub fn shr(self, other: u8) -> <i32 as Shr<u8>>::Output

impl Shr<i32> for u64

type Output = u64

pub fn shr(self, other: i32) -> u64

impl<'a> Shr<i128> for &'a isize

type Output = <isize as Shr<i128>>::Output

pub fn shr(self, other: i128) -> <isize as Shr<i128>>::Output

impl<'a> Shr<u64> for &'a i16

type Output = <i16 as Shr<u64>>::Output

pub fn shr(self, other: u64) -> <i16 as Shr<u64>>::Output

impl Shr<i64> for u64

type Output = u64

pub fn shr(self, other: i64) -> u64

impl Shr<usize> for u16

type Output = u16

pub fn shr(self, other: usize) -> u16

impl<'a> Shr<usize> for &'a i32

type Output = <i32 as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <i32 as Shr<usize>>::Output

impl<'_> Shr<&'_ u16> for isize

type Output = <isize as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <isize as Shr<u16>>::Output

impl<'_> Shr<&'_ u16> for u8

type Output = <u8 as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <u8 as Shr<u16>>::Output

impl<'_, '_> Shr<&'_ u16> for &'_ i128

type Output = <i128 as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <i128 as Shr<u16>>::Output

impl<'_> Shr<&'_ i8> for i8

type Output = <i8 as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <i8 as Shr<i8>>::Output

impl<'_, '_> Shr<&'_ u32> for &'_ u16

type Output = <u16 as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <u16 as Shr<u32>>::Output

impl Shr<i64> for i16

type Output = i16

pub fn shr(self, other: i64) -> i16

impl<'_, '_> Shr<&'_ u64> for &'_ i128

type Output = <i128 as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <i128 as Shr<u64>>::Output

impl<'_> Shr<&'_ i8> for u16

type Output = <u16 as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <u16 as Shr<i8>>::Output

impl Shr<i16> for i16

type Output = i16

pub fn shr(self, other: i16) -> i16

impl Shr<i16> for i8

type Output = i8

pub fn shr(self, other: i16) -> i8

impl<'_, '_> Shr<&'_ u128> for &'_ u16

type Output = <u16 as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <u16 as Shr<u128>>::Output

impl<'_, '_> Shr<&'_ i32> for &'_ u16

type Output = <u16 as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <u16 as Shr<i32>>::Output

impl<'_> Shr<&'_ u32> for u16

type Output = <u16 as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <u16 as Shr<u32>>::Output

impl<'_> Shr<&'_ u64> for i64

type Output = <i64 as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <i64 as Shr<u64>>::Output

impl Shr<usize> for i64

type Output = i64

pub fn shr(self, other: usize) -> i64

impl Shr<i128> for u8

type Output = u8

pub fn shr(self, other: i128) -> u8

impl<'a> Shr<usize> for &'a u8

type Output = <u8 as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <u8 as Shr<usize>>::Output

impl<'_> Shr<&'_ u16> for i32

type Output = <i32 as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <i32 as Shr<u16>>::Output

impl<'_, '_> Shr<&'_ usize> for &'_ i128

type Output = <i128 as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <i128 as Shr<usize>>::Output

impl<'a> Shr<u8> for &'a u16

type Output = <u16 as Shr<u8>>::Output

pub fn shr(self, other: u8) -> <u16 as Shr<u8>>::Output

impl<'_> Shr<&'_ u16> for i16

type Output = <i16 as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <i16 as Shr<u16>>::Output

impl<'_, '_> Shr<&'_ i16> for &'_ u32

type Output = <u32 as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <u32 as Shr<i16>>::Output

impl<'_> Shr<&'_ u8> for u32

type Output = <u32 as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <u32 as Shr<u8>>::Output

impl<'_> Shr<&'_ i32> for i16

type Output = <i16 as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <i16 as Shr<i32>>::Output

impl<'_> Shr<&'_ isize> for i8

type Output = <i8 as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <i8 as Shr<isize>>::Output

impl<'_> Shr<&'_ i8> for u8

type Output = <u8 as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <u8 as Shr<i8>>::Output

impl Shr<u32> for usize

type Output = usize

pub fn shr(self, other: u32) -> usize

impl<'a> Shr<u16> for &'a u8

type Output = <u8 as Shr<u16>>::Output

pub fn shr(self, other: u16) -> <u8 as Shr<u16>>::Output

impl Shr<u8> for i64

type Output = i64

pub fn shr(self, other: u8) -> i64

impl<'_, '_> Shr<&'_ isize> for &'_ i64

type Output = <i64 as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <i64 as Shr<isize>>::Output

impl Shr<i64> for u32

type Output = u32

pub fn shr(self, other: i64) -> u32

impl<'_, '_> Shr<&'_ i128> for &'_ usize

type Output = <usize as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <usize as Shr<i128>>::Output

impl<'_> Shr<&'_ u128> for i128

type Output = <i128 as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <i128 as Shr<u128>>::Output

impl<'_, '_> Shr<&'_ u32> for &'_ u64

type Output = <u64 as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <u64 as Shr<u32>>::Output

impl<'a> Shr<i32> for &'a isize

type Output = <isize as Shr<i32>>::Output

pub fn shr(self, other: i32) -> <isize as Shr<i32>>::Output

impl<'_> Shr<&'_ u32> for i16

type Output = <i16 as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <i16 as Shr<u32>>::Output

impl<'_, '_> Shr<&'_ i64> for &'_ u32

type Output = <u32 as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <u32 as Shr<i64>>::Output

impl<'_> Shr<&'_ isize> for u8

type Output = <u8 as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <u8 as Shr<isize>>::Output

impl<'_, '_> Shr<&'_ u64> for &'_ u16

type Output = <u16 as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <u16 as Shr<u64>>::Output

impl<'_> Shr<&'_ i64> for u128

type Output = <u128 as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <u128 as Shr<i64>>::Output

impl Shr<u64> for isize

type Output = isize

pub fn shr(self, other: u64) -> isize

impl<'_> Shr<&'_ u128> for i64

type Output = <i64 as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <i64 as Shr<u128>>::Output

impl<'_, '_> Shr<&'_ i64> for &'_ i8

type Output = <i8 as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <i8 as Shr<i64>>::Output

impl<'_> Shr<&'_ i32> for isize

type Output = <isize as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <isize as Shr<i32>>::Output

impl Shr<u32> for u16

type Output = u16

pub fn shr(self, other: u32) -> u16

impl<'_, '_> Shr<&'_ i64> for &'_ u128

type Output = <u128 as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <u128 as Shr<i64>>::Output

impl Shr<i64> for i64

type Output = i64

pub fn shr(self, other: i64) -> i64

impl<'_, '_> Shr<&'_ i64> for &'_ isize

type Output = <isize as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <isize as Shr<i64>>::Output

impl<'a> Shr<i8> for &'a u64

type Output = <u64 as Shr<i8>>::Output

pub fn shr(self, other: i8) -> <u64 as Shr<i8>>::Output

impl Shr<i16> for i64

type Output = i64

pub fn shr(self, other: i16) -> i64

impl Shr<usize> for i128

type Output = i128

pub fn shr(self, other: usize) -> i128

impl<'a> Shr<i16> for &'a u8

type Output = <u8 as Shr<i16>>::Output

pub fn shr(self, other: i16) -> <u8 as Shr<i16>>::Output

impl<'_> Shr<&'_ i64> for u32

type Output = <u32 as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <u32 as Shr<i64>>::Output

impl<'a> Shr<usize> for &'a u128

type Output = <u128 as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <u128 as Shr<usize>>::Output

impl<'a> Shr<usize> for &'a isize

type Output = <isize as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <isize as Shr<usize>>::Output

impl Shr<u8> for u32

type Output = u32

pub fn shr(self, other: u8) -> u32

impl<'_> Shr<&'_ usize> for u16

type Output = <u16 as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <u16 as Shr<usize>>::Output

impl<'_> Shr<&'_ i128> for i32

type Output = <i32 as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <i32 as Shr<i128>>::Output

impl<'_> Shr<&'_ u128> for u8

type Output = <u8 as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <u8 as Shr<u128>>::Output

impl<'_> Shr<&'_ u8> for i64

type Output = <i64 as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <i64 as Shr<u8>>::Output

impl<'a> Shr<i64> for &'a i64

type Output = <i64 as Shr<i64>>::Output

pub fn shr(self, other: i64) -> <i64 as Shr<i64>>::Output

impl Shr<u8> for i128

type Output = i128

pub fn shr(self, other: u8) -> i128

impl<'_> Shr<&'_ i32> for u64

type Output = <u64 as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <u64 as Shr<i32>>::Output

impl<'_, '_> Shr<&'_ i128> for &'_ i8

type Output = <i8 as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <i8 as Shr<i128>>::Output

impl<'_, '_> Shr<&'_ i128> for &'_ u128

type Output = <u128 as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <u128 as Shr<i128>>::Output

impl<'a> Shr<u8> for &'a i64

type Output = <i64 as Shr<u8>>::Output

pub fn shr(self, other: u8) -> <i64 as Shr<u8>>::Output

impl<'a> Shr<i16> for &'a i64

type Output = <i64 as Shr<i16>>::Output

pub fn shr(self, other: i16) -> <i64 as Shr<i16>>::Output

impl<'_, '_> Shr<&'_ usize> for &'_ i16

type Output = <i16 as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <i16 as Shr<usize>>::Output

impl<'a> Shr<i128> for &'a usize

type Output = <usize as Shr<i128>>::Output

pub fn shr(self, other: i128) -> <usize as Shr<i128>>::Output

impl<'a> Shr<u32> for &'a u64

type Output = <u64 as Shr<u32>>::Output

pub fn shr(self, other: u32) -> <u64 as Shr<u32>>::Output

impl<'_> Shr<&'_ i64> for isize

type Output = <isize as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <isize as Shr<i64>>::Output

impl<'_> Shr<&'_ u64> for u64

type Output = <u64 as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <u64 as Shr<u64>>::Output

impl<'_> Shr<&'_ u64> for isize

type Output = <isize as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <isize as Shr<u64>>::Output

impl<'_, '_> Shr<&'_ i128> for &'_ i64

type Output = <i64 as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <i64 as Shr<i128>>::Output

impl Shr<usize> for u64

type Output = u64

pub fn shr(self, other: usize) -> u64

impl<'a> Shr<i128> for &'a i64

type Output = <i64 as Shr<i128>>::Output

pub fn shr(self, other: i128) -> <i64 as Shr<i128>>::Output

impl<'_, '_> Shr<&'_ isize> for &'_ u32

type Output = <u32 as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <u32 as Shr<isize>>::Output

impl<'_, '_> Shr<&'_ isize> for &'_ u16

type Output = <u16 as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <u16 as Shr<isize>>::Output

impl<'_> Shr<&'_ u16> for i64

type Output = <i64 as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <i64 as Shr<u16>>::Output

impl Shr<i128> for i128

type Output = i128

pub fn shr(self, other: i128) -> i128

impl<'a> Shr<i64> for &'a u64

type Output = <u64 as Shr<i64>>::Output

pub fn shr(self, other: i64) -> <u64 as Shr<i64>>::Output

impl<'_, '_> Shr<&'_ i64> for &'_ i32

type Output = <i32 as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <i32 as Shr<i64>>::Output

impl<'_> Shr<&'_ u128> for u16

type Output = <u16 as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <u16 as Shr<u128>>::Output

impl<'_> Shr<&'_ u32> for i8

type Output = <i8 as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <i8 as Shr<u32>>::Output

impl<'_> Shr<&'_ isize> for i128

type Output = <i128 as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <i128 as Shr<isize>>::Output

impl Shr<u128> for u32

type Output = u32

pub fn shr(self, other: u128) -> u32

impl<'a> Shr<u64> for &'a u32

type Output = <u32 as Shr<u64>>::Output

pub fn shr(self, other: u64) -> <u32 as Shr<u64>>::Output

impl<'_, '_> Shr<&'_ u32> for &'_ u8

type Output = <u8 as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <u8 as Shr<u32>>::Output

impl<'_, '_> Shr<&'_ usize> for &'_ i32

type Output = <i32 as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <i32 as Shr<usize>>::Output

impl Shr<isize> for i32

type Output = i32

pub fn shr(self, other: isize) -> i32

impl<'_, '_> Shr<&'_ i32> for &'_ u128

type Output = <u128 as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <u128 as Shr<i32>>::Output

impl<'_, '_> Shr<&'_ i64> for &'_ u16

type Output = <u16 as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <u16 as Shr<i64>>::Output

impl<'_> Shr<&'_ i16> for u8

type Output = <u8 as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <u8 as Shr<i16>>::Output

impl<'_, '_> Shr<&'_ u128> for &'_ i64

type Output = <i64 as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <i64 as Shr<u128>>::Output

impl<'_, '_> Shr<&'_ i8> for &'_ u16

type Output = <u16 as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <u16 as Shr<i8>>::Output

impl<'_> Shr<&'_ i8> for i128

type Output = <i128 as Shr<i8>>::Output

pub fn shr(self, other: &i8) -> <i128 as Shr<i8>>::Output

impl<'_> Shr<&'_ u8> for i128

type Output = <i128 as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <i128 as Shr<u8>>::Output

impl<'_> Shr<&'_ isize> for u16

type Output = <u16 as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <u16 as Shr<isize>>::Output

impl<'_, '_> Shr<&'_ u16> for &'_ u128

type Output = <u128 as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <u128 as Shr<u16>>::Output

impl<'a> Shr<isize> for &'a u16

type Output = <u16 as Shr<isize>>::Output

pub fn shr(self, other: isize) -> <u16 as Shr<isize>>::Output

impl<'_, '_> Shr<&'_ i16> for &'_ i128

type Output = <i128 as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <i128 as Shr<i16>>::Output

impl Shr<i16> for u16

type Output = u16

pub fn shr(self, other: i16) -> u16

impl<'_> Shr<&'_ i64> for i128

type Output = <i128 as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <i128 as Shr<i64>>::Output

impl<'_, '_> Shr<&'_ isize> for &'_ i32

type Output = <i32 as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <i32 as Shr<isize>>::Output

impl<'_, '_> Shr<&'_ i16> for &'_ usize

type Output = <usize as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <usize as Shr<i16>>::Output

impl Shr<i64> for u16

type Output = u16

pub fn shr(self, other: i64) -> u16

impl<'a> Shr<u128> for &'a i8

type Output = <i8 as Shr<u128>>::Output

pub fn shr(self, other: u128) -> <i8 as Shr<u128>>::Output

impl<'a> Shr<i32> for &'a u64

type Output = <u64 as Shr<i32>>::Output

pub fn shr(self, other: i32) -> <u64 as Shr<i32>>::Output

impl<'a> Shr<u32> for &'a u32

type Output = <u32 as Shr<u32>>::Output

pub fn shr(self, other: u32) -> <u32 as Shr<u32>>::Output

impl<'a> Shr<i64> for &'a i128

type Output = <i128 as Shr<i64>>::Output

pub fn shr(self, other: i64) -> <i128 as Shr<i64>>::Output

impl<'_> Shr<&'_ isize> for u64

type Output = <u64 as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <u64 as Shr<isize>>::Output

impl<'_> Shr<&'_ i128> for i8

type Output = <i8 as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <i8 as Shr<i128>>::Output

impl<'_> Shr<&'_ usize> for i128

type Output = <i128 as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <i128 as Shr<usize>>::Output

impl Shr<i8> for u16

type Output = u16

pub fn shr(self, other: i8) -> u16

impl<'_, '_> Shr<&'_ i32> for &'_ i32

type Output = <i32 as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <i32 as Shr<i32>>::Output

impl<'a> Shr<u16> for &'a usize

type Output = <usize as Shr<u16>>::Output

pub fn shr(self, other: u16) -> <usize as Shr<u16>>::Output

impl<'_> Shr<&'_ i128> for u16

type Output = <u16 as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <u16 as Shr<i128>>::Output

impl<'_> Shr<&'_ i64> for u8

type Output = <u8 as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <u8 as Shr<i64>>::Output

impl<'_> Shr<&'_ u128> for u128

type Output = <u128 as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <u128 as Shr<u128>>::Output

impl<'a> Shr<isize> for &'a u64

type Output = <u64 as Shr<isize>>::Output

pub fn shr(self, other: isize) -> <u64 as Shr<isize>>::Output

impl<'a> Shr<isize> for &'a usize

type Output = <usize as Shr<isize>>::Output

pub fn shr(self, other: isize) -> <usize as Shr<isize>>::Output

impl<'_> Shr<&'_ u64> for u128

type Output = <u128 as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <u128 as Shr<u64>>::Output

impl Shr<u32> for i16

type Output = i16

pub fn shr(self, other: u32) -> i16

impl<'_, '_> Shr<&'_ u16> for &'_ isize

type Output = <isize as Shr<u16>>::Output

pub fn shr(self, other: &u16) -> <isize as Shr<u16>>::Output

impl Shr<u128> for i64

type Output = i64

pub fn shr(self, other: u128) -> i64

impl<'a> Shr<u32> for &'a i64

type Output = <i64 as Shr<u32>>::Output

pub fn shr(self, other: u32) -> <i64 as Shr<u32>>::Output

impl Shr<u64> for i64

type Output = i64

pub fn shr(self, other: u64) -> i64

impl<'_, '_> Shr<&'_ i128> for &'_ u32

type Output = <u32 as Shr<i128>>::Output

pub fn shr(self, other: &i128) -> <u32 as Shr<i128>>::Output

impl<'a> Shr<u32> for &'a isize

type Output = <isize as Shr<u32>>::Output

pub fn shr(self, other: u32) -> <isize as Shr<u32>>::Output

impl<'_> Shr<&'_ i16> for i8

type Output = <i8 as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <i8 as Shr<i16>>::Output

impl<'_, '_> Shr<&'_ i64> for &'_ i16

type Output = <i16 as Shr<i64>>::Output

pub fn shr(self, other: &i64) -> <i16 as Shr<i64>>::Output

impl Shr<u128> for u64

type Output = u64

pub fn shr(self, other: u128) -> u64

impl<'a> Shr<u8> for &'a u64

type Output = <u64 as Shr<u8>>::Output

pub fn shr(self, other: u8) -> <u64 as Shr<u8>>::Output

impl Shr<i8> for i32

type Output = i32

pub fn shr(self, other: i8) -> i32

impl<'_, '_> Shr<&'_ u128> for &'_ u8

type Output = <u8 as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <u8 as Shr<u128>>::Output

impl<'_> Shr<&'_ u32> for u128

type Output = <u128 as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <u128 as Shr<u32>>::Output

impl<'_> Shr<&'_ u128> for u32

type Output = <u32 as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <u32 as Shr<u128>>::Output

impl<'_> Shr<&'_ i16> for i64

type Output = <i64 as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <i64 as Shr<i16>>::Output

impl<'a> Shr<u32> for &'a u8

type Output = <u8 as Shr<u32>>::Output

pub fn shr(self, other: u32) -> <u8 as Shr<u32>>::Output

impl Shr<isize> for isize

type Output = isize

pub fn shr(self, other: isize) -> isize

impl<'_> Shr<&'_ u8> for u8

type Output = <u8 as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <u8 as Shr<u8>>::Output

impl<'_, '_> Shr<&'_ u64> for &'_ i16

type Output = <i16 as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <i16 as Shr<u64>>::Output

impl<'_, '_> Shr<&'_ usize> for &'_ u8

type Output = <u8 as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <u8 as Shr<usize>>::Output

impl<'_, '_> Shr<&'_ u8> for &'_ i128

type Output = <i128 as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <i128 as Shr<u8>>::Output

impl Shr<i16> for usize

type Output = usize

pub fn shr(self, other: i16) -> usize

impl<'_> Shr<&'_ u64> for i8

type Output = <i8 as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <i8 as Shr<u64>>::Output

impl<'a> Shr<u64> for &'a usize

type Output = <usize as Shr<u64>>::Output

pub fn shr(self, other: u64) -> <usize as Shr<u64>>::Output

impl<'_, '_> Shr<&'_ i32> for &'_ u64

type Output = <u64 as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <u64 as Shr<i32>>::Output

impl<'_, '_> Shr<&'_ u64> for &'_ u128

type Output = <u128 as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <u128 as Shr<u64>>::Output

impl Shr<i8> for u32

type Output = u32

pub fn shr(self, other: i8) -> u32

impl Shr<isize> for u16

type Output = u16

pub fn shr(self, other: isize) -> u16

impl<'a> Shr<u8> for &'a isize

type Output = <isize as Shr<u8>>::Output

pub fn shr(self, other: u8) -> <isize as Shr<u8>>::Output

impl<'a> Shr<u64> for &'a u128

type Output = <u128 as Shr<u64>>::Output

pub fn shr(self, other: u64) -> <u128 as Shr<u64>>::Output

impl<'_, '_> Shr<&'_ i32> for &'_ u32

type Output = <u32 as Shr<i32>>::Output

pub fn shr(self, other: &i32) -> <u32 as Shr<i32>>::Output

impl<'a> Shr<usize> for &'a u32

type Output = <u32 as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <u32 as Shr<usize>>::Output

impl Shr<usize> for u8

type Output = u8

pub fn shr(self, other: usize) -> u8

impl<'a> Shr<i16> for &'a isize

type Output = <isize as Shr<i16>>::Output

pub fn shr(self, other: i16) -> <isize as Shr<i16>>::Output

impl<'a> Shr<u64> for &'a i8

type Output = <i8 as Shr<u64>>::Output

pub fn shr(self, other: u64) -> <i8 as Shr<u64>>::Output

impl<'_, '_> Shr<&'_ u64> for &'_ u64

type Output = <u64 as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <u64 as Shr<u64>>::Output

impl<'_> Shr<&'_ u8> for i8

type Output = <i8 as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <i8 as Shr<u8>>::Output

impl<'_> Shr<&'_ u128> for usize

type Output = <usize as Shr<u128>>::Output

pub fn shr(self, other: &u128) -> <usize as Shr<u128>>::Output

impl<'_, '_> Shr<&'_ u8> for &'_ isize

type Output = <isize as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <isize as Shr<u8>>::Output

impl Shr<i16> for u64

type Output = u64

pub fn shr(self, other: i16) -> u64

impl<'_> Shr<&'_ u8> for i32

type Output = <i32 as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <i32 as Shr<u8>>::Output

impl Shr<i128> for u64

type Output = u64

pub fn shr(self, other: i128) -> u64

impl Shr<i16> for i128

type Output = i128

pub fn shr(self, other: i16) -> i128

impl<'_> Shr<&'_ isize> for i64

type Output = <i64 as Shr<isize>>::Output

pub fn shr(self, other: &isize) -> <i64 as Shr<isize>>::Output

impl Shr<u8> for u8

type Output = u8

pub fn shr(self, other: u8) -> u8

impl<'_> Shr<&'_ u64> for usize

type Output = <usize as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <usize as Shr<u64>>::Output

impl Shr<usize> for i32

type Output = i32

pub fn shr(self, other: usize) -> i32

impl Shr<u8> for u64

type Output = u64

pub fn shr(self, other: u8) -> u64

impl<'_, '_> Shr<&'_ u8> for &'_ u8

type Output = <u8 as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <u8 as Shr<u8>>::Output

impl Shr<i128> for u128

type Output = u128

pub fn shr(self, other: i128) -> u128

impl<'a> Shr<i64> for &'a usize

type Output = <usize as Shr<i64>>::Output

pub fn shr(self, other: i64) -> <usize as Shr<i64>>::Output

impl<'a> Shr<u64> for &'a u64

type Output = <u64 as Shr<u64>>::Output

pub fn shr(self, other: u64) -> <u64 as Shr<u64>>::Output

impl<'_, '_> Shr<&'_ u64> for &'_ u8

type Output = <u8 as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <u8 as Shr<u64>>::Output

impl<'_, '_> Shr<&'_ u64> for &'_ i32

type Output = <i32 as Shr<u64>>::Output

pub fn shr(self, other: &u64) -> <i32 as Shr<u64>>::Output

impl<'a> Shr<usize> for &'a i16

type Output = <i16 as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <i16 as Shr<usize>>::Output

impl<'a> Shr<u32> for &'a u16

type Output = <u16 as Shr<u32>>::Output

pub fn shr(self, other: u32) -> <u16 as Shr<u32>>::Output

impl<'_> Shr<&'_ i16> for isize

type Output = <isize as Shr<i16>>::Output

pub fn shr(self, other: &i16) -> <isize as Shr<i16>>::Output

impl<'_, '_> Shr<&'_ u8> for &'_ u16

type Output = <u16 as Shr<u8>>::Output

pub fn shr(self, other: &u8) -> <u16 as Shr<u8>>::Output

impl Shr<isize> for usize

type Output = usize

pub fn shr(self, other: isize) -> usize

impl<'_> Shr<&'_ u32> for u8

type Output = <u8 as Shr<u32>>::Output

pub fn shr(self, other: &u32) -> <u8 as Shr<u32>>::Output

impl Shr<i128> for i32

type Output = i32

pub fn shr(self, other: i128) -> i32

impl<'a> Shr<usize> for &'a usize

type Output = <usize as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <usize as Shr<usize>>::Output

impl<'a> Shr<isize> for &'a i8

type Output = <i8 as Shr<isize>>::Output

pub fn shr(self, other: isize) -> <i8 as Shr<isize>>::Output

impl Shr<u32> for i128

type Output = i128

pub fn shr(self, other: u32) -> i128

impl Shr<isize> for u32

type Output = u32

pub fn shr(self, other: isize) -> u32

impl<'a, S, D> Shr<&'a ArrayBase<S, D>> for u8 where
    D: Dimension,
    S: Data<Elem = u8>, 

type Output = ArrayBase<OwnedRepr<u8>, D>

pub fn shr(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u8>, D>

impl<S, D> Shr<ArrayBase<S, D>> for i32 where
    D: Dimension,
    S: DataOwned<Elem = i32> + DataMut, 

type Output = ArrayBase<S, D>

pub fn shr(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Shr<&'a ArrayBase<S, D>> for i128 where
    D: Dimension,
    S: Data<Elem = i128>, 

type Output = ArrayBase<OwnedRepr<i128>, D>

pub fn shr(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i128>, D>

impl<S, D> Shr<ArrayBase<S, D>> for u8 where
    D: Dimension,
    S: DataOwned<Elem = u8> + DataMut, 

type Output = ArrayBase<S, D>

pub fn shr(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Shr<&'a ArrayBase<S, D>> for i64 where
    D: Dimension,
    S: Data<Elem = i64>, 

type Output = ArrayBase<OwnedRepr<i64>, D>

pub fn shr(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i64>, D>

impl<'a, S, D> Shr<&'a ArrayBase<S, D>> for i8 where
    D: Dimension,
    S: Data<Elem = i8>, 

type Output = ArrayBase<OwnedRepr<i8>, D>

pub fn shr(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i8>, D>

impl<S, D> Shr<ArrayBase<S, D>> for i16 where
    D: Dimension,
    S: DataOwned<Elem = i16> + DataMut, 

type Output = ArrayBase<S, D>

pub fn shr(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Shr<&'a ArrayBase<S, D>> for i16 where
    D: Dimension,
    S: Data<Elem = i16>, 

type Output = ArrayBase<OwnedRepr<i16>, D>

pub fn shr(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i16>, D>

impl<S, D> Shr<ArrayBase<S, D>> for u64 where
    D: Dimension,
    S: DataOwned<Elem = u64> + DataMut, 

type Output = ArrayBase<S, D>

pub fn shr(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Shr<&'a ArrayBase<S, D>> for i32 where
    D: Dimension,
    S: Data<Elem = i32>, 

type Output = ArrayBase<OwnedRepr<i32>, D>

pub fn shr(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i32>, D>

impl<S, D> Shr<ArrayBase<S, D>> for u128 where
    D: Dimension,
    S: DataOwned<Elem = u128> + DataMut, 

type Output = ArrayBase<S, D>

pub fn shr(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Shr<ArrayBase<S, D>> for i64 where
    D: Dimension,
    S: DataOwned<Elem = i64> + DataMut, 

type Output = ArrayBase<S, D>

pub fn shr(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Shr<&'a ArrayBase<S, D>> for u16 where
    D: Dimension,
    S: Data<Elem = u16>, 

type Output = ArrayBase<OwnedRepr<u16>, D>

pub fn shr(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u16>, D>

impl<S, D> Shr<ArrayBase<S, D>> for i8 where
    D: Dimension,
    S: DataOwned<Elem = i8> + DataMut, 

type Output = ArrayBase<S, D>

pub fn shr(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Shr<&'a ArrayBase<S, D>> for u64 where
    D: Dimension,
    S: Data<Elem = u64>, 

type Output = ArrayBase<OwnedRepr<u64>, D>

pub fn shr(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u64>, D>

impl<S, D> Shr<ArrayBase<S, D>> for u32 where
    D: Dimension,
    S: DataOwned<Elem = u32> + DataMut, 

type Output = ArrayBase<S, D>

pub fn shr(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Shr<&'a ArrayBase<S, D>> for u32 where
    D: Dimension,
    S: Data<Elem = u32>, 

type Output = ArrayBase<OwnedRepr<u32>, D>

pub fn shr(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u32>, D>

impl<S, D> Shr<ArrayBase<S, D>> for u16 where
    D: Dimension,
    S: DataOwned<Elem = u16> + DataMut, 

type Output = ArrayBase<S, D>

pub fn shr(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Shr<&'a ArrayBase<S, D>> for u128 where
    D: Dimension,
    S: Data<Elem = u128>, 

type Output = ArrayBase<OwnedRepr<u128>, D>

pub fn shr(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u128>, D>

impl<S, D> Shr<ArrayBase<S, D>> for i128 where
    D: Dimension,
    S: DataOwned<Elem = i128> + DataMut, 

type Output = ArrayBase<S, D>

pub fn shr(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

Loading content...

Implementors

impl Shr<usize> for Wrapping<i8>

type Output = Wrapping<i8>

pub fn shr(self, other: usize) -> Wrapping<i8>

impl Shr<usize> for Wrapping<i16>

type Output = Wrapping<i16>

pub fn shr(self, other: usize) -> Wrapping<i16>

impl Shr<usize> for Wrapping<i32>

type Output = Wrapping<i32>

pub fn shr(self, other: usize) -> Wrapping<i32>

impl Shr<usize> for Wrapping<i64>

type Output = Wrapping<i64>

pub fn shr(self, other: usize) -> Wrapping<i64>

impl Shr<usize> for Wrapping<i128>

type Output = Wrapping<i128>

pub fn shr(self, other: usize) -> Wrapping<i128>

impl Shr<usize> for Wrapping<isize>

type Output = Wrapping<isize>

pub fn shr(self, other: usize) -> Wrapping<isize>

impl Shr<usize> for Wrapping<u8>

type Output = Wrapping<u8>

pub fn shr(self, other: usize) -> Wrapping<u8>

impl Shr<usize> for Wrapping<u16>

type Output = Wrapping<u16>

pub fn shr(self, other: usize) -> Wrapping<u16>

impl Shr<usize> for Wrapping<u32>

type Output = Wrapping<u32>

pub fn shr(self, other: usize) -> Wrapping<u32>

impl Shr<usize> for Wrapping<u64>

type Output = Wrapping<u64>

pub fn shr(self, other: usize) -> Wrapping<u64>

impl Shr<usize> for Wrapping<u128>

type Output = Wrapping<u128>

pub fn shr(self, other: usize) -> Wrapping<u128>

impl Shr<usize> for Wrapping<usize>

type Output = Wrapping<usize>

pub fn shr(self, other: usize) -> Wrapping<usize>

impl<'_> Shr<&'_ usize> for Wrapping<i8>

type Output = <Wrapping<i8> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<i8> as Shr<usize>>::Output

impl<'_> Shr<&'_ usize> for Wrapping<i16>

type Output = <Wrapping<i16> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<i16> as Shr<usize>>::Output

impl<'_> Shr<&'_ usize> for Wrapping<i32>

type Output = <Wrapping<i32> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<i32> as Shr<usize>>::Output

impl<'_> Shr<&'_ usize> for Wrapping<i64>

type Output = <Wrapping<i64> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<i64> as Shr<usize>>::Output

impl<'_> Shr<&'_ usize> for Wrapping<i128>

type Output = <Wrapping<i128> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<i128> as Shr<usize>>::Output

impl<'_> Shr<&'_ usize> for Wrapping<isize>

type Output = <Wrapping<isize> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<isize> as Shr<usize>>::Output

impl<'_> Shr<&'_ usize> for Wrapping<u8>

type Output = <Wrapping<u8> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<u8> as Shr<usize>>::Output

impl<'_> Shr<&'_ usize> for Wrapping<u16>

type Output = <Wrapping<u16> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<u16> as Shr<usize>>::Output

impl<'_> Shr<&'_ usize> for Wrapping<u32>

type Output = <Wrapping<u32> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<u32> as Shr<usize>>::Output

impl<'_> Shr<&'_ usize> for Wrapping<u64>

type Output = <Wrapping<u64> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<u64> as Shr<usize>>::Output

impl<'_> Shr<&'_ usize> for Wrapping<u128>

type Output = <Wrapping<u128> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<u128> as Shr<usize>>::Output

impl<'_> Shr<&'_ usize> for Wrapping<usize>

type Output = <Wrapping<usize> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<usize> as Shr<usize>>::Output

impl<'_, '_> Shr<&'_ usize> for &'_ Wrapping<i8>

type Output = <Wrapping<i8> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<i8> as Shr<usize>>::Output

impl<'_, '_> Shr<&'_ usize> for &'_ Wrapping<i16>

type Output = <Wrapping<i16> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<i16> as Shr<usize>>::Output

impl<'_, '_> Shr<&'_ usize> for &'_ Wrapping<i32>

type Output = <Wrapping<i32> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<i32> as Shr<usize>>::Output

impl<'_, '_> Shr<&'_ usize> for &'_ Wrapping<i64>

type Output = <Wrapping<i64> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<i64> as Shr<usize>>::Output

impl<'_, '_> Shr<&'_ usize> for &'_ Wrapping<i128>

type Output = <Wrapping<i128> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<i128> as Shr<usize>>::Output

impl<'_, '_> Shr<&'_ usize> for &'_ Wrapping<isize>

type Output = <Wrapping<isize> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<isize> as Shr<usize>>::Output

impl<'_, '_> Shr<&'_ usize> for &'_ Wrapping<u8>

type Output = <Wrapping<u8> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<u8> as Shr<usize>>::Output

impl<'_, '_> Shr<&'_ usize> for &'_ Wrapping<u16>

type Output = <Wrapping<u16> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<u16> as Shr<usize>>::Output

impl<'_, '_> Shr<&'_ usize> for &'_ Wrapping<u32>

type Output = <Wrapping<u32> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<u32> as Shr<usize>>::Output

impl<'_, '_> Shr<&'_ usize> for &'_ Wrapping<u64>

type Output = <Wrapping<u64> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<u64> as Shr<usize>>::Output

impl<'_, '_> Shr<&'_ usize> for &'_ Wrapping<u128>

type Output = <Wrapping<u128> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<u128> as Shr<usize>>::Output

impl<'_, '_> Shr<&'_ usize> for &'_ Wrapping<usize>

type Output = <Wrapping<usize> as Shr<usize>>::Output

pub fn shr(self, other: &usize) -> <Wrapping<usize> as Shr<usize>>::Output

impl<'a> Shr<usize> for &'a Wrapping<i8>

type Output = <Wrapping<i8> as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <Wrapping<i8> as Shr<usize>>::Output

impl<'a> Shr<usize> for &'a Wrapping<i16>

type Output = <Wrapping<i16> as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <Wrapping<i16> as Shr<usize>>::Output

impl<'a> Shr<usize> for &'a Wrapping<i32>

type Output = <Wrapping<i32> as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <Wrapping<i32> as Shr<usize>>::Output

impl<'a> Shr<usize> for &'a Wrapping<i64>

type Output = <Wrapping<i64> as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <Wrapping<i64> as Shr<usize>>::Output

impl<'a> Shr<usize> for &'a Wrapping<i128>

type Output = <Wrapping<i128> as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <Wrapping<i128> as Shr<usize>>::Output

impl<'a> Shr<usize> for &'a Wrapping<isize>

type Output = <Wrapping<isize> as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <Wrapping<isize> as Shr<usize>>::Output

impl<'a> Shr<usize> for &'a Wrapping<u8>

type Output = <Wrapping<u8> as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <Wrapping<u8> as Shr<usize>>::Output

impl<'a> Shr<usize> for &'a Wrapping<u16>

type Output = <Wrapping<u16> as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <Wrapping<u16> as Shr<usize>>::Output

impl<'a> Shr<usize> for &'a Wrapping<u32>

type Output = <Wrapping<u32> as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <Wrapping<u32> as Shr<usize>>::Output

impl<'a> Shr<usize> for &'a Wrapping<u64>

type Output = <Wrapping<u64> as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <Wrapping<u64> as Shr<usize>>::Output

impl<'a> Shr<usize> for &'a Wrapping<u128>

type Output = <Wrapping<u128> as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <Wrapping<u128> as Shr<usize>>::Output

impl<'a> Shr<usize> for &'a Wrapping<usize>

type Output = <Wrapping<usize> as Shr<usize>>::Output

pub fn shr(self, other: usize) -> <Wrapping<usize> as Shr<usize>>::Output

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,
    D: Dimension,
    E: Dimension,
    S: Data<Elem = A>,
    S2: Data<Elem = B>, 

Perform elementwise right shift between references self and rhs, and return the result as a new Array.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<OwnedRepr<A>, D>

pub fn shr(self, rhs: &'a ArrayBase<S2, E>) -> ArrayBase<OwnedRepr<A>, D>

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,
    D: Dimension,
    E: Dimension,
    S: DataOwned<Elem = A> + DataMut,
    S2: Data<Elem = B>, 

Perform elementwise right shift between self and reference rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

pub fn shr(self, rhs: &ArrayBase<S2, E>) -> ArrayBase<S, D>

impl<'a, A, S, D, B> Shr<B> for &'a ArrayBase<S, D> where
    A: Clone + Shr<B, Output = A>,
    B: ScalarOperand,
    D: Dimension,
    S: Data<Elem = A>, 

Perform elementwise right shift between the reference self and the scalar x, and return the result as a new Array.

type Output = ArrayBase<OwnedRepr<A>, D>

pub fn shr(self, x: B) -> ArrayBase<OwnedRepr<A>, D>

impl<A, B, S, S2, D, E> Shr<ArrayBase<S2, E>> for ArrayBase<S, D> where
    A: Clone + Shr<B, Output = A>,
    B: Clone,
    D: Dimension,
    E: Dimension,
    S: DataOwned<Elem = A> + DataMut,
    S2: Data<Elem = B>, 

Perform elementwise right shift between self and rhs, and return the result (based on self).

self must be an Array or ArcArray.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

pub fn shr(self, rhs: ArrayBase<S2, E>) -> ArrayBase<S, D>

impl<A, S, D, B> Shr<B> for ArrayBase<S, D> where
    A: Clone + Shr<B, Output = A>,
    B: ScalarOperand,
    D: Dimension,
    S: DataOwned<Elem = A> + DataMut, 

Perform elementwise right shift between self and the scalar x, and return the result (based on self).

self must be an Array or ArcArray.

type Output = ArrayBase<S, D>

pub fn shr(self, x: B) -> ArrayBase<S, D>

Loading content...