fixes

Author: nh13

Cargo.lock

@@ -49,7 +49,6 @@ serde-aux = "4.1.2"
 seq_io = "0.3.1"
 thiserror = "1.0.37"
 proglog = {version = "0.3.0", features = ["pretty_counts"] }
-lazy_static = "1.5.0"
 
 [dev-dependencies]
 csv = "1.1.6"

Cargo.toml

@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly"
+channel = "1.85"
 components = ["rustfmt", "clippy"]

rust-toolchain.toml

@@ -424,19 +424,28 @@ impl BitEnc {
     /// corresponding (IUPAC) base in this sequence. E.g. If the other sequence is an
     /// N, it will not match anything but an N, and if the other base is an R, it
     /// will match R, V, D, and N, since the latter IUPAC codes allow both A and G.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the length and widths of the two sequences are not the same.
+    #[must_use]
     pub fn hamming(&self, other: &BitEnc, max_mismatches: u32) -> u32 {
         assert!(self.len == other.len, "Both bitenc sequences must have the same length");
         assert!(self.width == other.width, "Both bitenc sequences must have the same width");
         let mut count: u32 = 0;
         let values_per_block = self.usable_bits_per_block / self.width;
         for block_index in 0..self.nr_blocks() {
-            let intersection = self.storage[block_index] & other.storage[block_index];
-            if intersection != self.storage[block_index] {
+            // Get the bits that are different across the two blocks.  These represent differences
+            // in values (bases), where multiple values (bases) are stored in each block.  We
+            // save the block differences so we efficiently count the differences below.
+            let block_diff = self.storage[block_index] & !other.storage[block_index];
+            if block_diff != 0 {
+                // Scan through the values (bases) in the block, counting those values (bases)
+                // that are different.
                 let mut shift_i = 0;
                 for _ in 0..values_per_block {
-                    let intersection_sub = (intersection >> shift_i) & self.mask;
-                    let self_sub = (self.storage[block_index] >> shift_i) & self.mask;
-                    if intersection_sub != self_sub {
+                    let block_diff_sub = (block_diff >> shift_i) & self.mask;
+                    if block_diff_sub != 0 {
                         count += 1;
                     }
                     shift_i += self.width;
@@ -528,9 +537,10 @@ mod tests {
         // | 42 42 42 42 | 17 17 23 42 | 17 17 17 17 | 17 17 17 17 | __ __ 17 17 |
 
         let values: Vec<u8> = bitenc.iter().collect();
-        assert_eq!(values, [
-            42, 42, 42, 42, 42, 23, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17
-        ]);
+        assert_eq!(
+            values,
+            [42, 42, 42, 42, 42, 23, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17]
+        );
         assert_eq!(bitenc.nr_blocks(), 5);
         assert_eq!(bitenc.nr_symbols(), 18);
     }

src/lib/bitenc.rs

@@ -3,50 +3,48 @@ pub mod bitenc;
 pub mod samples;
 
 use crate::bitenc::BitEnc;
-use lazy_static::lazy_static;
+use std::sync::LazyLock;
 
 pub const DNA_BASES: [u8; 5] = *b"ACGTN";
 pub const IUPAC_BASES: [u8; 15] = *b"ACGTMRWSYKVHDBN";
 
-lazy_static! {
-    pub static ref BASE_A: usize = 1;
-    pub static ref BASE_C: usize = 2;
-    pub static ref BASE_G: usize = 4;
-    pub static ref BASE_T: usize = 8;
-    pub static ref BASE_N: usize = 15;
-    pub static ref DNA_MASKS: [u8; 256] = {
-        let mut masks = [0; 256];
-        let (a, c, g, t) = (1, 2, 4, 8);
-        masks['A' as usize] = a;
-        masks['C' as usize] = c;
-        masks['G' as usize] = g;
-        masks['T' as usize] = t;
-        masks['U' as usize] = t;
-        masks['N' as usize] = a | c | g | t;
-        masks
-    };
-    pub static ref IUPAC_MASKS: [u8; 256] = {
-        let mut masks = [0; 256];
-        let (a, c, g, t) = (1, 2, 4, 8);
-        masks['A' as usize] = a;
-        masks['C' as usize] = c;
-        masks['G' as usize] = g;
-        masks['T' as usize] = t;
-        masks['U' as usize] = t;
-        masks['M' as usize] = a | c;
-        masks['R' as usize] = a | g;
-        masks['W' as usize] = a | t;
-        masks['S' as usize] = c | g;
-        masks['Y' as usize] = c | t;
-        masks['K' as usize] = g | t;
-        masks['V' as usize] = a | c | g;
-        masks['H' as usize] = a | c | t;
-        masks['D' as usize] = a | g | t;
-        masks['B' as usize] = c | g | t;
-        masks['N' as usize] = a | c | g | t;
-        masks
-    };
-}
+pub static BASE_A: LazyLock<usize> = LazyLock::new(|| 1);
+pub static BASE_C: LazyLock<usize> = LazyLock::new(|| 2);
+pub static BASE_G: LazyLock<usize> = LazyLock::new(|| 4);
+pub static BASE_T: LazyLock<usize> = LazyLock::new(|| 8);
+pub static BASE_N: LazyLock<usize> = LazyLock::new(|| 15);
+pub static DNA_MASKS: LazyLock<[u8; 256]> = LazyLock::new(|| {
+    let mut masks = [0; 256];
+    let (a, c, g, t) = (1, 2, 4, 8);
+    masks['A' as usize] = a;
+    masks['C' as usize] = c;
+    masks['G' as usize] = g;
+    masks['T' as usize] = t;
+    masks['U' as usize] = t;
+    masks['N' as usize] = a | c | g | t;
+    masks
+});
+pub static IUPAC_MASKS: LazyLock<[u8; 256]> = LazyLock::new(|| {
+    let mut masks = [0; 256];
+    let (a, c, g, t) = (1, 2, 4, 8);
+    masks['A' as usize] = a;
+    masks['C' as usize] = c;
+    masks['G' as usize] = g;
+    masks['T' as usize] = t;
+    masks['U' as usize] = t;
+    masks['M' as usize] = a | c;
+    masks['R' as usize] = a | g;
+    masks['W' as usize] = a | t;
+    masks['S' as usize] = c | g;
+    masks['Y' as usize] = c | t;
+    masks['K' as usize] = g | t;
+    masks['V' as usize] = a | c | g;
+    masks['H' as usize] = a | c | t;
+    masks['D' as usize] = a | g | t;
+    masks['B' as usize] = c | g | t;
+    masks['N' as usize] = a | c | g | t;
+    masks
+});
 
 #[must_use]
 pub fn encode(bases: &[u8]) -> BitEnc {
@@ -56,7 +54,11 @@ pub fn encode(bases: &[u8]) -> BitEnc {
             IUPAC_MASKS[b'N' as usize]
         } else {
             let value = base.to_ascii_uppercase() as usize;
-            if value < 256 { IUPAC_MASKS[value] } else { 0 }
+            if value < 256 {
+                IUPAC_MASKS[value]
+            } else {
+                0
+            }
         };
         vec.push(bit);
     }