Trait caffe2_imports::BitAnd

pub trait BitAnd<Rhs = Self> {
    type Output;

    // Required method
    fn bitand(self, rhs: Rhs) -> Self::Output;
}

The bitwise AND operator &.

Note that Rhs is Self by default, but this is not mandatory.

Examples

An implementation of BitAnd for a wrapper around bool.

use std::ops::BitAnd;

#[derive(Debug, PartialEq)]
struct Scalar(bool);

impl BitAnd for Scalar {
    type Output = Self;

    // rhs is the "right-hand side" of the expression `a & b`
    fn bitand(self, rhs: Self) -> Self::Output {
        Self(self.0 & rhs.0)
    }
}

assert_eq!(Scalar(true) & Scalar(true), Scalar(true));
assert_eq!(Scalar(true) & Scalar(false), Scalar(false));
assert_eq!(Scalar(false) & Scalar(true), Scalar(false));
assert_eq!(Scalar(false) & Scalar(false), Scalar(false));

An implementation of BitAnd for a wrapper around Vec<bool>.

use std::ops::BitAnd;

#[derive(Debug, PartialEq)]
struct BooleanVector(Vec<bool>);

impl BitAnd for BooleanVector {
    type Output = Self;

    fn bitand(self, Self(rhs): Self) -> Self::Output {
        let Self(lhs) = self;
        assert_eq!(lhs.len(), rhs.len());
        Self(
            lhs.iter()
                .zip(rhs.iter())
                .map(|(x, y)| *x & *y)
                .collect()
        )
    }
}

let bv1 = BooleanVector(vec![true, true, false, false]);
let bv2 = BooleanVector(vec![true, false, true, false]);
let expected = BooleanVector(vec![true, false, false, false]);
assert_eq!(bv1 & bv2, expected);

Required Associated Types

type Output

The resulting type after applying the & operator.

Required Methods

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

Performs the & operation.

Examples

assert_eq!(true & false, false);
assert_eq!(true & true, true);
assert_eq!(5u8 & 1u8, 1);
assert_eq!(5u8 & 2u8, 0);

Implementors

impl BitAnd<&bool> for &bool

type Output = <bool as BitAnd<bool>>::Output

impl BitAnd<&bool> for bool

type Output = <bool as BitAnd<bool>>::Output

impl BitAnd<&i8> for &i8

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

impl BitAnd<&i8> for i8

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

impl BitAnd<&i16> for &i16

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

impl BitAnd<&i16> for i16

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

impl BitAnd<&i32> for &i32

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

impl BitAnd<&i32> for i32

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

impl BitAnd<&i64> for &i64

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

impl BitAnd<&i64> for i64

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

impl BitAnd<&i128> for &i128

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

impl BitAnd<&i128> for i128

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

impl BitAnd<&isize> for &isize

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

impl BitAnd<&isize> for isize

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

impl BitAnd<&u8> for &u8

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

impl BitAnd<&u8> for u8

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

impl BitAnd<&u16> for &u16

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

impl BitAnd<&u16> for u16

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

impl BitAnd<&u32> for &u32

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

impl BitAnd<&u32> for u32

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

impl BitAnd<&u64> for &u64

type Output = <u64 as BitAnd<u64>>::Output

impl BitAnd<&u64> for u64

type Output = <u64 as BitAnd<u64>>::Output

impl BitAnd<&u128> for &u128

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

impl BitAnd<&u128> for u128

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

impl BitAnd<&usize> for &usize

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

impl BitAnd<&usize> for usize

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

impl BitAnd<&Saturating<i8>> for &Saturating<i8>

type Output = <Saturating<i8> as BitAnd<Saturating<i8>>>::Output

impl BitAnd<&Saturating<i8>> for Saturating<i8>

type Output = <Saturating<i8> as BitAnd<Saturating<i8>>>::Output

impl BitAnd<&Saturating<i16>> for &Saturating<i16>

type Output = <Saturating<i16> as BitAnd<Saturating<i16>>>::Output

impl BitAnd<&Saturating<i16>> for Saturating<i16>

type Output = <Saturating<i16> as BitAnd<Saturating<i16>>>::Output

impl BitAnd<&Saturating<i32>> for &Saturating<i32>

type Output = <Saturating<i32> as BitAnd<Saturating<i32>>>::Output

impl BitAnd<&Saturating<i32>> for Saturating<i32>

type Output = <Saturating<i32> as BitAnd<Saturating<i32>>>::Output

impl BitAnd<&Saturating<i64>> for &Saturating<i64>

type Output = <Saturating<i64> as BitAnd<Saturating<i64>>>::Output

impl BitAnd<&Saturating<i64>> for Saturating<i64>

type Output = <Saturating<i64> as BitAnd<Saturating<i64>>>::Output

impl BitAnd<&Saturating<i128>> for &Saturating<i128>

type Output = <Saturating<i128> as BitAnd<Saturating<i128>>>::Output

impl BitAnd<&Saturating<i128>> for Saturating<i128>

type Output = <Saturating<i128> as BitAnd<Saturating<i128>>>::Output

impl BitAnd<&Saturating<isize>> for &Saturating<isize>

type Output = <Saturating<isize> as BitAnd<Saturating<isize>>>::Output

impl BitAnd<&Saturating<isize>> for Saturating<isize>

type Output = <Saturating<isize> as BitAnd<Saturating<isize>>>::Output

impl BitAnd<&Saturating<u8>> for &Saturating<u8>

type Output = <Saturating<u8> as BitAnd<Saturating<u8>>>::Output

impl BitAnd<&Saturating<u8>> for Saturating<u8>

type Output = <Saturating<u8> as BitAnd<Saturating<u8>>>::Output

impl BitAnd<&Saturating<u16>> for &Saturating<u16>

type Output = <Saturating<u16> as BitAnd<Saturating<u16>>>::Output

impl BitAnd<&Saturating<u16>> for Saturating<u16>

type Output = <Saturating<u16> as BitAnd<Saturating<u16>>>::Output

impl BitAnd<&Saturating<u32>> for &Saturating<u32>

type Output = <Saturating<u32> as BitAnd<Saturating<u32>>>::Output

impl BitAnd<&Saturating<u32>> for Saturating<u32>

type Output = <Saturating<u32> as BitAnd<Saturating<u32>>>::Output

impl BitAnd<&Saturating<u64>> for &Saturating<u64>

type Output = <Saturating<u64> as BitAnd<Saturating<u64>>>::Output

impl BitAnd<&Saturating<u64>> for Saturating<u64>

type Output = <Saturating<u64> as BitAnd<Saturating<u64>>>::Output

impl BitAnd<&Saturating<u128>> for &Saturating<u128>

type Output = <Saturating<u128> as BitAnd<Saturating<u128>>>::Output

impl BitAnd<&Saturating<u128>> for Saturating<u128>

type Output = <Saturating<u128> as BitAnd<Saturating<u128>>>::Output

impl BitAnd<&Saturating<usize>> for &Saturating<usize>

type Output = <Saturating<usize> as BitAnd<Saturating<usize>>>::Output

impl BitAnd<&Saturating<usize>> for Saturating<usize>

type Output = <Saturating<usize> as BitAnd<Saturating<usize>>>::Output

impl BitAnd<&Wrapping<i8>> for &Wrapping<i8>

type Output = <Wrapping<i8> as BitAnd<Wrapping<i8>>>::Output

impl BitAnd<&Wrapping<i8>> for Wrapping<i8>

type Output = <Wrapping<i8> as BitAnd<Wrapping<i8>>>::Output

impl BitAnd<&Wrapping<i16>> for &Wrapping<i16>

type Output = <Wrapping<i16> as BitAnd<Wrapping<i16>>>::Output

impl BitAnd<&Wrapping<i16>> for Wrapping<i16>

type Output = <Wrapping<i16> as BitAnd<Wrapping<i16>>>::Output

impl BitAnd<&Wrapping<i32>> for &Wrapping<i32>

type Output = <Wrapping<i32> as BitAnd<Wrapping<i32>>>::Output

impl BitAnd<&Wrapping<i32>> for Wrapping<i32>

type Output = <Wrapping<i32> as BitAnd<Wrapping<i32>>>::Output

impl BitAnd<&Wrapping<i64>> for &Wrapping<i64>

type Output = <Wrapping<i64> as BitAnd<Wrapping<i64>>>::Output

impl BitAnd<&Wrapping<i64>> for Wrapping<i64>

type Output = <Wrapping<i64> as BitAnd<Wrapping<i64>>>::Output

impl BitAnd<&Wrapping<i128>> for &Wrapping<i128>

type Output = <Wrapping<i128> as BitAnd<Wrapping<i128>>>::Output

impl BitAnd<&Wrapping<i128>> for Wrapping<i128>

type Output = <Wrapping<i128> as BitAnd<Wrapping<i128>>>::Output

impl BitAnd<&Wrapping<isize>> for &Wrapping<isize>

type Output = <Wrapping<isize> as BitAnd<Wrapping<isize>>>::Output

impl BitAnd<&Wrapping<isize>> for Wrapping<isize>

type Output = <Wrapping<isize> as BitAnd<Wrapping<isize>>>::Output

impl BitAnd<&Wrapping<u8>> for &Wrapping<u8>

type Output = <Wrapping<u8> as BitAnd<Wrapping<u8>>>::Output

impl BitAnd<&Wrapping<u8>> for Wrapping<u8>

type Output = <Wrapping<u8> as BitAnd<Wrapping<u8>>>::Output

impl BitAnd<&Wrapping<u16>> for &Wrapping<u16>

type Output = <Wrapping<u16> as BitAnd<Wrapping<u16>>>::Output

impl BitAnd<&Wrapping<u16>> for Wrapping<u16>

type Output = <Wrapping<u16> as BitAnd<Wrapping<u16>>>::Output

impl BitAnd<&Wrapping<u32>> for &Wrapping<u32>

type Output = <Wrapping<u32> as BitAnd<Wrapping<u32>>>::Output

impl BitAnd<&Wrapping<u32>> for Wrapping<u32>

type Output = <Wrapping<u32> as BitAnd<Wrapping<u32>>>::Output

impl BitAnd<&Wrapping<u64>> for &Wrapping<u64>

type Output = <Wrapping<u64> as BitAnd<Wrapping<u64>>>::Output

impl BitAnd<&Wrapping<u64>> for Wrapping<u64>

type Output = <Wrapping<u64> as BitAnd<Wrapping<u64>>>::Output

impl BitAnd<&Wrapping<u128>> for &Wrapping<u128>

type Output = <Wrapping<u128> as BitAnd<Wrapping<u128>>>::Output

impl BitAnd<&Wrapping<u128>> for Wrapping<u128>

type Output = <Wrapping<u128> as BitAnd<Wrapping<u128>>>::Output

impl BitAnd<&Wrapping<usize>> for &Wrapping<usize>

type Output = <Wrapping<usize> as BitAnd<Wrapping<usize>>>::Output

impl BitAnd<&Wrapping<usize>> for Wrapping<usize>

type Output = <Wrapping<usize> as BitAnd<Wrapping<usize>>>::Output

impl BitAnd<&f32x4> for f32x4

type Output = f32x4

impl BitAnd<&f32x8> for f32x8

type Output = f32x8

impl BitAnd<&f64x2> for f64x2

type Output = f64x2

impl BitAnd<&f64x4> for f64x4

type Output = f64x4

impl BitAnd<&i8x16> for i8x16

type Output = i8x16

impl BitAnd<&i8x32> for i8x32

type Output = i8x32

impl BitAnd<&i16x8> for i16x8

type Output = i16x8

impl BitAnd<&i16x16> for i16x16

type Output = i16x16

impl BitAnd<&i32x4> for i32x4

type Output = i32x4

impl BitAnd<&i32x8> for i32x8

type Output = i32x8

impl BitAnd<&i64x2> for i64x2

type Output = i64x2

impl BitAnd<&u8x16> for u8x16

type Output = u8x16

impl BitAnd<&u16x8> for u16x8

type Output = u16x8

impl BitAnd<&u32x4> for u32x4

type Output = u32x4

impl BitAnd<&u32x8> for u32x8

type Output = u32x8

impl BitAnd<&u64x2> for u64x2

type Output = u64x2

impl BitAnd<&u64x4> for u64x4

type Output = u64x4

impl BitAnd<bool> for bool

type Output = bool

impl BitAnd<i8> for i8

type Output = i8

impl BitAnd<i16> for i16

type Output = i16

impl BitAnd<i32> for i32

type Output = i32

impl BitAnd<i64> for i64

type Output = i64

impl BitAnd<i128> for i128

type Output = i128

impl BitAnd<isize> for isize

type Output = isize

impl BitAnd<u8> for u8

type Output = u8

impl BitAnd<u16> for u16

type Output = u16

impl BitAnd<u32> for u32

type Output = u32

impl BitAnd<u64> for u64

type Output = u64

impl BitAnd<u128> for u128

type Output = u128

impl BitAnd<usize> for usize

type Output = usize

impl BitAnd<Saturating<i8>> for Saturating<i8>

type Output = Saturating<i8>

impl BitAnd<Saturating<i16>> for Saturating<i16>

type Output = Saturating<i16>

impl BitAnd<Saturating<i32>> for Saturating<i32>

type Output = Saturating<i32>

impl BitAnd<Saturating<i64>> for Saturating<i64>

type Output = Saturating<i64>

impl BitAnd<Saturating<i128>> for Saturating<i128>

type Output = Saturating<i128>

impl BitAnd<Saturating<isize>> for Saturating<isize>

type Output = Saturating<isize>

impl BitAnd<Saturating<u8>> for Saturating<u8>

type Output = Saturating<u8>

impl BitAnd<Saturating<u16>> for Saturating<u16>

type Output = Saturating<u16>

impl BitAnd<Saturating<u32>> for Saturating<u32>

type Output = Saturating<u32>

impl BitAnd<Saturating<u64>> for Saturating<u64>

type Output = Saturating<u64>

impl BitAnd<Saturating<u128>> for Saturating<u128>

type Output = Saturating<u128>

impl BitAnd<Saturating<usize>> for Saturating<usize>

type Output = Saturating<usize>

impl BitAnd<Wrapping<i8>> for Wrapping<i8>

type Output = Wrapping<i8>

impl BitAnd<Wrapping<i16>> for Wrapping<i16>

type Output = Wrapping<i16>

impl BitAnd<Wrapping<i32>> for Wrapping<i32>

type Output = Wrapping<i32>

impl BitAnd<Wrapping<i64>> for Wrapping<i64>

type Output = Wrapping<i64>

impl BitAnd<Wrapping<i128>> for Wrapping<i128>

type Output = Wrapping<i128>

impl BitAnd<Wrapping<isize>> for Wrapping<isize>

type Output = Wrapping<isize>

impl BitAnd<Wrapping<u8>> for Wrapping<u8>

type Output = Wrapping<u8>

impl BitAnd<Wrapping<u16>> for Wrapping<u16>

type Output = Wrapping<u16>

impl BitAnd<Wrapping<u32>> for Wrapping<u32>

type Output = Wrapping<u32>

impl BitAnd<Wrapping<u64>> for Wrapping<u64>

type Output = Wrapping<u64>

impl BitAnd<Wrapping<u128>> for Wrapping<u128>

type Output = Wrapping<u128>

impl BitAnd<Wrapping<usize>> for Wrapping<usize>

type Output = Wrapping<usize>

impl BitAnd<BigInt> for BigInt

type Output = BigInt

impl BitAnd<BigUint> for BigUint

type Output = BigUint

impl BitAnd<B0> for B1

And with 1 ( 1 & 0 = 0)

type Output = B0

impl BitAnd<B1> for B1

And with 1 ( 1 & 1 = 1)

type Output = B1

impl BitAnd<AutoSimd<[bool; 1]>> for AutoSimd<[bool; 1]>

type Output = AutoSimd<[bool; 1]>

impl BitAnd<AutoSimd<[bool; 2]>> for AutoSimd<[bool; 2]>

type Output = AutoSimd<[bool; 2]>

impl BitAnd<AutoSimd<[bool; 4]>> for AutoSimd<[bool; 4]>

type Output = AutoSimd<[bool; 4]>

impl BitAnd<AutoSimd<[bool; 8]>> for AutoSimd<[bool; 8]>

type Output = AutoSimd<[bool; 8]>

impl BitAnd<AutoSimd<[bool; 16]>> for AutoSimd<[bool; 16]>

type Output = AutoSimd<[bool; 16]>

impl BitAnd<AutoSimd<[bool; 32]>> for AutoSimd<[bool; 32]>

type Output = AutoSimd<[bool; 32]>

impl BitAnd<WideBoolF32x4> for WideBoolF32x4

type Output = WideBoolF32x4

impl BitAnd<f32x4> for f32x4

type Output = f32x4

impl BitAnd<f32x8> for f32x8

type Output = f32x8

impl BitAnd<f64x2> for f64x2

type Output = f64x2

impl BitAnd<f64x4> for f64x4

type Output = f64x4

impl BitAnd<i8x16> for i8x16

type Output = i8x16

impl BitAnd<i8x32> for i8x32

type Output = i8x32

impl BitAnd<i16x8> for i16x8

type Output = i16x8

impl BitAnd<i16x16> for i16x16

type Output = i16x16

impl BitAnd<i32x4> for i32x4

type Output = i32x4

impl BitAnd<i32x8> for i32x8

type Output = i32x8

impl BitAnd<i64x2> for i64x2

type Output = i64x2

impl BitAnd<i64x4> for i64x4

type Output = i64x4

impl BitAnd<m128> for m128

type Output = m128

impl BitAnd<m128d> for m128d

type Output = m128d

impl BitAnd<m128i> for m128i

type Output = m128i

impl BitAnd<u8x16> for u8x16

type Output = u8x16

impl BitAnd<u16x8> for u16x8

type Output = u16x8

impl BitAnd<u32x4> for u32x4

type Output = u32x4

impl BitAnd<u32x8> for u32x8

type Output = u32x8

impl BitAnd<u64x2> for u64x2

type Output = u64x2

impl BitAnd<u64x4> for u64x4

type Output = u64x4

impl<'a> BitAnd<&'a BigInt> for BigInt

type Output = BigInt

impl<'a> BitAnd<&'a BigUint> for BigUint

type Output = BigUint

impl<'a> BitAnd<bool> for &'a bool

type Output = <bool as BitAnd<bool>>::Output

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

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

impl<'a> BitAnd<i16> for &'a i16

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

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

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

impl<'a> BitAnd<i64> for &'a i64

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

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

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

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

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

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

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

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

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

impl<'a> BitAnd<u32> for &'a u32

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

impl<'a> BitAnd<u64> for &'a u64

type Output = <u64 as BitAnd<u64>>::Output

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

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

impl<'a> BitAnd<usize> for &'a usize

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

impl<'a> BitAnd<Saturating<i8>> for &'a Saturating<i8>

type Output = <Saturating<i8> as BitAnd<Saturating<i8>>>::Output

impl<'a> BitAnd<Saturating<i16>> for &'a Saturating<i16>

type Output = <Saturating<i16> as BitAnd<Saturating<i16>>>::Output

impl<'a> BitAnd<Saturating<i32>> for &'a Saturating<i32>

type Output = <Saturating<i32> as BitAnd<Saturating<i32>>>::Output

impl<'a> BitAnd<Saturating<i64>> for &'a Saturating<i64>

type Output = <Saturating<i64> as BitAnd<Saturating<i64>>>::Output

impl<'a> BitAnd<Saturating<i128>> for &'a Saturating<i128>

type Output = <Saturating<i128> as BitAnd<Saturating<i128>>>::Output

impl<'a> BitAnd<Saturating<isize>> for &'a Saturating<isize>

type Output = <Saturating<isize> as BitAnd<Saturating<isize>>>::Output

impl<'a> BitAnd<Saturating<u8>> for &'a Saturating<u8>

type Output = <Saturating<u8> as BitAnd<Saturating<u8>>>::Output

impl<'a> BitAnd<Saturating<u16>> for &'a Saturating<u16>

type Output = <Saturating<u16> as BitAnd<Saturating<u16>>>::Output

impl<'a> BitAnd<Saturating<u32>> for &'a Saturating<u32>

type Output = <Saturating<u32> as BitAnd<Saturating<u32>>>::Output

impl<'a> BitAnd<Saturating<u64>> for &'a Saturating<u64>

type Output = <Saturating<u64> as BitAnd<Saturating<u64>>>::Output

impl<'a> BitAnd<Saturating<u128>> for &'a Saturating<u128>

type Output = <Saturating<u128> as BitAnd<Saturating<u128>>>::Output

impl<'a> BitAnd<Saturating<usize>> for &'a Saturating<usize>

type Output = <Saturating<usize> as BitAnd<Saturating<usize>>>::Output

impl<'a> BitAnd<Wrapping<i8>> for &'a Wrapping<i8>

type Output = <Wrapping<i8> as BitAnd<Wrapping<i8>>>::Output

impl<'a> BitAnd<Wrapping<i16>> for &'a Wrapping<i16>

type Output = <Wrapping<i16> as BitAnd<Wrapping<i16>>>::Output

impl<'a> BitAnd<Wrapping<i32>> for &'a Wrapping<i32>

type Output = <Wrapping<i32> as BitAnd<Wrapping<i32>>>::Output

impl<'a> BitAnd<Wrapping<i64>> for &'a Wrapping<i64>

type Output = <Wrapping<i64> as BitAnd<Wrapping<i64>>>::Output

impl<'a> BitAnd<Wrapping<i128>> for &'a Wrapping<i128>

type Output = <Wrapping<i128> as BitAnd<Wrapping<i128>>>::Output

impl<'a> BitAnd<Wrapping<isize>> for &'a Wrapping<isize>

type Output = <Wrapping<isize> as BitAnd<Wrapping<isize>>>::Output

impl<'a> BitAnd<Wrapping<u8>> for &'a Wrapping<u8>

type Output = <Wrapping<u8> as BitAnd<Wrapping<u8>>>::Output

impl<'a> BitAnd<Wrapping<u16>> for &'a Wrapping<u16>

type Output = <Wrapping<u16> as BitAnd<Wrapping<u16>>>::Output

impl<'a> BitAnd<Wrapping<u32>> for &'a Wrapping<u32>

type Output = <Wrapping<u32> as BitAnd<Wrapping<u32>>>::Output

impl<'a> BitAnd<Wrapping<u64>> for &'a Wrapping<u64>

type Output = <Wrapping<u64> as BitAnd<Wrapping<u64>>>::Output

impl<'a> BitAnd<Wrapping<u128>> for &'a Wrapping<u128>

type Output = <Wrapping<u128> as BitAnd<Wrapping<u128>>>::Output

impl<'a> BitAnd<Wrapping<usize>> for &'a Wrapping<usize>

type Output = <Wrapping<usize> as BitAnd<Wrapping<usize>>>::Output

impl<'a> BitAnd<BigInt> for &'a BigInt

type Output = BigInt

impl<'a> BitAnd<BigUint> for &'a BigUint

type Output = BigUint

impl<'a, 'b> BitAnd<&'b BigInt> for &'a BigInt

type Output = BigInt

impl<'a, 'b> BitAnd<&'b BigUint> for &'a BigUint

type Output = BigUint

impl<'a, A, B, S, S2, D, E> BitAnd<&'a ArrayBase<S2, E>> for &'a ArrayBase<S, D>where A: Clone + BitAnd<B, Output = A>, B: Clone, S: Data<Elem = A>, S2: Data<Elem = B>, D: Dimension + DimMax<E>, E: Dimension,

Perform elementwise bit and 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.

type Output = ArrayBase<OwnedRepr<A>, <D as DimMax<E>>::Output>

impl<'a, A, B, S, S2, D, E> BitAnd<&'a ArrayBase<S2, E>> for ArrayBase<S, D>where A: Clone + BitAnd<B, Output = A>, B: Clone, S: DataOwned<Elem = A> + DataMut, S2: Data<Elem = B>, D: Dimension + DimMax<E>, E: Dimension,

Perform elementwise bit and 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.

type Output = ArrayBase<S, <D as DimMax<E>>::Output>

impl<'a, A, B, S, S2, D, E> BitAnd<ArrayBase<S2, E>> for &'a ArrayBase<S, D>where A: Clone + BitAnd<B, Output = B>, B: Clone, S: Data<Elem = A>, S2: DataOwned<Elem = B> + DataMut, D: Dimension, E: Dimension + DimMax<D>,

Perform elementwise bit and 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.

type Output = ArrayBase<S2, <E as DimMax<D>>::Output>

impl<'a, A, S, D, B> BitAnd<B> for &'a ArrayBase<S, D>where A: Clone + BitAnd<B, Output = A>, S: Data<Elem = A>, D: Dimension, B: ScalarOperand,

Perform elementwise bit and between the reference self and the scalar x, and return the result as a new Array.

type Output = ArrayBase<OwnedRepr<A>, D>

impl<'a, S, D> BitAnd<&'a ArrayBase<S, D>> for boolwhere S: Data<Elem = bool>, D: Dimension,

type Output = ArrayBase<OwnedRepr<bool>, D>

impl<'a, S, D> BitAnd<&'a ArrayBase<S, D>> for i8where S: Data<Elem = i8>, D: Dimension,

type Output = ArrayBase<OwnedRepr<i8>, D>

impl<'a, S, D> BitAnd<&'a ArrayBase<S, D>> for i16where S: Data<Elem = i16>, D: Dimension,

type Output = ArrayBase<OwnedRepr<i16>, D>

impl<'a, S, D> BitAnd<&'a ArrayBase<S, D>> for i32where S: Data<Elem = i32>, D: Dimension,

type Output = ArrayBase<OwnedRepr<i32>, D>

impl<'a, S, D> BitAnd<&'a ArrayBase<S, D>> for i64where S: Data<Elem = i64>, D: Dimension,

type Output = ArrayBase<OwnedRepr<i64>, D>

impl<'a, S, D> BitAnd<&'a ArrayBase<S, D>> for i128where S: Data<Elem = i128>, D: Dimension,

type Output = ArrayBase<OwnedRepr<i128>, D>

impl<'a, S, D> BitAnd<&'a ArrayBase<S, D>> for isizewhere S: Data<Elem = isize>, D: Dimension,

type Output = ArrayBase<OwnedRepr<isize>, D>

impl<'a, S, D> BitAnd<&'a ArrayBase<S, D>> for u8where S: Data<Elem = u8>, D: Dimension,

type Output = ArrayBase<OwnedRepr<u8>, D>

impl<'a, S, D> BitAnd<&'a ArrayBase<S, D>> for u16where S: Data<Elem = u16>, D: Dimension,

type Output = ArrayBase<OwnedRepr<u16>, D>

impl<'a, S, D> BitAnd<&'a ArrayBase<S, D>> for u32where S: Data<Elem = u32>, D: Dimension,

type Output = ArrayBase<OwnedRepr<u32>, D>

impl<'a, S, D> BitAnd<&'a ArrayBase<S, D>> for u64where S: Data<Elem = u64>, D: Dimension,

type Output = ArrayBase<OwnedRepr<u64>, D>

impl<'a, S, D> BitAnd<&'a ArrayBase<S, D>> for u128where S: Data<Elem = u128>, D: Dimension,

type Output = ArrayBase<OwnedRepr<u128>, D>

impl<'a, S, D> BitAnd<&'a ArrayBase<S, D>> for usizewhere S: Data<Elem = usize>, D: Dimension,

type Output = ArrayBase<OwnedRepr<usize>, D>

impl<'lhs, 'rhs, T, const LANES: usize> BitAnd<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where T: SimdElement, Simd<T, LANES>: BitAnd<Simd<T, LANES>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

impl<A, B, S, S2, D, E> BitAnd<ArrayBase<S2, E>> for ArrayBase<S, D>where A: Clone + BitAnd<B, Output = A>, B: Clone, S: DataOwned<Elem = A> + DataMut, S2: Data<Elem = B>, D: Dimension + DimMax<E>, E: Dimension,

Perform elementwise bit and 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.

type Output = ArrayBase<S, <D as DimMax<E>>::Output>

impl<A, S, D, B> BitAnd<B> for ArrayBase<S, D>where A: Clone + BitAnd<B, Output = A>, S: DataOwned<Elem = A> + DataMut, D: Dimension, B: ScalarOperand,

Perform elementwise bit and 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>

impl<Rhs> BitAnd<Rhs> for B0where Rhs: Bit,

And with 0 ( 0 & B = 0)

type Output = B0

impl<S, D> BitAnd<ArrayBase<S, D>> for boolwhere S: DataOwned<Elem = bool> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> BitAnd<ArrayBase<S, D>> for i8where S: DataOwned<Elem = i8> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> BitAnd<ArrayBase<S, D>> for i16where S: DataOwned<Elem = i16> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> BitAnd<ArrayBase<S, D>> for i32where S: DataOwned<Elem = i32> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> BitAnd<ArrayBase<S, D>> for i64where S: DataOwned<Elem = i64> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> BitAnd<ArrayBase<S, D>> for i128where S: DataOwned<Elem = i128> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> BitAnd<ArrayBase<S, D>> for isizewhere S: DataOwned<Elem = isize> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> BitAnd<ArrayBase<S, D>> for u8where S: DataOwned<Elem = u8> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> BitAnd<ArrayBase<S, D>> for u16where S: DataOwned<Elem = u16> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> BitAnd<ArrayBase<S, D>> for u32where S: DataOwned<Elem = u32> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> BitAnd<ArrayBase<S, D>> for u64where S: DataOwned<Elem = u64> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> BitAnd<ArrayBase<S, D>> for u128where S: DataOwned<Elem = u128> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<S, D> BitAnd<ArrayBase<S, D>> for usizewhere S: DataOwned<Elem = usize> + DataMut, D: Dimension,

type Output = ArrayBase<S, D>

impl<T> BitAnd<Rect_<T>> for Rect_<T>where Rect_<T>: BitAndAssign<Rect_<T>>,

type Output = Rect_<T>

impl<T, A> BitAnd<&BTreeSet<T, A>> for &BTreeSet<T, A>where T: Ord + Clone, A: Allocator + Clone,

type Output = BTreeSet<T, A>

impl<T, S> BitAnd<&HashSet<T, S>> for &HashSet<T, S>where T: Eq + Hash + Clone, S: BuildHasher + Default,

type Output = HashSet<T, S>

impl<T, const LANES: usize> BitAnd<&Simd<T, LANES>> for Simd<T, LANES>where T: SimdElement, Simd<T, LANES>: BitAnd<Simd<T, LANES>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

impl<T, const LANES: usize> BitAnd<bool> for Mask<T, LANES>where T: MaskElement, LaneCount<LANES>: SupportedLaneCount,

type Output = Mask<T, LANES>

impl<T, const LANES: usize> BitAnd<Mask<T, LANES>> for boolwhere T: MaskElement, LaneCount<LANES>: SupportedLaneCount,

type Output = Mask<T, LANES>

impl<T, const LANES: usize> BitAnd<Mask<T, LANES>> for Mask<T, LANES>where T: MaskElement, LaneCount<LANES>: SupportedLaneCount,

type Output = Mask<T, LANES>

impl<T, const LANES: usize> BitAnd<Simd<T, LANES>> for &Simd<T, LANES>where T: SimdElement, Simd<T, LANES>: BitAnd<Simd<T, LANES>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

impl<Ul, Bl, Ur> BitAnd<Ur> for UInt<Ul, Bl>where Ul: Unsigned, Bl: Bit, Ur: Unsigned, UInt<Ul, Bl>: PrivateAnd<Ur>, <UInt<Ul, Bl> as PrivateAnd<Ur>>::Output: Trim,

Anding unsigned integers. We use our PrivateAnd operator and then Trim the output.

type Output = <<UInt<Ul, Bl> as PrivateAnd<Ur>>::Output as Trim>::Output

impl<Ur> BitAnd<Ur> for UTermwhere Ur: Unsigned,

0 & X = 0

type Output = UTerm

impl<const N: usize> BitAnd<Simd<i8, N>> for Simd<i8, N>where i8: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<i8, N>

impl<const N: usize> BitAnd<Simd<i16, N>> for Simd<i16, N>where i16: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<i16, N>

impl<const N: usize> BitAnd<Simd<i32, N>> for Simd<i32, N>where i32: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<i32, N>

impl<const N: usize> BitAnd<Simd<i64, N>> for Simd<i64, N>where i64: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<i64, N>

impl<const N: usize> BitAnd<Simd<isize, N>> for Simd<isize, N>where isize: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<isize, N>

impl<const N: usize> BitAnd<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<u8, N>

impl<const N: usize> BitAnd<Simd<u16, N>> for Simd<u16, N>where u16: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<u16, N>

impl<const N: usize> BitAnd<Simd<u32, N>> for Simd<u32, N>where u32: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<u32, N>

impl<const N: usize> BitAnd<Simd<u64, N>> for Simd<u64, N>where u64: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<u64, N>

impl<const N: usize> BitAnd<Simd<usize, N>> for Simd<usize, N>where usize: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<usize, N>