binar 0.1.1

High-performance binary arithmetic.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

use crate::{BitLength, Bitwise, BitwiseMut, BitwisePair, BitwisePairMut, IntoBitIterator};

impl Bitwise for bool {
    #[inline]
    fn index(&self, index: usize) -> bool {
        assert_eq!(index, 0);
        *self
    }

    #[inline]
    fn weight(&self) -> usize {
        usize::from(*self)
    }

    #[inline]
    fn support(&self) -> impl sorted_iter::SortedIterator<Item = usize> {
        if *self { 0..1 } else { 0..0 }
    }
}

impl BitwiseMut for bool {
    #[inline]
    fn assign_index(&mut self, index: usize, to: bool) {
        assert_eq!(index, 0);
        *self = to;
    }

    #[inline]
    fn negate_index(&mut self, index: usize) {
        assert_eq!(index, 0);
        *self ^= true;
    }

    #[inline]
    fn clear_bits(&mut self) {
        *self = false;
    }
}

impl BitwisePair for bool {
    #[inline]
    fn dot(&self, other: &bool) -> bool {
        *self && *other
    }

    #[inline]
    fn and_weight(&self, other: &bool) -> usize {
        usize::from(*self && *other)
    }

    #[inline]
    fn or_weight(&self, other: &bool) -> usize {
        usize::from(*self || *other)
    }

    #[inline]
    fn xor_weight(&self, other: &bool) -> usize {
        usize::from(*self ^ *other)
    }
}

impl BitwisePairMut for bool {
    #[inline]
    fn assign(&mut self, other: &bool) {
        *self = *other;
    }

    #[inline]
    fn bitxor_assign(&mut self, other: &bool) {
        *self ^= *other;
    }

    #[inline]
    fn bitand_assign(&mut self, other: &Self) {
        *self &= *other;
    }

    #[inline]
    fn bitor_assign(&mut self, other: &Self) {
        *self |= *other;
    }
}

impl IntoBitIterator for &bool {
    type BitIterator = std::iter::Once<bool>;
    fn iter_bits(self) -> Self::BitIterator {
        std::iter::once(*self)
    }
}

impl BitLength for bool {
    #[inline]
    fn bit_len(&self) -> usize {
        1
    }
    const BLOCK_BIT_LEN: usize = 1;
}