Implemented truncate

Author: haxelion

src/auto.rs

@@ -300,13 +300,13 @@ impl BitVector for Bv {
         }
     }
 
-    fn resize(&mut self, new_length: usize, bit: Bit) {
-        if new_length > self.len() {
-            self.reserve(new_length - self.len());
+    fn resize(&mut self, new_len: usize, bit: Bit) {
+        if new_len > self.len() {
+            self.reserve(new_len - self.len());
         }
         match self {
-            Bv::Fixed(b) => b.resize(new_length, bit),
-            Bv::Dynamic(b) => b.resize(new_length, bit),
+            Bv::Fixed(b) => b.resize(new_len, bit),
+            Bv::Dynamic(b) => b.resize(new_len, bit),
         }
     }
 

src/dynamic.rs

@@ -372,31 +372,31 @@ impl BitVector for Bvd {
         Some(bit)
     }
 
-    fn resize(&mut self, new_length: usize, bit: Bit) {
-        if new_length < self.length {
-            for i in (new_length / Self::BIT_UNIT + 1)..Self::capacity_from_bit_len(self.length) {
+    fn resize(&mut self, new_len: usize, bit: Bit) {
+        if new_len < self.length {
+            for i in (new_len / Self::BIT_UNIT + 1)..Self::capacity_from_bit_len(self.length) {
                 self.data[i] = 0;
             }
-            if let Some(l) = self.data.get_mut(new_length / Self::BIT_UNIT) {
-                *l &= u64::mask(new_length % Self::BIT_UNIT);
+            if let Some(l) = self.data.get_mut(new_len / Self::BIT_UNIT) {
+                *l &= u64::mask(new_len % Self::BIT_UNIT);
             }
-            self.length = new_length;
-        } else if new_length > self.length {
+            self.length = new_len;
+        } else if new_len > self.length {
             let sign_pattern = match bit {
                 Bit::Zero => u64::MIN,
                 Bit::One => u64::MAX,
             };
-            self.reserve(new_length - self.length);
+            self.reserve(new_len - self.length);
             if let Some(l) = self.data.get_mut(self.length / Self::BIT_UNIT) {
                 *l |= sign_pattern & !u64::mask(self.length % Self::BIT_UNIT);
             }
-            for i in (self.length / Self::BIT_UNIT + 1)..Self::capacity_from_bit_len(new_length) {
+            for i in (self.length / Self::BIT_UNIT + 1)..Self::capacity_from_bit_len(new_len) {
                 self.data[i] = sign_pattern;
             }
-            if let Some(l) = self.data.get_mut(new_length / Self::BIT_UNIT) {
-                *l &= u64::mask(new_length % Self::BIT_UNIT);
+            if let Some(l) = self.data.get_mut(new_len / Self::BIT_UNIT) {
+                *l &= u64::mask(new_len % Self::BIT_UNIT);
             }
-            self.length = new_length;
+            self.length = new_len;
         }
     }
 

src/fixed.rs

@@ -372,31 +372,31 @@ where
         b
     }
 
-    fn resize(&mut self, new_length: usize, bit: Bit) {
-        if new_length < self.length {
-            for i in (new_length / Self::BIT_UNIT + 1)..Self::capacity_from_bit_len(self.length) {
+    fn resize(&mut self, new_len: usize, bit: Bit) {
+        if new_len < self.length {
+            for i in (new_len / Self::BIT_UNIT + 1)..Self::capacity_from_bit_len(self.length) {
                 self.data[i] = I::ZERO;
             }
-            if let Some(l) = self.data.get_mut(new_length / Self::BIT_UNIT) {
-                *l &= I::mask(new_length % Self::BIT_UNIT);
+            if let Some(l) = self.data.get_mut(new_len / Self::BIT_UNIT) {
+                *l &= I::mask(new_len % Self::BIT_UNIT);
             }
-            self.length = new_length;
-        } else if new_length > self.length {
-            debug_assert!(new_length <= Self::capacity());
+            self.length = new_len;
+        } else if new_len > self.length {
+            debug_assert!(new_len <= Self::capacity());
             let sign_pattern = match bit {
                 Bit::Zero => I::MIN,
                 Bit::One => I::MAX,
             };
             if let Some(l) = self.data.get_mut(self.length / Self::BIT_UNIT) {
                 *l |= sign_pattern & !I::mask(self.length % Self::BIT_UNIT);
             }
-            for i in (self.length / Self::BIT_UNIT + 1)..Self::capacity_from_bit_len(new_length) {
+            for i in (self.length / Self::BIT_UNIT + 1)..Self::capacity_from_bit_len(new_len) {
                 self.data[i] = sign_pattern;
             }
-            if let Some(l) = self.data.get_mut(new_length / Self::BIT_UNIT) {
-                *l &= I::mask(new_length % Self::BIT_UNIT);
+            if let Some(l) = self.data.get_mut(new_len / Self::BIT_UNIT) {
+                *l &= I::mask(new_len % Self::BIT_UNIT);
             }
-            self.length = new_length;
+            self.length = new_len;
         }
     }
 

src/lib.rs

@@ -459,7 +459,7 @@ pub trait BitVector:
     /// ```
     fn pop(&mut self) -> Option<Bit>;
 
-    /// Resize the bit vector in place so that its length is equal to `new_length`.
+    /// Resize the bit vector in place so that its length is equal to `new_len`.
     /// This will either truncate or extend the bit vector. If it is extended, new bits are filled
     /// with `bit`.
     /// Will panic if there is not enough capacity and it is a fixed variant.
@@ -471,7 +471,23 @@ pub trait BitVector:
     /// a.resize(10, Bit::One);
     /// assert_eq!(a, Bv::from(0b1100000000u16));
     /// ```
-    fn resize(&mut self, new_length: usize, bit: Bit);
+    fn resize(&mut self, new_len: usize, bit: Bit);
+
+    /// Truncate the bit vector in place, keeping the first `new_len` bits.
+    /// If `new_len` is greater or equal to the bit vector’s current length, this has no effect.
+    ///
+    /// ```
+    /// use bva::{Bit, BitVector, Bv};
+    ///
+    /// let mut a = Bv::from(0b111000110010u16);
+    /// a.truncate(8);
+    /// assert_eq!(a, Bv::from(0b00110010u16));
+    /// ```
+    fn truncate(&mut self, new_len: usize) {
+        if new_len < self.len() {
+            self.resize(new_len, Bit::Zero);
+        }
+    }
 
     /// Resize this bit vector using the most significant bit as a sign bit so that its length
     /// is equal to `new_length`. If `new_length` is smaller than the current length, this method

src/tests/bitvector.rs

@@ -632,6 +632,33 @@ fn resize_bv() {
     resize_inner::<Bv>(256);
 }
 
+fn truncate_inner<B: BitVector>(max_capacity: usize) {
+    let bv: B = random_bv(max_capacity);
+
+    for len in (0..bv.len()).rev() {
+        let mut bv2 = bv.clone();
+        bv2.truncate(len);
+        for i in 0..bv2.len() {
+            assert_eq!(bv.get(i), bv2.get(i));
+        }
+    }
+}
+
+#[test]
+fn truncate_bvf() {
+    bvf_inner_unroll_cap!(truncate_inner, {u8, u16, u32, u64, u128}, {1, 2, 3, 4, 5});
+}
+
+#[test]
+fn truncate_bvd() {
+    truncate_inner::<Bvd>(256);
+}
+
+#[test]
+fn truncate_bv() {
+    truncate_inner::<Bv>(256);
+}
+
 fn sign_extend_inner<B: BitVector>(max_capacity: usize) {
     for capacity in 0..max_capacity {
         let bv = random_bv::<B>(capacity);