Merge branch 'main' into feature/aggregation

codecov.yml

@@ -7,6 +7,13 @@ coverage:
         target: 90%
         flags:
           - fa-compression
+    patch:
+      default:
+        target: 90%
+      fa-compression:
+        target: 90%
+        flags:
+          - fa-compression
 
 flags:
   fa-compression:

fa-compression/Cargo.toml

@@ -10,5 +10,9 @@ criterion = "0.5.1"
 rand = "0.8.5"
 
 [[bench]]
+opt-level = 0
 name = "bench_main"
 harness = false
+
+[profile.bench]
+opt-level=3

fa-compression/benches/algorithm1/decode.rs

@@ -0,0 +1,31 @@
+use criterion::black_box;
+use fa_compression::algorithm1::{
+    decode,
+    encode
+};
+
+use super::util::generate_annotation;
+
+/// Generate a random number of encoded annotations.
+fn generate_encoded_annotations(count: usize) -> Vec<u8> {
+    let mut random = rand::thread_rng();
+
+    let mut annotations = String::new();
+    for _ in 0 .. count {
+        annotations.push_str(&generate_annotation(&mut random));
+        annotations.push(';');
+    }
+    annotations.pop();
+
+    encode(annotations.as_str())
+}
+
+pub fn decode_benchmark(c: &mut criterion::Criterion) {
+    c.bench_function("decode_algorithm1", |b| {
+        b.iter_batched(
+            || generate_encoded_annotations(100),
+            |annotations| black_box(decode(annotations.as_slice())),
+            criterion::BatchSize::SmallInput
+        )
+    });
+}

fa-compression/benches/algorithm1/encode.rs

@@ -0,0 +1,28 @@
+use criterion::black_box;
+use fa_compression::algorithm1::encode;
+
+use super::util::generate_annotation;
+
+/// Generate a random number of decoded annotations.
+fn generate_decoded_annotations(count: usize) -> String {
+    let mut random = rand::thread_rng();
+
+    let mut annotations = String::new();
+    for _ in 0 .. count {
+        annotations.push_str(&generate_annotation(&mut random));
+        annotations.push(';');
+    }
+
+    annotations.pop();
+    annotations
+}
+
+pub fn encode_benchmark(c: &mut criterion::Criterion) {
+    c.bench_function("encode_algorithm1", |b| {
+        b.iter_batched(
+            || generate_decoded_annotations(100),
+            |annotations| black_box(encode(annotations.as_str())),
+            criterion::BatchSize::SmallInput
+        )
+    });
+}

fa-compression/benches/algorithm1/mod.rs

@@ -0,0 +1,8 @@
+use criterion::criterion_group;
+
+use super::util;
+
+mod decode;
+mod encode;
+
+criterion_group!(benches, encode::encode_benchmark, decode::decode_benchmark);

fa-compression/benches/algorithm2/decode.rs

@@ -0,0 +1,38 @@
+use criterion::black_box;
+use fa_compression::algorithm2::{
+    decode,
+    encode,
+    CompressionTable
+};
+
+use super::util::generate_annotation;
+
+fn generate_encoded_annotations_and_table(count: usize) -> (Vec<u8>, CompressionTable) {
+    let mut random = rand::thread_rng();
+
+    let mut compression_table1 = CompressionTable::new();
+    let mut compression_table2 = CompressionTable::new();
+
+    let mut annotations = String::new();
+    for _ in 0 .. count {
+        let annotation = generate_annotation(&mut random);
+        annotations.push_str(&annotation);
+        annotations.push(';');
+        compression_table1.add_entry(annotation.clone());
+        compression_table2.add_entry(annotation);
+    }
+
+    annotations.pop();
+
+    (encode(annotations.as_str(), compression_table1), compression_table2)
+}
+
+pub fn decode_benchmark(c: &mut criterion::Criterion) {
+    c.bench_function("decode_algorithm2", |b| {
+        b.iter_batched(
+            || generate_encoded_annotations_and_table(100),
+            |(annotations, ct)| black_box(decode(annotations.as_slice(), ct)),
+            criterion::BatchSize::SmallInput
+        )
+    });
+}

fa-compression/benches/algorithm2/encode.rs

@@ -0,0 +1,35 @@
+use criterion::black_box;
+use fa_compression::algorithm2::{
+    encode,
+    CompressionTable
+};
+
+use super::util::generate_annotation;
+
+fn generate_decoded_annotations_and_table(count: usize) -> (String, CompressionTable) {
+    let mut random = rand::thread_rng();
+
+    let mut compression_table = CompressionTable::new();
+
+    let mut annotations = String::new();
+    for _ in 0 .. count {
+        let annotation = generate_annotation(&mut random);
+        annotations.push_str(&annotation);
+        annotations.push(';');
+        compression_table.add_entry(annotation);
+    }
+
+    annotations.pop();
+
+    (annotations, compression_table)
+}
+
+pub fn encode_benchmark(c: &mut criterion::Criterion) {
+    c.bench_function("encode_algorithm2", |b| {
+        b.iter_batched(
+            || generate_decoded_annotations_and_table(100),
+            |(annotations, ct)| black_box(encode(annotations.as_str(), ct)),
+            criterion::BatchSize::SmallInput
+        )
+    });
+}

fa-compression/benches/algorithm2/mod.rs

@@ -0,0 +1,8 @@
+use criterion::criterion_group;
+
+use super::util;
+
+mod decode;
+mod encode;
+
+criterion_group!(benches, encode::encode_benchmark, decode::decode_benchmark);

fa-compression/benches/bench_main.rs

@@ -1,34 +1,7 @@
-use criterion::{
-    black_box,
-    criterion_group,
-    criterion_main
-};
-use fa_compression::{
-    decode,
-    encode
-};
+use criterion::criterion_main;
 
+mod algorithm1;
+mod algorithm2;
 mod util;
 
-fn encode_benchmark(c: &mut criterion::Criterion) {
-    c.bench_function("encode", |b| {
-        b.iter_batched(
-            || util::generate_decoded_annotations(100),
-            |annotations| black_box(encode(annotations.as_str())),
-            criterion::BatchSize::SmallInput
-        )
-    });
-}
-
-fn decode_benchmark(c: &mut criterion::Criterion) {
-    c.bench_function("decode", |b| {
-        b.iter_batched(
-            || util::generate_encoded_annotations(100),
-            |annotations| black_box(decode(annotations.as_slice())),
-            criterion::BatchSize::SmallInput
-        )
-    });
-}
-
-criterion_group!(benches, encode_benchmark, decode_benchmark);
-criterion_main!(benches);
+criterion_main!(algorithm1::benches, algorithm2::benches);

fa-compression/benches/util.rs

@@ -1,4 +1,3 @@
-use fa_compression::encode;
 use rand::{
     rngs::ThreadRng,
     Rng
@@ -34,30 +33,3 @@ pub fn generate_annotation(random: &mut ThreadRng) -> String {
         _ => unreachable!()
     }
 }
-
-/// Generate a random number of decoded annotations.
-pub fn generate_decoded_annotations(count: usize) -> String {
-    let mut random = rand::thread_rng();
-
-    let mut annotations = String::new();
-    for _ in 0 .. count {
-        annotations.push_str(&generate_annotation(&mut random));
-        annotations.push(';');
-    }
-    annotations.pop();
-    annotations
-}
-
-/// Generate a random number of encoded annotations.
-pub fn generate_encoded_annotations(count: usize) -> Vec<u8> {
-    let mut random = rand::thread_rng();
-
-    let mut annotations = String::new();
-    for _ in 0 .. count {
-        annotations.push_str(&generate_annotation(&mut random));
-        annotations.push(';');
-    }
-    annotations.pop();
-
-    encode(annotations.as_str())
-}

fa-compression/src/decode.rs → fa-compression/src/algorithm1/decode.rs

@@ -1,7 +1,7 @@
 //! This module provides a function to decode a byte array into a string representation of
 //! annotations.
 
-use crate::{
+use super::{
     CharacterSet,
     Decode
 };
@@ -26,7 +26,7 @@ static PREFIXES: [&str; 3] = ["EC:", "GO:", "IPR:IPR"];
 /// # Examples
 ///
 /// ```
-/// use fa_compression::decode;
+/// use fa_compression::algorithm1::decode;
 ///
 /// let input = &[ 44, 44, 44, 189, 17, 26, 56, 173, 18, 116, 117, 225, 67, 116, 110, 17, 153, 39 ];
 /// let result = decode(input);

fa-compression/src/encode.rs → fa-compression/src/algorithm1/encode.rs

@@ -1,6 +1,6 @@
 //! This module contains the function to encode the input string into a compressed byte vector.
 
-use crate::{
+use super::{
     CharacterSet,
     Encode
 };
@@ -23,7 +23,7 @@ use crate::{
 /// # Examples
 ///
 /// ```
-/// use fa_compression::encode;
+/// use fa_compression::algorithm1::encode;
 ///
 /// let input = "IPR:IPR016364;EC:1.1.1.-;GO:0009279";
 /// let encoded = encode(input);