Trait tract_hir::internal::tract_downcast_rs::__std::ops::BitAnd

#[lang = "bitand"]pub trait BitAnd<Rhs = Self> {
    type Output;
#[must_use]    pub 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);

Associated Types

type Output

The resulting type after applying the & operator.

Loading content...

Required methods

#[must_use]pub 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);

Loading content...

Implementations on Foreign Types

impl BitAnd<i32> for i32

type Output = i32

pub fn bitand(self, rhs: i32) -> i32

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

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

pub fn bitand(self, other: &i16) -> <i16 as BitAnd<i16>>::Output

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

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

pub fn bitand(self, other: &i8) -> <i8 as BitAnd<i8>>::Output

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

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

pub fn bitand(self, other: &i128) -> <i128 as BitAnd<i128>>::Output

impl BitAnd<u16> for u16

type Output = u16

pub fn bitand(self, rhs: u16) -> u16

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

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

pub fn bitand(self, other: &i32) -> <i32 as BitAnd<i32>>::Output

impl BitAnd<bool> for bool

type Output = bool

pub fn bitand(self, rhs: bool) -> bool

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

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

pub fn bitand(self, other: &usize) -> <usize as BitAnd<usize>>::Output

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

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

pub fn bitand(self, other: &u128) -> <u128 as BitAnd<u128>>::Output

impl BitAnd<u8> for u8

type Output = u8

pub fn bitand(self, rhs: u8) -> u8

impl BitAnd<i16> for i16

type Output = i16

pub fn bitand(self, rhs: i16) -> i16

impl<'_, '_> BitAnd<&'_ u8> for &'_ u8

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

pub fn bitand(self, other: &u8) -> <u8 as BitAnd<u8>>::Output

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

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

pub fn bitand(self, other: i128) -> <i128 as BitAnd<i128>>::Output

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

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

pub fn bitand(self, other: &u128) -> <u128 as BitAnd<u128>>::Output

impl<'_, '_> BitAnd<&'_ bool> for &'_ bool

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

pub fn bitand(self, other: &bool) -> <bool as BitAnd<bool>>::Output

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

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

pub fn bitand(self, other: &u64) -> <u64 as BitAnd<u64>>::Output

impl BitAnd<u128> for u128

type Output = u128

pub fn bitand(self, rhs: u128) -> u128

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

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

pub fn bitand(self, other: u128) -> <u128 as BitAnd<u128>>::Output

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

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

pub fn bitand(self, other: &i128) -> <i128 as BitAnd<i128>>::Output

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

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

pub fn bitand(self, other: &u16) -> <u16 as BitAnd<u16>>::Output

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

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

pub fn bitand(self, other: &u8) -> <u8 as BitAnd<u8>>::Output

impl BitAnd<i64> for i64

type Output = i64

pub fn bitand(self, rhs: i64) -> i64

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

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

pub fn bitand(self, other: &i64) -> <i64 as BitAnd<i64>>::Output

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

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

pub fn bitand(self, other: &u32) -> <u32 as BitAnd<u32>>::Output

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

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

pub fn bitand(self, other: u64) -> <u64 as BitAnd<u64>>::Output

impl<'_, '_> BitAnd<&'_ u64> for &'_ u64

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

pub fn bitand(self, other: &u64) -> <u64 as BitAnd<u64>>::Output

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

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

pub fn bitand(self, other: u8) -> <u8 as BitAnd<u8>>::Output

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

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

pub fn bitand(self, other: &usize) -> <usize as BitAnd<usize>>::Output

impl<'_, '_> BitAnd<&'_ i32> for &'_ i32

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

pub fn bitand(self, other: &i32) -> <i32 as BitAnd<i32>>::Output

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

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

pub fn bitand(self, other: &i16) -> <i16 as BitAnd<i16>>::Output

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

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

pub fn bitand(self, other: isize) -> <isize as BitAnd<isize>>::Output

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

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

pub fn bitand(self, other: &isize) -> <isize as BitAnd<isize>>::Output

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

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

pub fn bitand(self, other: i8) -> <i8 as BitAnd<i8>>::Output

impl BitAnd<isize> for isize

type Output = isize

pub fn bitand(self, rhs: isize) -> isize

impl BitAnd<i128> for i128

type Output = i128

pub fn bitand(self, rhs: i128) -> i128

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

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

pub fn bitand(self, other: i32) -> <i32 as BitAnd<i32>>::Output

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

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

pub fn bitand(self, other: bool) -> <bool as BitAnd<bool>>::Output

impl BitAnd<u64> for u64

type Output = u64

pub fn bitand(self, rhs: u64) -> u64

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

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

pub fn bitand(self, other: u32) -> <u32 as BitAnd<u32>>::Output

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

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

pub fn bitand(self, other: i64) -> <i64 as BitAnd<i64>>::Output

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

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

pub fn bitand(self, other: &u16) -> <u16 as BitAnd<u16>>::Output

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

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

pub fn bitand(self, other: u16) -> <u16 as BitAnd<u16>>::Output

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

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

pub fn bitand(self, other: &isize) -> <isize as BitAnd<isize>>::Output

impl BitAnd<u32> for u32

type Output = u32

pub fn bitand(self, rhs: u32) -> u32

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

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

pub fn bitand(self, other: &i64) -> <i64 as BitAnd<i64>>::Output

impl BitAnd<usize> for usize

type Output = usize

pub fn bitand(self, rhs: usize) -> usize

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

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

pub fn bitand(self, other: &u32) -> <u32 as BitAnd<u32>>::Output

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

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

pub fn bitand(self, other: &bool) -> <bool as BitAnd<bool>>::Output

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

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

pub fn bitand(self, other: i16) -> <i16 as BitAnd<i16>>::Output

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

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

pub fn bitand(self, other: &i8) -> <i8 as BitAnd<i8>>::Output

impl BitAnd<i8> for i8

type Output = i8

pub fn bitand(self, rhs: i8) -> i8

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

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

pub fn bitand(self, other: usize) -> <usize as BitAnd<usize>>::Output

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

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

pub fn bitand(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i128>, D>

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

type Output = ArrayBase<S, D>

pub fn bitand(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

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

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

pub fn bitand(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u128>, D>

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

type Output = ArrayBase<S, D>

pub fn bitand(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

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

type Output = ArrayBase<S, D>

pub fn bitand(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

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

type Output = ArrayBase<S, D>

pub fn bitand(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

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

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

pub fn bitand(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u16>, D>

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

type Output = ArrayBase<S, D>

pub fn bitand(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

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

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

pub fn bitand(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i32>, D>

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

type Output = ArrayBase<S, D>

pub fn bitand(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

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

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

pub fn bitand(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u64>, D>

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

type Output = ArrayBase<S, D>

pub fn bitand(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

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

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

pub fn bitand(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u32>, D>

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

type Output = ArrayBase<S, D>

pub fn bitand(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

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

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

pub fn bitand(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i64>, D>

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

type Output = ArrayBase<S, D>

pub fn bitand(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

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

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

pub fn bitand(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i16>, D>

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

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

pub fn bitand(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i8>, D>

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

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

pub fn bitand(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u8>, D>

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

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

pub fn bitand(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<bool>, D>

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

type Output = ArrayBase<S, D>

pub fn bitand(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

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

type Output = ArrayBase<S, D>

pub fn bitand(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

Loading content...

Implementors

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

type Output = Wrapping<i8>

pub fn bitand(self, other: Wrapping<i8>) -> Wrapping<i8>

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

type Output = Wrapping<i16>

pub fn bitand(self, other: Wrapping<i16>) -> Wrapping<i16>

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

type Output = Wrapping<i32>

pub fn bitand(self, other: Wrapping<i32>) -> Wrapping<i32>

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

type Output = Wrapping<i64>

pub fn bitand(self, other: Wrapping<i64>) -> Wrapping<i64>

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

type Output = Wrapping<i128>

pub fn bitand(self, other: Wrapping<i128>) -> Wrapping<i128>

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

type Output = Wrapping<isize>

pub fn bitand(self, other: Wrapping<isize>) -> Wrapping<isize>

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

type Output = Wrapping<u8>

pub fn bitand(self, other: Wrapping<u8>) -> Wrapping<u8>

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

type Output = Wrapping<u16>

pub fn bitand(self, other: Wrapping<u16>) -> Wrapping<u16>

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

type Output = Wrapping<u32>

pub fn bitand(self, other: Wrapping<u32>) -> Wrapping<u32>

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

type Output = Wrapping<u64>

pub fn bitand(self, other: Wrapping<u64>) -> Wrapping<u64>

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

type Output = Wrapping<u128>

pub fn bitand(self, other: Wrapping<u128>) -> Wrapping<u128>

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

type Output = Wrapping<usize>

pub fn bitand(self, other: Wrapping<usize>) -> Wrapping<usize>

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

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

pub fn bitand(
    self,
    other: &Wrapping<i8>
) -> <Wrapping<i8> as BitAnd<Wrapping<i8>>>::Output

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

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

pub fn bitand(
    self,
    other: &Wrapping<i16>
) -> <Wrapping<i16> as BitAnd<Wrapping<i16>>>::Output

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

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

pub fn bitand(
    self,
    other: &Wrapping<i32>
) -> <Wrapping<i32> as BitAnd<Wrapping<i32>>>::Output

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

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

pub fn bitand(
    self,
    other: &Wrapping<i64>
) -> <Wrapping<i64> as BitAnd<Wrapping<i64>>>::Output

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

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

pub fn bitand(
    self,
    other: &Wrapping<i128>
) -> <Wrapping<i128> as BitAnd<Wrapping<i128>>>::Output

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

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

pub fn bitand(
    self,
    other: &Wrapping<isize>
) -> <Wrapping<isize> as BitAnd<Wrapping<isize>>>::Output

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

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

pub fn bitand(
    self,
    other: &Wrapping<u8>
) -> <Wrapping<u8> as BitAnd<Wrapping<u8>>>::Output

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

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

pub fn bitand(
    self,
    other: &Wrapping<u16>
) -> <Wrapping<u16> as BitAnd<Wrapping<u16>>>::Output

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

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

pub fn bitand(
    self,
    other: &Wrapping<u32>
) -> <Wrapping<u32> as BitAnd<Wrapping<u32>>>::Output

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

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

pub fn bitand(
    self,
    other: &Wrapping<u64>
) -> <Wrapping<u64> as BitAnd<Wrapping<u64>>>::Output

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

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

pub fn bitand(
    self,
    other: &Wrapping<u128>
) -> <Wrapping<u128> as BitAnd<Wrapping<u128>>>::Output

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

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

pub fn bitand(
    self,
    other: &Wrapping<usize>
) -> <Wrapping<usize> as BitAnd<Wrapping<usize>>>::Output

impl<'_, '_> BitAnd<&'_ Wrapping<i8>> for &'_ Wrapping<i8>

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

pub fn bitand(
    self,
    other: &Wrapping<i8>
) -> <Wrapping<i8> as BitAnd<Wrapping<i8>>>::Output

impl<'_, '_> BitAnd<&'_ Wrapping<i16>> for &'_ Wrapping<i16>

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

pub fn bitand(
    self,
    other: &Wrapping<i16>
) -> <Wrapping<i16> as BitAnd<Wrapping<i16>>>::Output

impl<'_, '_> BitAnd<&'_ Wrapping<i32>> for &'_ Wrapping<i32>

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

pub fn bitand(
    self,
    other: &Wrapping<i32>
) -> <Wrapping<i32> as BitAnd<Wrapping<i32>>>::Output

impl<'_, '_> BitAnd<&'_ Wrapping<i64>> for &'_ Wrapping<i64>

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

pub fn bitand(
    self,
    other: &Wrapping<i64>
) -> <Wrapping<i64> as BitAnd<Wrapping<i64>>>::Output

impl<'_, '_> BitAnd<&'_ Wrapping<i128>> for &'_ Wrapping<i128>

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

pub fn bitand(
    self,
    other: &Wrapping<i128>
) -> <Wrapping<i128> as BitAnd<Wrapping<i128>>>::Output

impl<'_, '_> BitAnd<&'_ Wrapping<isize>> for &'_ Wrapping<isize>

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

pub fn bitand(
    self,
    other: &Wrapping<isize>
) -> <Wrapping<isize> as BitAnd<Wrapping<isize>>>::Output

impl<'_, '_> BitAnd<&'_ Wrapping<u8>> for &'_ Wrapping<u8>

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

pub fn bitand(
    self,
    other: &Wrapping<u8>
) -> <Wrapping<u8> as BitAnd<Wrapping<u8>>>::Output

impl<'_, '_> BitAnd<&'_ Wrapping<u16>> for &'_ Wrapping<u16>

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

pub fn bitand(
    self,
    other: &Wrapping<u16>
) -> <Wrapping<u16> as BitAnd<Wrapping<u16>>>::Output

impl<'_, '_> BitAnd<&'_ Wrapping<u32>> for &'_ Wrapping<u32>

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

pub fn bitand(
    self,
    other: &Wrapping<u32>
) -> <Wrapping<u32> as BitAnd<Wrapping<u32>>>::Output

impl<'_, '_> BitAnd<&'_ Wrapping<u64>> for &'_ Wrapping<u64>

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

pub fn bitand(
    self,
    other: &Wrapping<u64>
) -> <Wrapping<u64> as BitAnd<Wrapping<u64>>>::Output

impl<'_, '_> BitAnd<&'_ Wrapping<u128>> for &'_ Wrapping<u128>

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

pub fn bitand(
    self,
    other: &Wrapping<u128>
) -> <Wrapping<u128> as BitAnd<Wrapping<u128>>>::Output

impl<'_, '_> BitAnd<&'_ Wrapping<usize>> for &'_ Wrapping<usize>

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

pub fn bitand(
    self,
    other: &Wrapping<usize>
) -> <Wrapping<usize> as BitAnd<Wrapping<usize>>>::Output

impl<'_, '_, T> BitAnd<&'_ BTreeSet<T>> for &'_ BTreeSet<T> where
    T: Ord + Clone, 

type Output = BTreeSet<T>

pub fn bitand(self, rhs: &BTreeSet<T>) -> BTreeSet<T>

Returns the intersection of self and rhs as a new BTreeSet<T>.

Examples

use std::collections::BTreeSet;

let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect();
let b: BTreeSet<_> = vec![2, 3, 4].into_iter().collect();

let result = &a & &b;
let result_vec: Vec<_> = result.into_iter().collect();
assert_eq!(result_vec, [2, 3]);

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

type Output = HashSet<T, S>

pub fn bitand(self, rhs: &HashSet<T, S>) -> HashSet<T, S>

Returns the intersection of self and rhs as a new HashSet<T, S>.

Examples

use std::collections::HashSet;

let a: HashSet<_> = vec![1, 2, 3].into_iter().collect();
let b: HashSet<_> = vec![2, 3, 4].into_iter().collect();

let set = &a & &b;

let mut i = 0;
let expected = [2, 3];
for x in &set {
    assert!(expected.contains(x));
    i += 1;
}
assert_eq!(i, expected.len());

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

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

pub fn bitand(
    self,
    other: Wrapping<i8>
) -> <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

pub fn bitand(
    self,
    other: Wrapping<i16>
) -> <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

pub fn bitand(
    self,
    other: Wrapping<i32>
) -> <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

pub fn bitand(
    self,
    other: Wrapping<i64>
) -> <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

pub fn bitand(
    self,
    other: Wrapping<i128>
) -> <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

pub fn bitand(
    self,
    other: Wrapping<isize>
) -> <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

pub fn bitand(
    self,
    other: Wrapping<u8>
) -> <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

pub fn bitand(
    self,
    other: Wrapping<u16>
) -> <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

pub fn bitand(
    self,
    other: Wrapping<u32>
) -> <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

pub fn bitand(
    self,
    other: Wrapping<u64>
) -> <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

pub fn bitand(
    self,
    other: Wrapping<u128>
) -> <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

pub fn bitand(
    self,
    other: Wrapping<usize>
) -> <Wrapping<usize> as BitAnd<Wrapping<usize>>>::Output

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

Perform elementwise bit and 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 bitand(self, rhs: &'a ArrayBase<S2, E>) -> ArrayBase<OwnedRepr<A>, D>

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

Perform elementwise bit and 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 bitand(self, rhs: &ArrayBase<S2, E>) -> ArrayBase<S, D>

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

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>

pub fn bitand(self, x: B) -> ArrayBase<OwnedRepr<A>, D>

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

Perform elementwise bit and 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 bitand(self, rhs: ArrayBase<S2, E>) -> ArrayBase<S, D>

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

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>

pub fn bitand(self, x: B) -> ArrayBase<S, D>

Loading content...