Implemented Hash trait

Author: haxelion

src/auto.rs

@@ -52,7 +52,7 @@ pub(crate) type Bvp = Bv128;
 /// assert_eq!(c.len(), 256);
 /// assert_eq!(c.to_string(), "26");
 /// ```
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Hash)]
 pub enum Bv {
     #[doc(hidden)]
     Fixed(Bvp),

src/dynamic.rs

@@ -1,5 +1,6 @@
 use std::cmp::Ordering;
 use std::fmt;
+use std::hash::{Hash, Hasher};
 use std::io::{Read, Write};
 use std::iter::repeat;
 use std::mem::size_of;
@@ -621,6 +622,19 @@ impl BitVector for Bvd {
     }
 }
 
+// ------------------------------------------------------------------------------------------------
+// Bvd - Hasher Implementation
+// ------------------------------------------------------------------------------------------------
+
+impl Hash for Bvd {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.length.hash(state);
+        for i in 0..Self::capacity_from_bit_len(self.length) {
+            self.data[i].hash(state);
+        }
+    }
+}
+
 // ------------------------------------------------------------------------------------------------
 // Bvd - Bit iterator traits
 // ------------------------------------------------------------------------------------------------

src/fixed.rs

@@ -1,5 +1,6 @@
 use std::cmp::Ordering;
 use std::fmt;
+use std::hash::{Hash, Hasher};
 use std::iter::repeat;
 use std::mem::size_of;
 use std::ops::{
@@ -619,6 +620,19 @@ where
     }
 }
 
+// ------------------------------------------------------------------------------------------------
+// Bvf - Hasher Implementation
+// ------------------------------------------------------------------------------------------------
+
+impl<I: Integer, const N: usize> Hash for Bvf<I, N> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.length.hash(state);
+        for i in 0..Self::capacity_from_bit_len(self.length) {
+            self.data[i].hash(state);
+        }
+    }
+}
+
 // ------------------------------------------------------------------------------------------------
 // Bvf - Bit iterator trait
 // ------------------------------------------------------------------------------------------------

src/lib.rs

@@ -104,6 +104,7 @@
 )]
 
 use std::fmt::{Binary, Debug, Display, LowerHex, Octal, UpperHex};
+use std::hash::Hash;
 use std::io::{Read, Write};
 use std::ops::Range;
 
@@ -164,6 +165,7 @@ pub trait BitVector:
     + Debug
     + Display
     + Eq
+    + Hash
     + IArray
     + IArrayMut
     + LowerHex

src/tests/auto.rs

@@ -1,5 +1,8 @@
+use std::hash::{DefaultHasher, Hash, Hasher};
+
 use crate::auto::Bv;
 use crate::bit::Bit;
+use crate::tests::random_bv;
 use crate::BitVector;
 
 #[test]
@@ -14,3 +17,16 @@ fn shrink_to_fit_bv() {
         assert_eq!(bv, Bv::ones(length));
     }
 }
+
+#[test]
+fn hash() {
+    for length in 0..512 {
+        let bv1 = random_bv::<Bv>(length);
+        let bv2 = random_bv::<Bv>(length);
+        let mut hasher1 = DefaultHasher::new();
+        let mut hasher2 = DefaultHasher::new();
+        bv1.hash(&mut hasher1);
+        bv2.hash(&mut hasher2);
+        assert_eq!(hasher1.finish() == hasher2.finish(), bv1 == bv2);
+    }
+}

src/tests/dynamic.rs

@@ -1,3 +1,5 @@
+use std::hash::{DefaultHasher, Hash, Hasher};
+
 use crate::bit::Bit;
 use crate::dynamic::Bvd;
 use crate::tests::random_bv;
@@ -13,6 +15,19 @@ fn new_into() {
     }
 }
 
+#[test]
+fn hash() {
+    for length in 0..512 {
+        let bv1 = random_bv::<Bvd>(length);
+        let bv2 = random_bv::<Bvd>(length);
+        let mut hasher1 = DefaultHasher::new();
+        let mut hasher2 = DefaultHasher::new();
+        bv1.hash(&mut hasher1);
+        bv2.hash(&mut hasher2);
+        assert_eq!(hasher1.finish() == hasher2.finish(), bv1 == bv2);
+    }
+}
+
 #[test]
 fn shrink_to_fit_bvd() {
     let capacity = 512;

src/tests/fixed.rs

@@ -1,3 +1,5 @@
+use std::hash::{DefaultHasher, Hash, Hasher};
+
 use crate::fixed::Bvf;
 use crate::tests::{bvf_inner_unroll, random_bv};
 use crate::utils::Integer;
@@ -11,7 +13,24 @@ fn new_into_inner<I: Integer, const N: usize>() {
     }
 }
 
+fn hash_inner<I: Integer, const N: usize>() {
+    for length in 0..Bvf::<I, N>::capacity() {
+        let bv1 = random_bv::<Bvf<I, N>>(length);
+        let bv2 = random_bv::<Bvf<I, N>>(length);
+        let mut hasher1 = DefaultHasher::new();
+        let mut hasher2 = DefaultHasher::new();
+        bv1.hash(&mut hasher1);
+        bv2.hash(&mut hasher2);
+        assert_eq!(hasher1.finish() == hasher2.finish(), bv1 == bv2);
+    }
+}
+
 #[test]
 fn new_into() {
     bvf_inner_unroll!(new_into_inner, {u8, u16, u32, u64, u128}, {1, 2, 3, 4, 5});
 }
+
+#[test]
+fn hash() {
+    bvf_inner_unroll!(hash_inner, {u8, u16, u32, u64, u128}, {1, 2, 3, 4, 5});
+}

src/utils.rs

@@ -1,4 +1,5 @@
 use std::fmt::{Debug, Display};
+use std::hash::Hash;
 use std::mem::{align_of, size_of, size_of_val};
 use std::ops::{
     Add, AddAssign, BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Div, DivAssign,
@@ -80,6 +81,7 @@ pub trait Integer:
     + Display
     + Eq
     + From<Bit>
+    + Hash
     + Into<Bit>
     + Mul<Output = Self>
     + MulAssign