Trait grafix_toolbox::uses::ops::BitXor1.0.0[−][src]

pub trait BitXor<Rhs = Self> {
    type Output;
    fn bitxor(self, rhs: Rhs) -> Self::Output;
}
Expand description

The bitwise XOR operator ^.

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

Examples

An implementation of BitXor that lifts ^ to a wrapper around bool.

use std::ops::BitXor;

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

impl BitXor for Scalar {
    type Output = Self;

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

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

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

use std::ops::BitXor;

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

impl BitXor for BooleanVector {
    type Output = Self;

    fn bitxor(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![false, true, true, false]);
assert_eq!(bv1 ^ bv2, expected);

Associated Types

The resulting type after applying the ^ operator.

Required methods

Performs the ^ operation.

Examples

assert_eq!(true ^ false, true);
assert_eq!(true ^ true, false);
assert_eq!(5u8 ^ 1u8, 4);
assert_eq!(5u8 ^ 2u8, 7);

Implementations on Foreign Types

Returns the symmetric difference 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![3, 4, 5].into_iter().collect();

let set = &a ^ &b;

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

Returns the left flags, but with all the right flags toggled.

Returns the left flags, but with all the right flags toggled.

Returns the left flags, but with all the right flags toggled.

Returns the symmetric difference of self and rhs as a new AHashSet<T, S>.

Examples

use ahash::AHashSet;

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

let set = &a ^ &b;

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

0 ^ X = X

Xoring unsigned integers. We use our PrivateXor operator and then Trim the output.

Xor between 0 and 0 ( 0 ^ 0 = 0)

Xor between 1 and 1 ( 1 ^ 1 = 0)

Xor between 0 and 1 ( 0 ^ 1 = 1)

Xor between 1 and 0 ( 1 ^ 0 = 1)

Implementors