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
98
99
100
101
102
103
104
105
106
107
108
109

use crate::bit::bitwise_via_borrow::{
    BitwiseMutViaBorrow, BitwisePairMutViaBorrow, BitwisePairViaBorrow, BitwiseViaBorrow,
};
use crate::bit::bitwise_via_iter::{BitwisePairMutViaIter, BitwisePairViaIter};
use crate::{BitLength, bit::standard_types::support_iterator};
use crate::{Bitwise, BitwiseMut, BitwisePair, BitwisePairMut, IntoBitIterator};
use std::iter::Copied;

// Bit traits for Vec<bool>, [bool], [bool;SIZE], Vec<bool>

impl<'life> IntoBitIterator for &'life [bool] {
    type BitIterator = Copied<<&'life [bool] as IntoIterator>::IntoIter>;
    fn iter_bits(self) -> Self::BitIterator {
        self.iter().copied()
    }
}

impl<'life> IntoBitIterator for &'life Vec<bool> {
    type BitIterator = Copied<<&'life [bool] as IntoIterator>::IntoIter>;
    fn iter_bits(self) -> Self::BitIterator {
        self.iter().copied()
    }
}

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

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

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

    #[inline]
    fn weight(&self) -> usize {
        self.iter().filter(|bit| **bit).count()
    }

    #[inline]
    fn support(&self) -> impl sorted_iter::SortedIterator<Item = usize> {
        support_iterator(self.iter_bits())
    }
}

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

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

    #[inline]
    fn clear_bits(&mut self) {
        for val in self.iter_mut() {
            *val = false;
        }
    }
}

delegate_bitwise_pair!([bool], [bool], BitwisePairViaIter<[bool]>);
delegate_bitwise_pair_mut!([bool], [bool], BitwisePairMutViaIter<[bool]>);

delegate_bitwise!(Vec<bool>, BitwiseViaBorrow<[bool]>);
impl<const SIZE: usize> Bitwise for [bool; SIZE] {
    delegate_bitwise_body! {BitwiseViaBorrow<[bool]>}
}

delegate_bitwise_mut!(Vec<bool>, BitwiseMutViaBorrow<[bool]>);
impl<const SIZE: usize> BitwiseMut for [bool; SIZE] {
    delegate_bitwise_mut_body! {BitwiseMutViaBorrow<[bool]>}
}

delegate_bitwise_pair!([bool], Vec<bool>, BitwisePairViaBorrow<Vec<bool>, [bool]>);
delegate_bitwise_pair!(Vec<bool>, [bool], BitwisePairViaBorrow<[bool], [bool]>);
delegate_bitwise_pair!(Vec<bool>, Vec<bool>, BitwisePairViaBorrow<Vec<bool>, [bool]>);
impl<const SIZE: usize> BitwisePair for [bool; SIZE] {
    delegate_bitwise_pair_body! {[bool; SIZE], BitwisePairViaBorrow<[bool; SIZE],[bool]>}
}

delegate_bitwise_pair_mut!([bool], Vec<bool>, BitwisePairMutViaBorrow<Vec<bool>, [bool]>);
delegate_bitwise_pair_mut!(Vec<bool>, [bool], BitwisePairMutViaBorrow<[bool], [bool]>);
delegate_bitwise_pair_mut!(Vec<bool>, Vec<bool>, BitwisePairMutViaBorrow<Vec<bool>, [bool]>);
impl<const SIZE: usize> BitwisePairMut for [bool; SIZE] {
    delegate_bitwise_pair_mut_body! {[bool; SIZE], BitwisePairMutViaBorrow<[bool; SIZE],[bool]>}
}

delegate_bitwise!(&[bool], BitwiseViaBorrow<[bool]>);
delegate_bitwise!(&mut [bool], BitwiseViaBorrow<[bool]>);
delegate_bitwise_mut!(&mut [bool], BitwiseMutViaBorrow<[bool]>);

delegate_bitwise_pair!(&[bool], &[bool], BitwisePairViaBorrow<&[bool], [bool]>);
delegate_bitwise_pair!(&mut [bool], &mut [bool], BitwisePairViaBorrow<&mut [bool], [bool]>);