MRG: add skipmers; switch to reading frame approach for translation, skipmers

.github/dependabot.yml

@@ -17,6 +17,8 @@ updates:
     - dependency-name: "wasm-bindgen"
     - dependency-name: "once_cell"
     - dependency-name: "chrono"
+    - dependency-name: "js-sys"
+    - dependency-name: "web-sys"
 - package-ecosystem: "github-actions"
   directory: "/"
   schedule:

src/core/Cargo.toml

@@ -96,8 +96,8 @@ skip_feature_sets = [
 ## Wasm section. Crates only used for WASM, as well as specific configurations
 
 [target.'cfg(all(target_arch = "wasm32", target_os="unknown"))'.dependencies]
-js-sys = "0.3.74"
-web-sys = { version = "0.3.74", features = ["console", "File", "FileReaderSync"] }
+js-sys = "0.3.72"
+web-sys = { version = "0.3.72", features = ["console", "File", "FileReaderSync"] }
 wasm-bindgen = "0.2.89"
 getrandom = { version = "0.2", features = ["js"] }
 

src/core/src/cmd.rs

@@ -42,6 +42,14 @@ pub struct ComputeParameters {
     #[builder(default = false)]
     hp: bool,
 
+    #[getset(get_copy = "pub", set = "pub")]
+    #[builder(default = false)]
+    skipm1n3: bool,
+
+    #[getset(get_copy = "pub", set = "pub")]
+    #[builder(default = false)]
+    skipm2n3: bool,
+
     #[getset(get_copy = "pub", set = "pub")]
     #[builder(default = false)]
     singleton: bool,
@@ -165,6 +173,40 @@ pub fn build_template(params: &ComputeParameters) -> Vec<Sketch> {
                 ));
             }
 
+            if params.skipm1n3 {
+                ksigs.push(Sketch::LargeMinHash(
+                    KmerMinHashBTree::builder()
+                        .num(params.num_hashes)
+                        .ksize(*k)
+                        .hash_function(HashFunctions::Murmur64Skipm1n3)
+                        .max_hash(max_hash)
+                        .seed(params.seed)
+                        .abunds(if params.track_abundance {
+                            Some(Default::default())
+                        } else {
+                            None
+                        })
+                        .build(),
+                ));
+            }
+
+            if params.skipm2n3 {
+                ksigs.push(Sketch::LargeMinHash(
+                    KmerMinHashBTree::builder()
+                        .num(params.num_hashes)
+                        .ksize(*k)
+                        .hash_function(HashFunctions::Murmur64Skipm2n3)
+                        .max_hash(max_hash)
+                        .seed(params.seed)
+                        .abunds(if params.track_abundance {
+                            Some(Default::default())
+                        } else {
+                            None
+                        })
+                        .build(),
+                ));
+            }
+
             if params.dna {
                 ksigs.push(Sketch::LargeMinHash(
                     KmerMinHashBTree::builder()

src/core/src/encodings.rs

@@ -31,6 +31,8 @@
     Murmur64Protein,
     Murmur64Dayhoff,
     Murmur64Hp,
+    Murmur64Skipm1n3,
+    Murmur64Skipm2n3,
     Custom(String),
 }
 
@@ -50,6 +52,14 @@
     pub fn hp(&self) -> bool {
         *self == HashFunctions::Murmur64Hp
     }
+
+    pub fn skipm1n3(&self) -> bool {
+        *self == HashFunctions::Murmur64Skipm1n3
+    }
+
+    pub fn skipm2n3(&self) -> bool {
+        *self == HashFunctions::Murmur64Skipm2n3
+    }
 }
 
 impl std::fmt::Display for HashFunctions {
@@ -62,6 +72,8 @@
                 HashFunctions::Murmur64Protein => "protein",
                 HashFunctions::Murmur64Dayhoff => "dayhoff",
                 HashFunctions::Murmur64Hp => "hp",
+                HashFunctions::Murmur64Skipm1n3 => "skipm1n3",
+                HashFunctions::Murmur64Skipm2n3 => "skipm2n3",
                 HashFunctions::Custom(v) => v,
             }
         )
@@ -77,6 +89,8 @@
             "dayhoff" => Ok(HashFunctions::Murmur64Dayhoff),
             "hp" => Ok(HashFunctions::Murmur64Hp),
             "protein" => Ok(HashFunctions::Murmur64Protein),
+            "skipm1n3" => Ok(HashFunctions::Murmur64Skipm1n3),
+            "skipm2n3" => Ok(HashFunctions::Murmur64Skipm2n3),
             v => unimplemented!("{v}"),
         }
     }
@@ -506,6 +520,7 @@
 #[cfg(test)]
 mod test {
     use super::*;
+    use std::convert::TryFrom;
 
     #[test]
     fn colors_update() {
@@ -573,4 +588,94 @@
 
         assert_eq!(colors.len(), 2);
     }
+
+    #[test]
+    fn test_dna_method() {
+        assert!(HashFunctions::Murmur64Dna.dna());
+        assert!(!HashFunctions::Murmur64Protein.dna());
+        assert!(!HashFunctions::Murmur64Dayhoff.dna());
+    }
+
+    #[test]
+    fn test_protein_method() {
+        assert!(HashFunctions::Murmur64Protein.protein());
+        assert!(!HashFunctions::Murmur64Dna.protein());
+        assert!(!HashFunctions::Murmur64Dayhoff.protein());
+    }
+
+    #[test]
+    fn test_dayhoff_method() {
+        assert!(HashFunctions::Murmur64Dayhoff.dayhoff());
+        assert!(!HashFunctions::Murmur64Dna.dayhoff());
+        assert!(!HashFunctions::Murmur64Protein.dayhoff());
+    }
+
+    #[test]
+    fn test_hp_method() {
+        assert!(HashFunctions::Murmur64Hp.hp());
+        assert!(!HashFunctions::Murmur64Dna.hp());
+        assert!(!HashFunctions::Murmur64Protein.hp());
+    }
+
+    #[test]
+    fn test_skipm1n3_method() {
+        assert!(HashFunctions::Murmur64Skipm1n3.skipm1n3());
+        assert!(!HashFunctions::Murmur64Dna.skipm1n3());
+        assert!(!HashFunctions::Murmur64Protein.skipm1n3());
+    }
+
+    #[test]
+    fn test_skipm2n3_method() {
+        assert!(HashFunctions::Murmur64Skipm2n3.skipm2n3());
+        assert!(!HashFunctions::Murmur64Dna.skipm2n3());
+        assert!(!HashFunctions::Murmur64Protein.skipm2n3());
+    }
+
+    #[test]
+    fn test_display_hashfunctions() {
+        assert_eq!(HashFunctions::Murmur64Dna.to_string(), "DNA");
+        assert_eq!(HashFunctions::Murmur64Protein.to_string(), "protein");
+        assert_eq!(HashFunctions::Murmur64Dayhoff.to_string(), "dayhoff");
+        assert_eq!(HashFunctions::Murmur64Hp.to_string(), "hp");
+        assert_eq!(HashFunctions::Murmur64Skipm1n3.to_string(), "skipm1n3");
+        assert_eq!(HashFunctions::Murmur64Skipm2n3.to_string(), "skipm2n3");
+        assert_eq!(
+            HashFunctions::Custom("custom_string".into()).to_string(),
+            "custom_string"
+        );
+    }
+
+    #[test]
+    fn test_try_from_str_valid() {
+        assert_eq!(
+            HashFunctions::try_from("dna").unwrap(),
+            HashFunctions::Murmur64Dna
+        );
+        assert_eq!(
+            HashFunctions::try_from("protein").unwrap(),
+            HashFunctions::Murmur64Protein
+        );
+        assert_eq!(
+            HashFunctions::try_from("dayhoff").unwrap(),
+            HashFunctions::Murmur64Dayhoff
+        );
+        assert_eq!(
+            HashFunctions::try_from("hp").unwrap(),
+            HashFunctions::Murmur64Hp
+        );
+        assert_eq!(
+            HashFunctions::try_from("skipm1n3").unwrap(),
+            HashFunctions::Murmur64Skipm1n3
+        );
+        assert_eq!(
+            HashFunctions::try_from("skipm2n3").unwrap(),
+            HashFunctions::Murmur64Skipm2n3
+        );
+    }
+
+    #[test]
+    #[should_panic(expected = "not implemented: unknown")]
+    fn test_try_from_str_invalid() {
+        HashFunctions::try_from("unknown").unwrap();
+    }
 }