deepmesa_collections/bitvec/
traits.rs

1/*
2   BitVector: A fast contiguous growable array of bits allocated
3   on the heap that allows storing and manipulating an arbitrary
4   number of bits. This collection is backed by a Vector<u8> which
5   manages the underlying memory.
6
7   Copyright 2021 "Rahul Singh <rsingh@arrsingh.com>"
8
9   Licensed under the Apache License, Version 2.0 (the "License");
10   you may not use this file except in compliance with the License.
11   You may obtain a copy of the License at
12
13       http://www.apache.org/licenses/LICENSE-2.0
14
15   Unless required by applicable law or agreed to in writing, software
16   distributed under the License is distributed on an "AS IS" BASIS,
17   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18   See the License for the specific language governing permissions and
19   limitations under the License.
20*/
21
22use crate::bitvec::BitCount;
23
24#[inline(always)]
25fn msb_ones(n: u8) -> u8 {
26    debug_assert_bounds_check!(n, 8);
27    match n {
28        0 => 0u8,
29        _ => 255u8 << (8 - n),
30    }
31}
32
33#[inline(always)]
34fn lsb_ones(n: u8) -> u8 {
35    debug_assert_bounds_check!(n, 8);
36    match n {
37        0 => 0u8,
38        _ => 255u8 >> (8 - n),
39    }
40}
41
42macro_rules! msb_nth_zero {
43    ($n:expr) => {
44        msb_ones($n) | lsb_ones(7 - $n)
45    };
46}
47
48macro_rules! lsb_nth_zero {
49    ($n:expr) => {
50        msb_ones(7 - $n) | lsb_ones($n)
51    };
52}
53
54/// Returns a value with some bits of self cleared.
55pub trait BitwiseClear {
56    type Output;
57    /// Returns a value with the `n` LSB bits of `self` cleared.
58    /// # Examples
59    /// ```
60    /// use deepmesa_collections::bitvec::BitwiseClear;
61    ///
62    /// let val:u8 = 0b1011_1100;
63    /// assert_eq!(val.clear_lsb(4), 0b1011_0000);
64    /// ```
65    fn clear_lsb(self, n: u8) -> Self::Output;
66    /// Returns a value with the `n` MSB bits of `self` cleared.
67    /// # Examples
68    /// ```
69    /// use deepmesa_collections::bitvec::BitwiseClear;
70    ///
71    /// let val:u8 = 0b1011_1100;
72    /// assert_eq!(val.clear_msb(4), 0b0000_1100);
73    /// ```
74    fn clear_msb(self, n: u8) -> Self::Output;
75    /// Returns a value with the `nth` LSB bit of `self` cleared.
76    /// # Examples
77    /// ```
78    /// use deepmesa_collections::bitvec::BitwiseClear;
79    ///
80    /// let val:u8 = 0b1011_1100;
81    /// assert_eq!(val.clear_lsb_nth(3), 0b1011_0100);
82    /// ```
83    fn clear_lsb_nth(self, n: u8) -> Self::Output;
84    /// Returns a value with the `nth` MSB bit of `self` cleared.
85    /// # Examples
86    /// ```
87    /// use deepmesa_collections::bitvec::BitwiseClear;
88    ///
89    /// let val:u8 = 0b1011_1100;
90    /// assert_eq!(val.clear_msb_nth(3), 0b1010_1100);
91    /// ```
92    fn clear_msb_nth(self, n: u8) -> Self::Output;
93}
94
95/// Clears some bits of self.
96pub trait BitwiseClearAssign {
97    /// Clears `n` LSB bits of `self`
98    /// # Examples
99    /// ```
100    /// use deepmesa_collections::bitvec::BitwiseClearAssign;
101    ///
102    /// let mut val:u8 = 0b1011_1100;
103    /// val.clear_lsb_assign(4);
104    /// assert_eq!(val, 0b1011_0000);
105    /// ```
106    fn clear_lsb_assign(&mut self, n: u8);
107    /// Clears `n` MSB bits of `self`
108    /// # Examples
109    /// ```
110    /// use deepmesa_collections::bitvec::BitwiseClearAssign;
111    ///
112    /// let mut val:u8 = 0b1011_1100;
113    /// val.clear_msb_assign(4);
114    /// assert_eq!(val, 0b0000_1100);
115    /// ```
116    fn clear_msb_assign(&mut self, n: u8);
117    /// Clears `nth` LSB bit of `self`
118    /// # Examples
119    /// ```
120    /// use deepmesa_collections::bitvec::BitwiseClearAssign;
121    ///
122    /// let mut val:u8 = 0b1011_1100;
123    /// val.clear_lsb_nth_assign(3);
124    /// assert_eq!(val, 0b1011_0100);
125    /// ```
126
127    fn clear_lsb_nth_assign(&mut self, n: u8);
128    /// Clears `nth` MSB bit of `self`
129    /// # Examples
130    /// ```
131    /// use deepmesa_collections::bitvec::BitwiseClearAssign;
132    ///
133    /// let mut val:u8 = 0b1011_1100;
134    /// val.clear_msb_nth_assign(3);
135    /// assert_eq!(val, 0b1010_1100);
136    /// ```
137    fn clear_msb_nth_assign(&mut self, n: u8);
138}
139
140/// Bitwise `!` (not) operation on the Lsb bits of self.
141pub trait NotLsb {
142    type Output;
143    fn not_lsb(self, n: u8) -> Self::Output;
144}
145
146/// Bitwise `!=` (not assign) operation on the Lsb bits of
147/// self.
148pub trait NotLsbAssign {
149    fn not_lsb_assign(&mut self, n: u8);
150}
151
152/// Bitwise `!` (not) operation on the Msb bits of self.
153pub trait NotMsb {
154    type Output;
155    fn not_msb(self, n: u8) -> Self::Output;
156}
157
158/// Bitwise `!=` (not assign) operation on the Msb bits of
159/// self.
160pub trait NotMsbAssign {
161    fn not_msb_assign(&mut self, n: u8);
162}
163
164/// Bitwise `!` (not) operation on a subset of the bits of
165/// self.
166pub trait NotPartial {
167    type Output;
168    fn not_partial(self, start: u8, len: u8) -> Self::Output;
169}
170
171/// Bitwise `!=` (not assign) operation on a subset of the
172/// bits of self.
173pub trait NotPartialAssign {
174    fn not_partial_assign(&mut self, start: u8, len: u8);
175}
176
177/// Bitwise `&` (and), `|` (or) and `^` (xor) operations on
178/// the Lsb bits of self.
179pub trait BitwiseLsb<Rhs = bool> {
180    type Output;
181    fn and_lsb(self, n: u8, rhs: Rhs) -> Self::Output;
182    fn or_lsb(self, n: u8, rhs: Rhs) -> Self::Output;
183    fn xor_lsb(self, n: u8, rhs: Rhs) -> Self::Output;
184}
185
186/// Bitwise `&` (and), `|` (or) and `^` (xor) operations on
187/// the Msb bits of self.
188pub trait BitwiseMsb<Rhs = bool> {
189    type Output;
190    fn and_msb(self, n: u8, rhs: Rhs) -> Self::Output;
191    fn or_msb(self, n: u8, rhs: Rhs) -> Self::Output;
192    fn xor_msb(self, n: u8, rhs: Rhs) -> Self::Output;
193}
194
195/// Bitwise `&` (and), `|` (or) and `^` (xor) operations on a
196/// subset of the bits of self.
197pub trait BitwisePartial<Rhs = bool> {
198    type Output;
199    fn and_partial(self, start: u8, len: u8, rhs: Rhs) -> Self::Output;
200    fn or_partial(self, start: u8, len: u8, rhs: Rhs) -> Self::Output;
201    fn xor_partial(self, start: u8, len: u8, rhs: Rhs) -> Self::Output;
202}
203
204/// Bitwise `&=` (and assign), `|=` (or assign) and `^=` (xor
205/// assign) operations on the Lsb bits of self.
206pub trait BitwiseLsbAssign<Rhs = bool> {
207    fn and_lsb_assign(&mut self, n: u8, rhs: Rhs);
208    fn or_lsb_assign(&mut self, n: u8, rhs: Rhs);
209    fn xor_lsb_assign(&mut self, n: u8, rhs: Rhs);
210}
211
212/// Bitwise `&=` (and assign), `|=` (or assign) and `^=` (xor
213/// assign) operations on the Msb bits of self.
214pub trait BitwiseMsbAssign<Rhs = bool> {
215    fn and_msb_assign(&mut self, n: u8, rhs: Rhs);
216    fn or_msb_assign(&mut self, n: u8, rhs: Rhs);
217    fn xor_msb_assign(&mut self, n: u8, rhs: Rhs);
218}
219
220/// Bitwise `&=` (and assign), `|=` (or assign) and `^=` (xor
221/// assign) operations on a subset of bits of self.
222pub trait BitwisePartialAssign<Rhs = bool> {
223    fn and_partial_assign(&mut self, start: u8, len: u8, rhs: Rhs);
224    fn or_partial_assign(&mut self, start: u8, len: u8, rhs: Rhs);
225    fn xor_partial_assign(&mut self, start: u8, len: u8, rhs: Rhs);
226}
227
228impl BitwiseClear for u8 {
229    type Output = u8;
230    #[inline(always)]
231    fn clear_lsb(self, n: u8) -> Self::Output {
232        debug_assert_bounds_check!(n, 8);
233        match n {
234            8 => 0u8,
235            _ => (self >> n) << n,
236        }
237    }
238    #[inline(always)]
239    fn clear_msb(self, n: u8) -> Self::Output {
240        debug_assert_bounds_check!(n, 8);
241        match n {
242            8 => 0u8,
243            _ => (self << n) >> n,
244        }
245    }
246
247    #[inline(always)]
248    fn clear_lsb_nth(self, n: u8) -> Self::Output {
249        debug_assert_bounds_check!(n, 7);
250        self & lsb_nth_zero!(n)
251    }
252    #[inline(always)]
253    fn clear_msb_nth(self, n: u8) -> Self::Output {
254        debug_assert_bounds_check!(n, 7);
255        self & msb_nth_zero!(n)
256    }
257}
258
259impl BitwiseClearAssign for u8 {
260    #[inline(always)]
261    fn clear_lsb_assign(&mut self, n: u8) {
262        debug_assert_bounds_check!(n, 8);
263        match n {
264            8 => *self = 0u8,
265            _ => *self = (*self >> n) << n,
266        }
267    }
268
269    #[inline(always)]
270    fn clear_msb_assign(&mut self, n: u8) {
271        debug_assert_bounds_check!(n, 8);
272        match n {
273            8 => *self = 0u8,
274            _ => *self = (*self << n) >> n,
275        }
276    }
277
278    #[inline(always)]
279    fn clear_lsb_nth_assign(&mut self, n: u8) {
280        debug_assert_bounds_check!(n, 7);
281        *self &= lsb_nth_zero!(n);
282    }
283
284    #[inline(always)]
285    fn clear_msb_nth_assign(&mut self, n: u8) {
286        debug_assert_bounds_check!(n, 7);
287        *self &= msb_nth_zero!(n);
288    }
289}
290
291impl BitwiseLsb<u8> for u8 {
292    type Output = u8;
293    #[inline(always)]
294    fn and_lsb(self, n: u8, rhs: u8) -> Self::Output {
295        debug_assert_bounds_check!(n, 8);
296        return self & (rhs | msb_ones(8 - n));
297    }
298    #[inline(always)]
299    fn or_lsb(self, n: u8, rhs: u8) -> Self::Output {
300        debug_assert_bounds_check!(n, 8);
301        return self | (rhs & lsb_ones(n));
302    }
303    #[inline(always)]
304    fn xor_lsb(self, n: u8, rhs: u8) -> Self::Output {
305        debug_assert_bounds_check!(n, 8);
306        return self ^ (rhs & lsb_ones(n));
307    }
308}
309
310impl BitwiseLsb<bool> for u8 {
311    type Output = u8;
312    #[inline(always)]
313    fn and_lsb(self, n: u8, rhs: bool) -> Self::Output {
314        debug_assert_bounds_check!(n, 8);
315        match rhs {
316            true => self,
317            false => self & msb_ones(8 - n),
318        }
319    }
320    #[inline(always)]
321    fn or_lsb(self, n: u8, rhs: bool) -> Self::Output {
322        debug_assert_bounds_check!(n, 8);
323        match rhs {
324            true => self | lsb_ones(n),
325            false => self,
326        }
327    }
328
329    #[inline(always)]
330    fn xor_lsb(self, n: u8, rhs: bool) -> Self::Output {
331        debug_assert_bounds_check!(n, 8);
332        match rhs {
333            true => self ^ lsb_ones(n),
334            false => self,
335        }
336    }
337}
338
339impl NotLsb for u8 {
340    type Output = u8;
341    #[inline(always)]
342    fn not_lsb(self, n: u8) -> Self::Output {
343        debug_assert_bounds_check!(n, 8);
344        return !(self ^ msb_ones(8 - n));
345    }
346}
347
348impl BitwiseLsbAssign<bool> for u8 {
349    #[inline(always)]
350    fn and_lsb_assign(&mut self, n: u8, rhs: bool) {
351        debug_assert_bounds_check!(n, 8);
352        match rhs {
353            true => {}
354            false => *self &= msb_ones(8 - n),
355        }
356    }
357    #[inline(always)]
358    fn or_lsb_assign(&mut self, n: u8, rhs: bool) {
359        debug_assert_bounds_check!(n, 8);
360        match rhs {
361            true => *self |= lsb_ones(n),
362            false => {}
363        }
364    }
365
366    #[inline(always)]
367    fn xor_lsb_assign(&mut self, n: u8, rhs: bool) {
368        debug_assert_bounds_check!(n, 8);
369        match rhs {
370            true => *self ^= lsb_ones(n),
371            false => {}
372        }
373    }
374}
375
376impl BitwiseLsbAssign<u8> for u8 {
377    #[inline(always)]
378    fn and_lsb_assign(&mut self, n: u8, rhs: u8) {
379        debug_assert_bounds_check!(n, 8);
380        *self &= rhs | msb_ones(8 - n);
381    }
382
383    #[inline(always)]
384    fn or_lsb_assign(&mut self, n: u8, rhs: u8) {
385        debug_assert_bounds_check!(n, 8);
386        *self |= rhs & lsb_ones(n);
387    }
388
389    #[inline(always)]
390    fn xor_lsb_assign(&mut self, n: u8, rhs: u8) {
391        debug_assert_bounds_check!(n, 8);
392        *self ^= rhs & lsb_ones(n);
393    }
394}
395
396impl NotLsbAssign for u8 {
397    #[inline(always)]
398    fn not_lsb_assign(&mut self, n: u8) {
399        debug_assert_bounds_check!(n, 8);
400        *self = !(*self ^ msb_ones(8 - n));
401    }
402}
403
404impl BitwiseMsb<bool> for u8 {
405    type Output = u8;
406    #[inline(always)]
407    fn and_msb(self, n: u8, rhs: bool) -> Self::Output {
408        debug_assert_bounds_check!(n, 8);
409        match rhs {
410            true => self,
411            false => self & lsb_ones(8 - n),
412        }
413    }
414    #[inline(always)]
415    fn or_msb(self, n: u8, rhs: bool) -> Self::Output {
416        debug_assert_bounds_check!(n, 8);
417        match rhs {
418            true => self | msb_ones(n),
419            false => self,
420        }
421    }
422    #[inline(always)]
423    fn xor_msb(self, n: u8, rhs: bool) -> Self::Output {
424        debug_assert_bounds_check!(n, 8);
425        match rhs {
426            true => self ^ msb_ones(n),
427            false => self,
428        }
429    }
430}
431
432impl BitwiseMsb<u8> for u8 {
433    type Output = u8;
434    #[inline(always)]
435    fn and_msb(self, n: u8, rhs: u8) -> Self::Output {
436        debug_assert_bounds_check!(n, 8);
437        return self & (rhs | lsb_ones(8 - n));
438    }
439    #[inline(always)]
440    fn or_msb(self, n: u8, rhs: u8) -> Self::Output {
441        debug_assert_bounds_check!(n, 8);
442        return self | (rhs & msb_ones(n));
443    }
444    #[inline(always)]
445    fn xor_msb(self, n: u8, rhs: u8) -> Self::Output {
446        debug_assert_bounds_check!(n, 8);
447        return self ^ (rhs & msb_ones(n));
448    }
449}
450
451impl NotMsb for u8 {
452    type Output = u8;
453    #[inline(always)]
454    fn not_msb(self, n: u8) -> Self::Output {
455        debug_assert_bounds_check!(n, 8);
456        return !(self ^ lsb_ones(8 - n));
457    }
458}
459
460impl BitwiseMsbAssign<bool> for u8 {
461    #[inline(always)]
462    fn and_msb_assign(&mut self, n: u8, rhs: bool) {
463        debug_assert_bounds_check!(n, 8);
464        match rhs {
465            true => {}
466            false => *self &= lsb_ones(8 - n),
467        }
468    }
469    #[inline(always)]
470    fn or_msb_assign(&mut self, n: u8, rhs: bool) {
471        debug_assert_bounds_check!(n, 8);
472        match rhs {
473            true => *self |= msb_ones(n),
474            false => {}
475        }
476    }
477
478    #[inline(always)]
479    fn xor_msb_assign(&mut self, n: u8, rhs: bool) {
480        debug_assert_bounds_check!(n, 8);
481        match rhs {
482            true => *self ^= msb_ones(n),
483            false => {}
484        }
485    }
486}
487
488impl BitwiseMsbAssign<u8> for u8 {
489    #[inline(always)]
490    fn and_msb_assign(&mut self, n: u8, rhs: u8) {
491        debug_assert_bounds_check!(n, 8);
492        *self &= rhs | lsb_ones(8 - n);
493    }
494    #[inline(always)]
495    fn or_msb_assign(&mut self, n: u8, rhs: u8) {
496        debug_assert_bounds_check!(n, 8);
497        *self |= rhs & msb_ones(n);
498    }
499    #[inline(always)]
500    fn xor_msb_assign(&mut self, n: u8, rhs: u8) {
501        debug_assert_bounds_check!(n, 8);
502        *self ^= rhs & msb_ones(n);
503    }
504}
505
506impl NotMsbAssign for u8 {
507    #[inline(always)]
508    fn not_msb_assign(&mut self, n: u8) {
509        debug_assert_bounds_check!(n, 8);
510        *self = !(*self ^ lsb_ones(8 - n));
511    }
512}
513
514impl BitwisePartial<bool> for u8 {
515    type Output = u8;
516    #[inline(always)]
517    // `start` starts from MSB
518    fn and_partial(self, start: u8, len: u8, rhs: bool) -> Self::Output {
519        debug_assert_bounds_check!(start, 7);
520        debug_assert_bounds_check!(len, 8 - start);
521        match rhs {
522            true => self,
523            false => self & (lsb_ones(8 - start) ^ msb_ones(start + len)),
524        }
525    }
526
527    #[inline(always)]
528    fn or_partial(self, start: u8, len: u8, rhs: bool) -> Self::Output {
529        debug_assert_bounds_check!(start, 7);
530        debug_assert_bounds_check!(len, 8 - start);
531        match rhs {
532            true => self | (lsb_ones(8 - start) & msb_ones(start + len)),
533            false => self,
534        }
535    }
536
537    #[inline(always)]
538    fn xor_partial(self, start: u8, len: u8, rhs: bool) -> Self::Output {
539        debug_assert_bounds_check!(start, 7);
540        debug_assert_bounds_check!(len, 8 - start);
541        match rhs {
542            true => self ^ (lsb_ones(8 - start) & msb_ones(start + len)),
543            false => self,
544        }
545    }
546}
547
548impl BitwisePartial<u8> for u8 {
549    type Output = u8;
550    #[inline(always)]
551    fn and_partial(self, start: u8, len: u8, rhs: u8) -> Self::Output {
552        debug_assert_bounds_check!(start, 7);
553        debug_assert_bounds_check!(len, 8 - start);
554
555        return self & (rhs | (lsb_ones(8 - start) ^ msb_ones(start + len)));
556    }
557
558    #[inline(always)]
559    fn or_partial(self, start: u8, len: u8, rhs: u8) -> Self::Output {
560        debug_assert_bounds_check!(start, 7);
561        debug_assert_bounds_check!(len, 8 - start);
562        return self | (rhs & (lsb_ones(8 - start) & msb_ones(start + len)));
563    }
564
565    #[inline(always)]
566    fn xor_partial(self, start: u8, len: u8, rhs: u8) -> Self::Output {
567        debug_assert_bounds_check!(start, 7);
568        debug_assert_bounds_check!(len, 8 - start);
569        return self ^ (rhs & (lsb_ones(8 - start) & msb_ones(start + len)));
570    }
571}
572
573impl NotPartial for u8 {
574    type Output = u8;
575    #[inline(always)]
576    fn not_partial(self, start: u8, len: u8) -> Self::Output {
577        debug_assert_bounds_check!(start, 7);
578        debug_assert_bounds_check!(len, 8 - start);
579        return !(self ^ (lsb_ones(8 - start) ^ msb_ones(start + len)));
580    }
581}
582
583impl BitwisePartialAssign<bool> for u8 {
584    #[inline(always)]
585    fn and_partial_assign(&mut self, start: u8, len: u8, rhs: bool) {
586        debug_assert_bounds_check!(start, 7);
587        debug_assert_bounds_check!(len, 8 - start);
588        match rhs {
589            true => {}
590            false => *self &= lsb_ones(8 - start) ^ msb_ones(start + len),
591        }
592    }
593
594    #[inline(always)]
595    fn or_partial_assign(&mut self, start: u8, len: u8, rhs: bool) {
596        debug_assert_bounds_check!(start, 7);
597        debug_assert_bounds_check!(len, 8 - start);
598        match rhs {
599            true => *self |= lsb_ones(8 - start) & msb_ones(start + len),
600            false => {}
601        }
602    }
603
604    #[inline(always)]
605    fn xor_partial_assign(&mut self, start: u8, len: u8, rhs: bool) {
606        debug_assert_bounds_check!(start, 7);
607        debug_assert_bounds_check!(len, 8 - start);
608        match rhs {
609            true => *self ^= lsb_ones(8 - start) & msb_ones(start + len),
610            false => {}
611        }
612    }
613}
614
615impl BitwisePartialAssign<u8> for u8 {
616    #[inline(always)]
617    fn and_partial_assign(&mut self, start: u8, len: u8, rhs: u8) {
618        debug_assert_bounds_check!(start, 7);
619        debug_assert_bounds_check!(len, 8 - start);
620        *self &= rhs | (lsb_ones(8 - start) ^ msb_ones(start + len));
621    }
622
623    #[inline(always)]
624    fn or_partial_assign(&mut self, start: u8, len: u8, rhs: u8) {
625        debug_assert_bounds_check!(start, 7);
626        debug_assert_bounds_check!(len, 8 - start);
627
628        *self |= rhs & (lsb_ones(8 - start) & msb_ones(start + len));
629    }
630
631    #[inline(always)]
632    fn xor_partial_assign(&mut self, start: u8, len: u8, rhs: u8) {
633        debug_assert_bounds_check!(start, 7);
634        debug_assert_bounds_check!(len, 8 - start);
635
636        *self ^= rhs & (lsb_ones(8 - start) & msb_ones(start + len));
637    }
638}
639
640impl NotPartialAssign for u8 {
641    #[inline(always)]
642    fn not_partial_assign(&mut self, start: u8, len: u8) {
643        debug_assert_bounds_check!(start, 7);
644        debug_assert_bounds_check!(len, 8 - start);
645        *self = !(*self ^ (lsb_ones(8 - start) ^ msb_ones(start + len)));
646    }
647}
648
649/// Converts bits to an `Msb0` ordering.
650///
651/// Given a specified number of bits, shift them left (towards the
652/// MSB) to produce an ordering such that those bits are counted from
653/// the MSB to the LSB
654///
655/// # Examples
656/// ```
657/// use deepmesa_collections::bitvec::AsMsb0;
658///
659/// let val: u8 = 0b0000_1100;
660/// let converted = val.as_msb0(4);
661/// assert_eq!(converted, 0b1100_0000);
662/// ```
663///
664/// If the bitcount equals the size of `Self` (in bits) then the value
665/// is unchanged.
666///
667/// # Examples
668/// ```
669/// use deepmesa_collections::bitvec::AsMsb0;
670///
671/// let val: u8 = 0b1010_1100;
672/// let converted = val.as_msb0(8);
673/// assert_eq!(converted, 0b1010_1100);
674/// ```
675pub trait AsMsb0 {
676    fn as_msb0(&self, n: BitCount) -> Self;
677}
678
679/// Converts bits to an `Lsb0` ordering.
680///
681/// Given a specified number of bits, shift them right (towards the
682/// LSB) to produce an ordering such that those bits are counted from
683/// the LSB to the MSB
684///
685/// # Examples
686/// ```
687/// use deepmesa_collections::bitvec::AsLsb0;
688///
689/// let val: u8 = 0b1100_0000;
690/// let converted = val.as_lsb0(4);
691/// assert_eq!(converted, 0b0000_1100);
692/// ```
693///
694/// If the bitcount equals the size of `Self` (in bits) then the value
695/// is unchanged.
696///
697/// # Examples
698/// ```
699/// use deepmesa_collections::bitvec::AsLsb0;
700///
701/// let val: u8 = 0b1010_1100;
702/// let converted = val.as_lsb0(8);
703/// assert_eq!(converted, 0b1010_1100);
704/// ```
705pub trait AsLsb0 {
706    fn as_lsb0(&self, n: BitCount) -> Self;
707}
708
709macro_rules! impl_as_lsb0 {
710    ($t: ty, $sz:literal) => {
711        impl AsLsb0 for $t {
712            fn as_lsb0(&self, n: BitCount) -> Self {
713                debug_assert!(n <= $sz);
714                match n {
715                    0 => return *self,
716                    $sz => return *self,
717                    _ => return *self >> ($sz - n),
718                };
719            }
720        }
721    };
722}
723
724macro_rules! impl_as_msb0 {
725    ($t:ty, $sz:literal) => {
726        impl AsMsb0 for $t {
727            fn as_msb0(&self, n: BitCount) -> Self {
728                debug_assert!(n <= $sz);
729                match n {
730                    0 => return *self,
731                    $sz => return *self,
732                    _ => return *self << ($sz - n),
733                }
734            }
735        }
736    };
737}
738
739impl_as_lsb0!(u8, 8);
740impl_as_lsb0!(u16, 16);
741impl_as_lsb0!(u32, 32);
742impl_as_lsb0!(u64, 64);
743impl_as_lsb0!(u128, 128);
744
745impl_as_msb0!(u8, 8);
746impl_as_msb0!(u16, 16);
747impl_as_msb0!(u32, 32);
748impl_as_msb0!(u64, 64);
749impl_as_msb0!(u128, 128);
750
751#[cfg(test)]
752mod tests {
753    use super::*;
754    use core::mem;
755    use rand::Rng;
756
757    #[test]
758    fn test_clear_msb() {
759        let val: u8 = 0b1111_1111;
760        assert_eq!(val.clear_msb(0), 0b1111_1111);
761        assert_eq!(val.clear_msb(1), 0b0111_1111);
762        assert_eq!(val.clear_msb(2), 0b0011_1111);
763        assert_eq!(val.clear_msb(3), 0b0001_1111);
764        assert_eq!(val.clear_msb(4), 0b0000_1111);
765        assert_eq!(val.clear_msb(5), 0b0000_0111);
766        assert_eq!(val.clear_msb(6), 0b0000_0011);
767        assert_eq!(val.clear_msb(7), 0b0000_0001);
768        assert_eq!(val.clear_msb(8), 0b0000_0000);
769    }
770
771    #[test]
772    fn test_clear_msb_nth() {
773        let val: u8 = 0b1111_1111;
774        assert_eq!(val.clear_msb_nth(0), 0b0111_1111);
775        assert_eq!(val.clear_msb_nth(1), 0b1011_1111);
776        assert_eq!(val.clear_msb_nth(2), 0b1101_1111);
777        assert_eq!(val.clear_msb_nth(3), 0b1110_1111);
778        assert_eq!(val.clear_msb_nth(4), 0b1111_0111);
779        assert_eq!(val.clear_msb_nth(5), 0b1111_1011);
780        assert_eq!(val.clear_msb_nth(6), 0b1111_1101);
781        assert_eq!(val.clear_msb_nth(7), 0b1111_1110);
782    }
783
784    #[test]
785    fn test_clear_msb_nth_assign() {
786        let mut val: u8 = 0b1111_1111;
787        val.clear_msb_nth_assign(0);
788        assert_eq!(val, 0b0111_1111);
789        let mut val: u8 = 0b1111_1111;
790        val.clear_msb_nth_assign(1);
791        assert_eq!(val, 0b1011_1111);
792        let mut val: u8 = 0b1111_1111;
793        val.clear_msb_nth_assign(2);
794        assert_eq!(val, 0b1101_1111);
795        let mut val: u8 = 0b1111_1111;
796        val.clear_msb_nth_assign(3);
797        assert_eq!(val, 0b1110_1111);
798        let mut val: u8 = 0b1111_1111;
799        val.clear_msb_nth_assign(4);
800        assert_eq!(val, 0b1111_0111);
801        let mut val: u8 = 0b1111_1111;
802        val.clear_msb_nth_assign(5);
803        assert_eq!(val, 0b1111_1011);
804        let mut val: u8 = 0b1111_1111;
805        val.clear_msb_nth_assign(6);
806        assert_eq!(val, 0b1111_1101);
807        let mut val: u8 = 0b1111_1111;
808        val.clear_msb_nth_assign(7);
809        assert_eq!(val, 0b1111_1110);
810    }
811
812    #[test]
813    fn test_clear_msb_assign() {
814        let mut val: u8 = 0b1111_1111;
815        val.clear_msb_assign(0);
816        assert_eq!(val, 0b1111_1111);
817        let mut val: u8 = 0b1111_1111;
818        val.clear_msb_assign(1);
819        assert_eq!(val, 0b0111_1111);
820        let mut val: u8 = 0b1111_1111;
821        val.clear_msb_assign(2);
822        assert_eq!(val, 0b0011_1111);
823        let mut val: u8 = 0b1111_1111;
824        val.clear_msb_assign(3);
825        assert_eq!(val, 0b0001_1111);
826        let mut val: u8 = 0b1111_1111;
827        val.clear_msb_assign(4);
828        assert_eq!(val, 0b0000_1111);
829        let mut val: u8 = 0b1111_1111;
830        val.clear_msb_assign(5);
831        assert_eq!(val, 0b0000_0111);
832        let mut val: u8 = 0b1111_1111;
833        val.clear_msb_assign(6);
834        assert_eq!(val, 0b0000_0011);
835        let mut val: u8 = 0b1111_1111;
836        val.clear_msb_assign(7);
837        assert_eq!(val, 0b0000_0001);
838        let mut val: u8 = 0b1111_1111;
839        val.clear_msb_assign(8);
840        assert_eq!(val, 0b0000_0000);
841    }
842
843    #[test]
844    fn test_clear_lsb() {
845        let val: u8 = 0b1111_1111;
846        assert_eq!(val.clear_lsb(0), 0b1111_1111);
847        assert_eq!(val.clear_lsb(1), 0b1111_1110);
848        assert_eq!(val.clear_lsb(2), 0b1111_1100);
849        assert_eq!(val.clear_lsb(3), 0b1111_1000);
850        assert_eq!(val.clear_lsb(4), 0b1111_0000);
851        assert_eq!(val.clear_lsb(5), 0b1110_0000);
852        assert_eq!(val.clear_lsb(6), 0b1100_0000);
853        assert_eq!(val.clear_lsb(7), 0b1000_0000);
854        assert_eq!(val.clear_lsb(8), 0b0000_0000);
855    }
856
857    #[test]
858    fn test_clear_lsb_nth() {
859        let val: u8 = 0b1111_1111;
860        assert_eq!(val.clear_lsb_nth(0), 0b1111_1110);
861        assert_eq!(val.clear_lsb_nth(1), 0b1111_1101);
862        assert_eq!(val.clear_lsb_nth(2), 0b1111_1011);
863        assert_eq!(val.clear_lsb_nth(3), 0b1111_0111);
864        assert_eq!(val.clear_lsb_nth(4), 0b1110_1111);
865        assert_eq!(val.clear_lsb_nth(5), 0b1101_1111);
866        assert_eq!(val.clear_lsb_nth(6), 0b1011_1111);
867        assert_eq!(val.clear_lsb_nth(7), 0b0111_1111);
868    }
869
870    #[test]
871    fn test_clear_lsb_nth_assign() {
872        let mut val: u8 = 0b1111_1111;
873        val.clear_lsb_nth_assign(0);
874        assert_eq!(val, 0b1111_1110);
875        let mut val: u8 = 0b1111_1111;
876        val.clear_lsb_nth_assign(1);
877        assert_eq!(val, 0b1111_1101);
878        let mut val: u8 = 0b1111_1111;
879        val.clear_lsb_nth_assign(2);
880        assert_eq!(val, 0b1111_1011);
881        let mut val: u8 = 0b1111_1111;
882        val.clear_lsb_nth_assign(3);
883        assert_eq!(val, 0b1111_0111);
884        let mut val: u8 = 0b1111_1111;
885        val.clear_lsb_nth_assign(4);
886        assert_eq!(val, 0b1110_1111);
887        let mut val: u8 = 0b1111_1111;
888        val.clear_lsb_nth_assign(5);
889        assert_eq!(val, 0b1101_1111);
890        let mut val: u8 = 0b1111_1111;
891        val.clear_lsb_nth_assign(6);
892        assert_eq!(val, 0b1011_1111);
893        let mut val: u8 = 0b1111_1111;
894        val.clear_lsb_nth_assign(7);
895        assert_eq!(val, 0b0111_1111);
896    }
897
898    #[test]
899    fn test_clear_lsb_assign() {
900        let mut val: u8 = 0b1111_1111;
901        val.clear_lsb_assign(0);
902        assert_eq!(val, 0b1111_1111);
903        let mut val: u8 = 0b1111_1111;
904        val.clear_lsb_assign(1);
905        assert_eq!(val, 0b1111_1110);
906        let mut val: u8 = 0b1111_1111;
907        val.clear_lsb_assign(2);
908        assert_eq!(val, 0b1111_1100);
909        let mut val: u8 = 0b1111_1111;
910        val.clear_lsb_assign(3);
911        assert_eq!(val, 0b1111_1000);
912        let mut val: u8 = 0b1111_1111;
913        val.clear_lsb_assign(4);
914        assert_eq!(val, 0b1111_0000);
915        let mut val: u8 = 0b1111_1111;
916        val.clear_lsb_assign(5);
917        assert_eq!(val, 0b1110_0000);
918        let mut val: u8 = 0b1111_1111;
919        val.clear_lsb_assign(6);
920        assert_eq!(val, 0b1100_0000);
921        let mut val: u8 = 0b1111_1111;
922        val.clear_lsb_assign(7);
923        assert_eq!(val, 0b1000_0000);
924        let mut val: u8 = 0b1111_1111;
925        val.clear_lsb_assign(8);
926        assert_eq!(val, 0b0000_0000);
927    }
928
929    #[test]
930    fn test_not_lsb_assign() {
931        let mut val = 0b1010_0011;
932        val.not_lsb_assign(5);
933        assert_eq!(val, 0b1011_1100);
934
935        let mut val = 0b1111_0000;
936        val.not_lsb_assign(8);
937        assert_eq!(val, 0b0000_1111);
938
939        let mut val = 0b1111_0000;
940        val.not_lsb_assign(0);
941        assert_eq!(val, 0b1111_0000);
942
943        let mut val = 0b1111_0000;
944        val.not_lsb_assign(1);
945        assert_eq!(val, 0b1111_0001);
946
947        let mut val = 0b1111_0010;
948        val.not_lsb_assign(3);
949        assert_eq!(val, 0b1111_0101);
950    }
951
952    #[test]
953    fn test_not_msb_assign() {
954        let mut val = 0b1010_0011;
955        val.not_msb_assign(3);
956        assert_eq!(val, 0b0100_0011);
957
958        let mut val = 0b1111_0000;
959        val.not_msb_assign(8);
960        assert_eq!(val, 0b000_1111);
961
962        let mut val = 0b1111_0000;
963        val.not_msb_assign(0);
964        assert_eq!(val, 0b1111_0000);
965
966        let mut val = 0b1111_0000;
967        val.not_msb_assign(1);
968        assert_eq!(val, 0b0111_0000);
969
970        let mut val = 0b1111_0010;
971        val.not_msb_assign(5);
972        assert_eq!(val, 0b0000_1010);
973    }
974
975    #[test]
976    fn test_or_lsb_assign() {
977        let mut val = 0b1010_0011;
978        val.or_lsb_assign(5, true);
979        assert_eq!(val, 0b1011_1111);
980
981        let mut val = 0b1010_0011;
982        val.or_lsb_assign(5, false);
983        assert_eq!(val, 0b1010_0011);
984
985        let mut val = 0b1111_0000;
986        val.or_lsb_assign(8, true);
987        assert_eq!(val, 0b1111_1111);
988
989        let mut val = 0b1111_0000;
990        val.or_lsb_assign(8, false);
991        assert_eq!(val, 0b1111_0000);
992
993        let mut val = 0b1111_0000;
994        val.or_lsb_assign(0, true);
995        assert_eq!(val, 0b1111_0000);
996
997        let mut val = 0b1111_0000;
998        val.or_lsb_assign(0, false);
999        assert_eq!(val, 0b1111_0000);
1000
1001        let mut val = 0b1111_0000;
1002        val.or_lsb_assign(1, true);
1003        assert_eq!(val, 0b1111_0001);
1004
1005        let mut val = 0b1111_0011;
1006        val.or_lsb_assign(1, false);
1007        assert_eq!(val, 0b1111_0011);
1008
1009        let mut val = 0b1111_0010;
1010        val.or_lsb_assign(3, true);
1011        assert_eq!(val, 0b1111_0111);
1012
1013        let mut val = 0b1111_0010;
1014        val.or_lsb_assign(3, false);
1015        assert_eq!(val, 0b1111_0010);
1016    }
1017
1018    #[test]
1019    fn test_or_msb_assign() {
1020        let mut val = 0b1010_0011;
1021        val.or_msb_assign(5, true);
1022        assert_eq!(val, 0b1111_1011);
1023
1024        let mut val = 0b1010_0011;
1025        val.or_msb_assign(5, false);
1026        assert_eq!(val, 0b1010_0011);
1027
1028        let mut val = 0b1111_0000;
1029        val.or_msb_assign(8, true);
1030        assert_eq!(val, 0b1111_1111);
1031
1032        let mut val = 0b1111_0000;
1033        val.or_msb_assign(8, false);
1034        assert_eq!(val, 0b1111_0000);
1035
1036        let mut val = 0b1111_0000;
1037        val.or_msb_assign(0, true);
1038        assert_eq!(val, 0b1111_0000);
1039
1040        let mut val = 0b1111_0000;
1041        val.or_msb_assign(0, false);
1042        assert_eq!(val, 0b1111_0000);
1043
1044        let mut val = 0b0000_1111;
1045        val.or_msb_assign(1, true);
1046        assert_eq!(val, 0b1000_1111);
1047
1048        let mut val = 0b0000_0011;
1049        val.or_msb_assign(1, false);
1050        assert_eq!(val, 0b0000_0011);
1051
1052        let mut val = 0b1010_0010;
1053        val.or_msb_assign(3, true);
1054        assert_eq!(val, 0b1110_0010);
1055
1056        let mut val = 0b1111_0010;
1057        val.or_msb_assign(3, false);
1058        assert_eq!(val, 0b1111_0010);
1059    }
1060
1061    #[test]
1062    fn test_xor_lsb_assign() {
1063        let mut val = 0b1010_0011;
1064        val.xor_lsb_assign(5, true);
1065        assert_eq!(val, 0b1011_1100);
1066
1067        let mut val = 0b1010_0011;
1068        val.xor_lsb_assign(5, false);
1069        assert_eq!(val, 0b1010_0011);
1070
1071        let mut val = 0b1111_0000;
1072        val.xor_lsb_assign(8, true);
1073        assert_eq!(val, 0b0000_1111);
1074
1075        let mut val = 0b1111_0000;
1076        val.xor_lsb_assign(8, false);
1077        assert_eq!(val, 0b1111_0000);
1078
1079        let mut val = 0b1111_0000;
1080        val.xor_lsb_assign(0, true);
1081        assert_eq!(val, 0b1111_0000);
1082
1083        let mut val = 0b1111_0000;
1084        val.xor_lsb_assign(0, false);
1085        assert_eq!(val, 0b1111_0000);
1086
1087        let mut val = 0b1111_0000;
1088        val.xor_lsb_assign(1, true);
1089        assert_eq!(val, 0b1111_0001);
1090
1091        let mut val = 0b1111_0011;
1092        val.xor_lsb_assign(1, false);
1093        assert_eq!(val, 0b1111_0011);
1094
1095        let mut val = 0b1111_0010;
1096        val.xor_lsb_assign(3, true);
1097        assert_eq!(val, 0b1111_0101);
1098
1099        let mut val = 0b1111_0010;
1100        val.xor_lsb_assign(3, false);
1101        assert_eq!(val, 0b1111_0010);
1102    }
1103
1104    #[test]
1105    fn test_xor_msb_assign() {
1106        let mut val = 0b1010_0011;
1107        val.xor_msb_assign(5, true);
1108        assert_eq!(val, 0b0101_1011);
1109
1110        let mut val = 0b1010_0011;
1111        val.xor_msb_assign(5, false);
1112        assert_eq!(val, 0b1010_0011);
1113
1114        let mut val = 0b1111_0000;
1115        val.xor_msb_assign(8, true);
1116        assert_eq!(val, 0b0000_1111);
1117
1118        let mut val = 0b1111_0000;
1119        val.xor_msb_assign(8, false);
1120        assert_eq!(val, 0b1111_0000);
1121
1122        let mut val = 0b1111_0000;
1123        val.xor_msb_assign(0, true);
1124        assert_eq!(val, 0b1111_0000);
1125
1126        let mut val = 0b1111_0000;
1127        val.xor_msb_assign(0, false);
1128        assert_eq!(val, 0b1111_0000);
1129
1130        let mut val = 0b0000_1111;
1131        val.xor_msb_assign(1, true);
1132        assert_eq!(val, 0b1000_1111);
1133
1134        let mut val = 0b0000_0011;
1135        val.xor_msb_assign(1, false);
1136        assert_eq!(val, 0b0000_0011);
1137
1138        let mut val = 0b1010_0010;
1139        val.xor_msb_assign(3, true);
1140        assert_eq!(val, 0b0100_0010);
1141
1142        let mut val = 0b1111_0010;
1143        val.xor_msb_assign(3, false);
1144        assert_eq!(val, 0b1111_0010);
1145    }
1146
1147    #[test]
1148    fn test_an_msb_u8() {
1149        let val = 0b1010_0011;
1150        assert_eq!(val.and_msb(0, 0b1100_0011), val);
1151        assert_eq!(val.and_msb(3, 0b1100_0011), 0b1000_0011);
1152        assert_eq!(val.and_msb(8, 0b1100_0011), 0b1000_0011);
1153        assert_eq!(val.and_msb(8, 0b0000_0000), 0b0000_0000);
1154        assert_eq!(val.and_msb(8, 0b1111_1111), val);
1155        assert_eq!(val.and_msb(3, 0b1111_1111), val);
1156        assert_eq!(val.and_msb(3, 0b0000_0000), 0b0000_0011);
1157    }
1158
1159    #[test]
1160    fn test_and_msb_assign_u8() {
1161        let val = 0b1010_0011;
1162        let mut res = val;
1163        res.and_msb_assign(0, 0b1100_0011);
1164        assert_eq!(res, val);
1165
1166        let mut res = val;
1167        res.and_msb_assign(3, 0b1100_0011);
1168        assert_eq!(res, 0b1000_0011);
1169
1170        let mut res = val;
1171        res.and_msb_assign(8, 0b1100_0011);
1172        assert_eq!(res, 0b1000_0011);
1173
1174        let mut res = val;
1175        res.and_msb_assign(8, 0b0000_0000);
1176        assert_eq!(res, 0b0000_0000);
1177
1178        let mut res = val;
1179        res.and_msb_assign(8, 0b1111_1111);
1180        assert_eq!(res, val);
1181
1182        let mut res = val;
1183        res.and_msb_assign(3, 0b1111_1111);
1184        assert_eq!(res, val);
1185
1186        let mut res = val;
1187        res.and_msb_assign(3, 0b0000_0000);
1188        assert_eq!(res, 0b0000_0011);
1189    }
1190
1191    #[test]
1192    fn test_and_lsb_u8() {
1193        let val = 0b1010_0011;
1194        assert_eq!(val.and_lsb(0, 0b1100_0011), val);
1195        assert_eq!(val.and_lsb(3, 0b1100_0101), 0b1010_0001);
1196        assert_eq!(val.and_lsb(8, 0b1100_0101), 0b1000_0001);
1197        assert_eq!(val.and_lsb(8, 0b0000_0000), 0b0000_0000);
1198        assert_eq!(val.and_lsb(8, 0b1111_1111), val);
1199        assert_eq!(val.and_lsb(3, 0b1111_1111), val);
1200        assert_eq!(val.and_lsb(3, 0b0000_0000), 0b1010_0000);
1201    }
1202    #[test]
1203    fn test_and_lsb_assign_u8() {
1204        let val = 0b1010_0011;
1205
1206        let mut res = val;
1207        res.and_lsb_assign(0, 0b1100_0011);
1208        assert_eq!(res, val);
1209
1210        let mut res = val;
1211        res.and_lsb_assign(3, 0b1100_0101);
1212        assert_eq!(res, 0b1010_0001);
1213
1214        let mut res = val;
1215        res.and_lsb_assign(8, 0b1100_0101);
1216        assert_eq!(res, 0b1000_0001);
1217
1218        let mut res = val;
1219        res.and_lsb_assign(8, 0b0000_0000);
1220        assert_eq!(res, 0b0000_0000);
1221
1222        let mut res = val;
1223        res.and_lsb_assign(8, 0b1111_1111);
1224        assert_eq!(res, val);
1225
1226        let mut res = val;
1227        res.and_lsb_assign(3, 0b1111_1111);
1228        assert_eq!(res, val);
1229
1230        let mut res = val;
1231        res.and_lsb_assign(3, 0b0000_0000);
1232        assert_eq!(res, 0b1010_0000);
1233    }
1234
1235    #[test]
1236    fn test_or_msb_u8() {
1237        let val = 0b1010_0011;
1238        assert_eq!(val.or_msb(0, 0b1100_0011), val);
1239        assert_eq!(val.or_msb(3, 0b1100_0101), 0b1110_0011);
1240        assert_eq!(val.or_msb(8, 0b1100_0101), 0b1110_0111);
1241        assert_eq!(val.or_msb(8, 0b0000_0000), val);
1242        assert_eq!(val.or_msb(8, 0b1111_1111), 0b1111_1111);
1243        assert_eq!(val.or_msb(3, 0b1111_1111), 0b1110_0011);
1244        assert_eq!(val.or_msb(3, 0b0000_0000), val);
1245    }
1246    #[test]
1247    fn test_or_msb_assign_u8() {
1248        let val = 0b1010_0011;
1249
1250        let mut res = val;
1251        res.or_msb_assign(0, 0b1100_0011);
1252        assert_eq!(res, val);
1253
1254        let mut res = val;
1255        res.or_msb_assign(3, 0b1100_0101);
1256        assert_eq!(res, 0b1110_0011);
1257
1258        let mut res = val;
1259        res.or_msb_assign(8, 0b1100_0101);
1260        assert_eq!(res, 0b1110_0111);
1261
1262        let mut res = val;
1263        res.or_msb_assign(8, 0b0000_0000);
1264        assert_eq!(res, val);
1265
1266        let mut res = val;
1267        res.or_msb_assign(8, 0b1111_1111);
1268        assert_eq!(res, 0b1111_1111);
1269
1270        let mut res = val;
1271        res.or_msb_assign(3, 0b1111_1111);
1272        assert_eq!(res, 0b1110_0011);
1273
1274        let mut res = val;
1275        res.or_msb_assign(3, 0b0000_0000);
1276        assert_eq!(res, val);
1277    }
1278
1279    #[test]
1280    fn test_or_lsb_u8() {
1281        let val = 0b1010_0011;
1282        assert_eq!(val.or_lsb(0, 0b1100_0011), val);
1283        assert_eq!(val.or_lsb(3, 0b1100_0101), 0b1010_0111);
1284        assert_eq!(val.or_lsb(8, 0b1100_0101), 0b1110_0111);
1285        assert_eq!(val.or_lsb(8, 0b0000_0000), val);
1286        assert_eq!(val.or_lsb(8, 0b1111_1111), 0b1111_1111);
1287        assert_eq!(val.or_lsb(3, 0b1111_1111), 0b1010_0111);
1288        assert_eq!(val.or_lsb(3, 0b0000_0000), val);
1289    }
1290    #[test]
1291    fn test_or_lsb_assign_u8() {
1292        let val = 0b1010_0011;
1293
1294        let mut res = val;
1295        res.or_lsb_assign(0, 0b1100_0011);
1296        assert_eq!(res, val);
1297
1298        let mut res = val;
1299        res.or_lsb_assign(3, 0b1100_0101);
1300        assert_eq!(res, 0b1010_0111);
1301
1302        let mut res = val;
1303        res.or_lsb_assign(8, 0b1100_0101);
1304        assert_eq!(res, 0b1110_0111);
1305
1306        let mut res = val;
1307        res.or_lsb_assign(8, 0b0000_0000);
1308        assert_eq!(res, val);
1309
1310        let mut res = val;
1311        res.or_lsb_assign(8, 0b1111_1111);
1312        assert_eq!(res, 0b1111_1111);
1313
1314        let mut res = val;
1315        res.or_lsb_assign(3, 0b1111_1111);
1316        assert_eq!(res, 0b1010_0111);
1317
1318        let mut res = val;
1319        res.or_lsb_assign(3, 0b0000_0000);
1320        assert_eq!(res, val);
1321    }
1322
1323    #[test]
1324    fn test_xor_msb_u8() {
1325        let val = 0b1010_0011;
1326        assert_eq!(val.xor_msb(0, 0b1100_0011), val);
1327        //                                  0b1010_0011;
1328        assert_eq!(val.xor_msb(3, 0b1100_0101), 0b0110_0011);
1329        //                                                  0110_0011
1330        assert_eq!(val.xor_msb(8, 0b1100_0101), 0b0110_0110);
1331        assert_eq!(val.xor_msb(8, 0b0000_0000), val);
1332        assert_eq!(val.xor_msb(8, 0b1111_1111), 0b0101_1100);
1333        assert_eq!(val.xor_msb(3, 0b1111_1111), 0b0100_0011);
1334        assert_eq!(val.xor_msb(3, 0b0000_0000), val);
1335    }
1336    #[test]
1337    fn test_xor_msb_assign_u8() {
1338        let val = 0b1010_0011;
1339
1340        let mut res = val;
1341        res.xor_msb_assign(0, 0b1100_0011);
1342        assert_eq!(res, val);
1343
1344        let mut res = val;
1345        res.xor_msb_assign(3, 0b1100_0101);
1346        assert_eq!(res, 0b0110_0011);
1347
1348        let mut res = val;
1349        res.xor_msb_assign(8, 0b1100_0101);
1350        assert_eq!(res, 0b0110_0110);
1351
1352        let mut res = val;
1353        res.xor_msb_assign(8, 0b0000_0000);
1354        assert_eq!(res, val);
1355
1356        let mut res = val;
1357        res.xor_msb_assign(8, 0b1111_1111);
1358        assert_eq!(res, 0b0101_1100);
1359
1360        let mut res = val;
1361        res.xor_msb_assign(3, 0b1111_1111);
1362        assert_eq!(res, 0b0100_0011);
1363
1364        let mut res = val;
1365        res.xor_msb_assign(3, 0b0000_0000);
1366        assert_eq!(res, val);
1367    }
1368
1369    #[test]
1370    fn test_xor_lsb_u8() {
1371        let val = 0b1010_0011;
1372        assert_eq!(val.xor_lsb(0, 0b1100_0011), val);
1373        assert_eq!(val.xor_lsb(3, 0b1100_0101), 0b1010_0110);
1374        assert_eq!(val.xor_lsb(8, 0b1100_0101), 0b0110_0110);
1375        assert_eq!(val.xor_lsb(8, 0b0000_0000), val);
1376        assert_eq!(val.xor_lsb(8, 0b1111_1111), 0b0101_1100);
1377        assert_eq!(val.xor_lsb(3, 0b1111_1111), 0b1010_0100);
1378        assert_eq!(val.xor_lsb(3, 0b0000_0000), val);
1379    }
1380    #[test]
1381    fn test_xor_lsb_assign_u8() {
1382        let val = 0b1010_0011;
1383
1384        let mut res = val;
1385        res.xor_lsb_assign(0, 0b1100_0011);
1386        assert_eq!(res, val);
1387
1388        let mut res = val;
1389        res.xor_lsb_assign(3, 0b1100_0101);
1390        assert_eq!(res, 0b1010_0110);
1391
1392        let mut res = val;
1393        res.xor_lsb_assign(8, 0b1100_0101);
1394        assert_eq!(res, 0b0110_0110);
1395
1396        let mut res = val;
1397        res.xor_lsb_assign(8, 0b0000_0000);
1398        assert_eq!(res, val);
1399
1400        let mut res = val;
1401        res.xor_lsb_assign(8, 0b1111_1111);
1402        assert_eq!(res, 0b0101_1100);
1403
1404        let mut res = val;
1405        res.xor_lsb_assign(3, 0b1111_1111);
1406        assert_eq!(res, 0b1010_0100);
1407
1408        let mut res = val;
1409        res.xor_lsb_assign(3, 0b0000_0000);
1410        assert_eq!(res, val);
1411    }
1412
1413    #[test]
1414    fn test_and_partial_bool() {
1415        let val: u8 = 0b1011_0011;
1416        assert_eq!(val.and_partial(0, 8, true), val);
1417        assert_eq!(val.and_partial(0, 8, false), 0b0000_0000);
1418
1419        assert_eq!(val.and_partial(0, 0, true), val);
1420        assert_eq!(val.and_partial(0, 0, false), val);
1421
1422        assert_eq!(val.and_partial(0, 1, true), val);
1423        assert_eq!(val.and_partial(0, 1, false), 0b0011_0011);
1424
1425        assert_eq!(val.and_partial(7, 1, true), val);
1426        assert_eq!(val.and_partial(7, 1, false), 0b1011_0010);
1427
1428        assert_eq!(val.and_partial(2, 3, true), val);
1429        assert_eq!(val.and_partial(2, 3, false), 0b1000_0011);
1430    }
1431
1432    #[test]
1433    fn test_and_partial_assign_bool() {
1434        let val: u8 = 0b1011_0011;
1435
1436        let mut res = val;
1437        res.and_partial_assign(0, 8, true);
1438        assert_eq!(res, val);
1439
1440        let mut res = val;
1441        res.and_partial_assign(0, 8, false);
1442        assert_eq!(res, 0b0000_0000);
1443
1444        let mut res = val;
1445        res.and_partial_assign(0, 0, true);
1446        assert_eq!(res, val);
1447
1448        let mut res = val;
1449        res.and_partial_assign(0, 0, false);
1450        assert_eq!(res, val);
1451
1452        let mut res = val;
1453        res.and_partial_assign(0, 1, true);
1454        assert_eq!(res, val);
1455
1456        let mut res = val;
1457        res.and_partial_assign(0, 1, false);
1458        assert_eq!(res, 0b0011_0011);
1459
1460        let mut res = val;
1461        res.and_partial_assign(7, 1, true);
1462        assert_eq!(res, val);
1463
1464        let mut res = val;
1465        res.and_partial_assign(7, 1, false);
1466        assert_eq!(res, 0b1011_0010);
1467
1468        let mut res = val;
1469        res.and_partial_assign(2, 3, true);
1470        assert_eq!(res, val);
1471
1472        let mut res = val;
1473        res.and_partial_assign(2, 3, false);
1474        assert_eq!(res, 0b1000_0011);
1475    }
1476
1477    #[test]
1478    fn test_or_partial_bool() {
1479        let val: u8 = 0b1011_0011;
1480        assert_eq!(val.or_partial(0, 8, true), 0b1111_1111);
1481        assert_eq!(val.or_partial(0, 8, false), val);
1482
1483        assert_eq!(val.or_partial(0, 0, true), val);
1484        assert_eq!(val.or_partial(0, 0, false), val);
1485
1486        assert_eq!(val.or_partial(0, 1, true), 0b1011_0011);
1487        assert_eq!(val.or_partial(0, 1, false), val);
1488
1489        assert_eq!(val.or_partial(7, 1, true), 0b1011_0011);
1490        assert_eq!(val.or_partial(7, 1, false), val);
1491
1492        assert_eq!(val.or_partial(2, 3, true), 0b1011_1011);
1493        assert_eq!(val.or_partial(2, 3, false), val);
1494    }
1495
1496    #[test]
1497    fn test_or_partial_assign_bool() {
1498        let val: u8 = 0b1011_0011;
1499        let mut res = val;
1500        res.or_partial_assign(0, 8, true);
1501        assert_eq!(res, 0b1111_1111);
1502
1503        let mut res = val;
1504        res.or_partial_assign(0, 8, false);
1505        assert_eq!(res, val);
1506
1507        let mut res = val;
1508        res.or_partial_assign(0, 0, true);
1509        assert_eq!(res, val);
1510
1511        let mut res = val;
1512        res.or_partial_assign(0, 0, false);
1513        assert_eq!(res, val);
1514
1515        let mut res = val;
1516        res.or_partial_assign(0, 1, true);
1517        assert_eq!(res, 0b1011_0011);
1518
1519        let mut res = val;
1520        res.or_partial_assign(0, 1, false);
1521        assert_eq!(res, val);
1522
1523        let mut res = val;
1524        res.or_partial_assign(7, 1, true);
1525        assert_eq!(res, 0b1011_0011);
1526
1527        let mut res = val;
1528        res.or_partial_assign(7, 1, false);
1529        assert_eq!(res, val);
1530
1531        let mut res = val;
1532        res.or_partial_assign(2, 3, true);
1533        assert_eq!(res, 0b1011_1011);
1534
1535        let mut res = val;
1536        res.or_partial_assign(2, 3, false);
1537        assert_eq!(res, val);
1538    }
1539
1540    #[test]
1541    fn test_xor_partial_bool() {
1542        let val: u8 = 0b1011_0011;
1543        assert_eq!(val.xor_partial(0, 8, true), 0b0100_1100);
1544        assert_eq!(val.xor_partial(0, 8, false), val);
1545
1546        assert_eq!(val.xor_partial(0, 0, true), val);
1547        assert_eq!(val.xor_partial(0, 0, false), val);
1548
1549        assert_eq!(val.xor_partial(0, 1, true), 0b0011_0011);
1550        assert_eq!(val.xor_partial(0, 1, false), val);
1551
1552        assert_eq!(val.xor_partial(7, 1, true), 0b1011_0010);
1553        assert_eq!(val.xor_partial(7, 1, false), val);
1554
1555        assert_eq!(val.xor_partial(2, 3, true), 0b1000_1011);
1556        assert_eq!(val.xor_partial(2, 3, false), val);
1557    }
1558
1559    #[test]
1560    fn test_xor_partial_assign_bool() {
1561        let val: u8 = 0b1011_0011;
1562
1563        let mut res = val;
1564        res.xor_partial_assign(0, 8, true);
1565        assert_eq!(res, 0b0100_1100);
1566
1567        let mut res = val;
1568        res.xor_partial_assign(0, 8, false);
1569        assert_eq!(res, val);
1570
1571        let mut res = val;
1572        res.xor_partial_assign(0, 0, true);
1573        assert_eq!(res, val);
1574
1575        let mut res = val;
1576        res.xor_partial_assign(0, 0, false);
1577        assert_eq!(res, val);
1578
1579        let mut res = val;
1580        res.xor_partial_assign(0, 1, true);
1581        assert_eq!(res, 0b0011_0011);
1582
1583        let mut res = val;
1584        res.xor_partial_assign(0, 1, false);
1585        assert_eq!(res, val);
1586
1587        let mut res = val;
1588        res.xor_partial_assign(7, 1, true);
1589        assert_eq!(res, 0b1011_0010);
1590
1591        let mut res = val;
1592        res.xor_partial_assign(7, 1, false);
1593        assert_eq!(res, val);
1594
1595        let mut res = val;
1596        res.xor_partial_assign(2, 3, true);
1597        assert_eq!(res, 0b1000_1011);
1598
1599        let mut res = val;
1600        res.xor_partial_assign(2, 3, false);
1601        assert_eq!(res, val);
1602    }
1603
1604    #[test]
1605    fn test_and_partial_u8() {
1606        let val: u8 = 0b1011_0011;
1607        assert_eq!(val.and_partial(0, 8, 0b1100_0101), 0b1000_0001);
1608        assert_eq!(val.and_partial(0, 0, 0b1100_0101), val);
1609        assert_eq!(val.and_partial(0, 1, 0b0100_0101), 0b0011_0011);
1610        assert_eq!(val.and_partial(7, 1, 0b0000_0000), 0b1011_0010);
1611        assert_eq!(val.and_partial(2, 3, 0b0000_0000), 0b1000_0011);
1612    }
1613
1614    #[test]
1615    fn test_and_partial_assign_u8() {
1616        let val: u8 = 0b1011_0011;
1617
1618        let mut res = val;
1619        res.and_partial_assign(0, 8, 0b1100_0101);
1620        assert_eq!(res, 0b1000_0001);
1621
1622        let mut res = val;
1623        res.and_partial_assign(0, 0, 0b1100_0101);
1624        assert_eq!(res, val);
1625
1626        let mut res = val;
1627        res.and_partial_assign(0, 1, 0b0100_0101);
1628        assert_eq!(res, 0b0011_0011);
1629
1630        let mut res = val;
1631        res.and_partial_assign(7, 1, 0b0000_0000);
1632        assert_eq!(res, 0b1011_0010);
1633
1634        let mut res = val;
1635        res.and_partial_assign(2, 3, 0b0000_0000);
1636        assert_eq!(res, 0b1000_0011);
1637    }
1638
1639    #[test]
1640    fn test_or_partial_u8() {
1641        let val: u8 = 0b1011_0011;
1642        assert_eq!(val.or_partial(0, 8, 0b1100_0101), 0b1111_0111);
1643        assert_eq!(val.or_partial(0, 0, 0b1100_0101), val);
1644        assert_eq!(val.or_partial(0, 1, 0b0100_0101), 0b1011_0011);
1645        assert_eq!(val.or_partial(7, 1, 0b0000_0000), 0b1011_0011);
1646        assert_eq!(val.or_partial(2, 3, 0b0000_0000), 0b1011_0011);
1647    }
1648
1649    #[test]
1650    fn test_or_partial_assign_u8() {
1651        let val: u8 = 0b1011_0011;
1652
1653        let mut res = val;
1654        res.or_partial_assign(0, 8, 0b1100_0101);
1655        assert_eq!(res, 0b1111_0111);
1656
1657        let mut res = val;
1658        res.or_partial_assign(0, 0, 0b1100_0101);
1659        assert_eq!(res, val);
1660
1661        let mut res = val;
1662        res.or_partial_assign(0, 1, 0b0100_0101);
1663        assert_eq!(res, 0b1011_0011);
1664
1665        let mut res = val;
1666        res.or_partial_assign(7, 1, 0b0000_0000);
1667        assert_eq!(res, 0b1011_0011);
1668
1669        let mut res = val;
1670        res.or_partial_assign(2, 3, 0b0000_0000);
1671        assert_eq!(res, 0b1011_0011);
1672    }
1673
1674    #[test]
1675    fn test_xor_partial_u8() {
1676        let val: u8 = 0b1011_0011;
1677        assert_eq!(val.xor_partial(0, 8, 0b1100_0101), 0b0111_0110);
1678        assert_eq!(val.xor_partial(0, 0, 0b1100_0101), val);
1679        assert_eq!(val.xor_partial(0, 1, 0b1100_0101), 0b0011_0011);
1680        assert_eq!(val.xor_partial(7, 1, 0b0000_0000), 0b1011_0011);
1681        assert_eq!(val.xor_partial(2, 3, 0b0000_0000), 0b1011_0011);
1682        assert_eq!(val.xor_partial(2, 3, 0b1111_1111), 0b1000_1011);
1683    }
1684
1685    #[test]
1686    fn test_xor_partial_assign_u8() {
1687        let val: u8 = 0b1011_0011;
1688
1689        let mut res = val;
1690        res.xor_partial_assign(0, 8, 0b1100_0101);
1691        assert_eq!(res, 0b0111_0110);
1692
1693        let mut res = val;
1694        res.xor_partial_assign(0, 0, 0b1100_0101);
1695        assert_eq!(res, val);
1696
1697        let mut res = val;
1698        res.xor_partial_assign(0, 1, 0b1100_0101);
1699        assert_eq!(res, 0b0011_0011);
1700
1701        let mut res = val;
1702        res.xor_partial_assign(7, 1, 0b0000_0000);
1703        assert_eq!(res, 0b1011_0011);
1704
1705        let mut res = val;
1706        res.xor_partial_assign(2, 3, 0b0000_0000);
1707        assert_eq!(res, 0b1011_0011);
1708
1709        let mut res = val;
1710        res.xor_partial_assign(2, 3, 0b1111_1111);
1711        assert_eq!(res, 0b1000_1011);
1712    }
1713
1714    macro_rules! gen_test {
1715        ($ty:ident, $test_name:ident) => {
1716            #[test]
1717            pub fn $test_name() {
1718                let bitlen = mem::size_of::<$ty>() * 8;
1719                let pow2: $ty = 2;
1720
1721                let mut rng = rand::thread_rng();
1722                let rand: $ty = rng.gen::<$ty>();
1723
1724                //test msb0_to_lsb0 $t
1725                assert_eq!(rand.as_lsb0(bitlen), rand);
1726                let converted = rand.as_lsb0(5);
1727
1728                assert_eq!(converted, rand / pow2.pow(bitlen as u32 - 5) as $ty);
1729
1730                //test lsb0_to_msb0
1731                let rand: $ty = converted;
1732
1733                assert_eq!(rand.as_msb0(bitlen), rand);
1734                assert_eq!(rand.as_msb0(5), rand * pow2.pow(bitlen as u32 - 5) as $ty);
1735            }
1736        };
1737    }
1738
1739    gen_test! {u8,test_bit_order_convert_u8}
1740    gen_test! {u16,test_bit_order_convert_u16}
1741    gen_test! {u32,test_bit_order_convert_u32}
1742    gen_test! {u64,test_bit_order_convert_u64}
1743    gen_test! {u128,test_bit_order_convert_u128}
1744
1745    #[test]
1746    pub fn test_convert_zero() {
1747        let val: u8 = 0b0000_0000;
1748        assert_eq!(0, val.as_lsb0(0));
1749        assert_eq!(0, val.as_msb0(0));
1750    }
1751
1752    #[test]
1753    pub fn test_lsb_ones() {
1754        assert_eq!(lsb_ones(0), 0b0000_0000);
1755        assert_eq!(lsb_ones(1), 0b0000_0001);
1756        assert_eq!(lsb_ones(2), 0b0000_0011);
1757        assert_eq!(lsb_ones(3), 0b0000_0111);
1758        assert_eq!(lsb_ones(4), 0b0000_1111);
1759        assert_eq!(lsb_ones(5), 0b0001_1111);
1760        assert_eq!(lsb_ones(6), 0b0011_1111);
1761        assert_eq!(lsb_ones(7), 0b0111_1111);
1762        assert_eq!(lsb_ones(8), 0b1111_1111);
1763    }
1764
1765    #[test]
1766    pub fn test_msb_ones() {
1767        assert_eq!(msb_ones(0), 0b0000_0000);
1768        assert_eq!(msb_ones(1), 0b1000_0000);
1769        assert_eq!(msb_ones(2), 0b1100_0000);
1770        assert_eq!(msb_ones(3), 0b1110_0000);
1771        assert_eq!(msb_ones(4), 0b1111_0000);
1772        assert_eq!(msb_ones(5), 0b1111_1000);
1773        assert_eq!(msb_ones(6), 0b1111_1100);
1774        assert_eq!(msb_ones(7), 0b1111_1110);
1775        assert_eq!(msb_ones(8), 0b1111_1111);
1776    }
1777
1778    #[test]
1779    pub fn test_msb_nth_zero() {
1780        assert_eq!(msb_nth_zero!(0), 0b0111_1111);
1781        assert_eq!(msb_nth_zero!(1), 0b1011_1111);
1782        assert_eq!(msb_nth_zero!(2), 0b1101_1111);
1783        assert_eq!(msb_nth_zero!(3), 0b1110_1111);
1784        assert_eq!(msb_nth_zero!(4), 0b1111_0111);
1785        assert_eq!(msb_nth_zero!(5), 0b1111_1011);
1786        assert_eq!(msb_nth_zero!(6), 0b1111_1101);
1787        assert_eq!(msb_nth_zero!(7), 0b1111_1110);
1788    }
1789
1790    #[test]
1791    pub fn test_lsb_nth_zero() {
1792        assert_eq!(lsb_nth_zero!(0), 0b1111_1110);
1793        assert_eq!(lsb_nth_zero!(1), 0b1111_1101);
1794        assert_eq!(lsb_nth_zero!(2), 0b1111_1011);
1795        assert_eq!(lsb_nth_zero!(3), 0b1111_0111);
1796        assert_eq!(lsb_nth_zero!(4), 0b1110_1111);
1797        assert_eq!(lsb_nth_zero!(5), 0b1101_1111);
1798        assert_eq!(lsb_nth_zero!(6), 0b1011_1111);
1799        assert_eq!(lsb_nth_zero!(7), 0b0111_1111);
1800    }
1801}
deepmesa_collections/bitvec/traits.rs

deepmesa_collections/bitvec/
traits.rs
