Format with rustfmt.

rust-bio · Mar 29, 2017 · 2e90c08 · 2e90c08
1 parent ea1b3f8
commit 2e90c08
Show file tree

Hide file tree

Showing 35 changed files with 590 additions and 580 deletions.
diff --git a/benches/distance.rs b/benches/distance.rs
@@ -271,33 +271,29 @@ GCCGCGCGCGCGGGGCCGGGCCGCGCGCGCGCCGGGCCGCCGGCGGGGCGCGGCC";
 
 #[bench]
 fn bench_hamming_dist_equal_str_1000iter(b: &mut Bencher) {
-    b.iter(|| {
-        for _ in 0..1000 {
-            hamming(STR_1, STR_1).unwrap();
-        }
-    });
+    b.iter(|| for _ in 0..1000 {
+               hamming(STR_1, STR_1).unwrap();
+           });
 }
 
 #[bench]
 fn bench_hamming_dist_diverse_str_1000iter(b: &mut Bencher) {
-    b.iter(|| {
-        for _ in 0..1000 {
-            hamming(STR_1, STR_2).unwrap();
-        }
-        });
+    b.iter(|| for _ in 0..1000 {
+               hamming(STR_1, STR_2).unwrap();
+           });
 }
 
 #[bench]
 fn bench_levenshtein_dist_equal_str(b: &mut Bencher) {
-    b.iter(|| { levenshtein(STR_1, STR_1) });
+    b.iter(|| levenshtein(STR_1, STR_1));
 }
 
 #[bench]
 fn bench_levenshtein_dist_diverse_str(b: &mut Bencher) {
-    b.iter(|| { levenshtein(STR_1, STR_2) });
+    b.iter(|| levenshtein(STR_1, STR_2));
 }
 
 #[bench]
 fn bench_levenshtein_dist_worst_str(b: &mut Bencher) {
-    b.iter(|| { levenshtein(STR_3, STR_4) });
-}
+    b.iter(|| levenshtein(STR_3, STR_4));
+}
diff --git a/benches/fmindex.rs b/benches/fmindex.rs
@@ -22,15 +22,14 @@ fn search_index_seeds(b: &mut Bencher) {
         let sequence = b"TCCAAAACAATAACGGAGGTGTCCAAAGGTCAGCTCAGCGTGTGGTTTCT";
         let seed_length = 20;
 
-        let seeds = (0..(sequence.len() + 1 - seed_length))
-            .map(|i| (i, &sequence[i..i + seed_length]));
+        let seeds =
+            (0..(sequence.len() + 1 - seed_length)).map(|i| (i, &sequence[i..i + seed_length]));
 
         let mut loc_temp = Vec::new();
         for (offset, seed) in seeds {
             let interval = fmindex.backward_search(seed.iter());
 
-            loc_temp.extend((interval.lower..interval.upper)
-                .map(|i| (sa[i], offset)));
+            loc_temp.extend((interval.lower..interval.upper).map(|i| (sa[i], offset)));
         }
     });
 }

diff --git a/benches/interval_tree.rs b/benches/interval_tree.rs
@@ -52,8 +52,10 @@ fn assert_intersections(tree: &IntervalTree<i64, Range<i64>>,
                         expected_results: &[Range<i64>]) {
     let mut actual_entries: Vec<_> = tree.find(target).collect();
     actual_entries.sort_by(|x1, x2| x1.data().start.cmp(&x2.data().start));
-    let mut expected_entries: Vec<_> =
-        expected_results.iter().map(|x| (x.clone(), Interval::from(x.clone()))).collect();
+    let mut expected_entries: Vec<_> = expected_results
+        .iter()
+        .map(|x| (x.clone(), Interval::from(x.clone())))
+        .collect();
     expected_entries.sort_by(|x1, x2| x1.0.start.cmp(&x2.0.start));
     assert_eq!(actual_entries.len(), expected_entries.len());
     for (actual, expected) in actual_entries.iter().zip(expected_entries.iter()) {

diff --git a/benches/orf.rs b/benches/orf.rs
@@ -77,13 +77,13 @@ CCAAAATTCTGCCCAGAAGCGTTTAAGTTCGCCCCACTAAAGTTGTCTAAAACGA";
 
 #[bench]
 fn bench_orf(b: &mut Bencher) {
-    let start_codons = vec!(b"ATG");
-    let stop_codons  = vec!(b"TGA", b"TAG", b"TAA");
+    let start_codons = vec![b"ATG"];
+    let stop_codons = vec![b"TGA", b"TAG", b"TAA"];
     let finder = Finder::new(start_codons, stop_codons, 100usize);
-    b.iter(|| { finder.find_all(STR_1).count() });
+    b.iter(|| finder.find_all(STR_1).count());
 }
 
 #[bench]
 fn bench_gc(b: &mut Bencher) {
-	b.iter(|| gc_content(STR_1));
-}
+    b.iter(|| gc_content(STR_1));
+}
diff --git a/benches/pairwise.rs b/benches/pairwise.rs
@@ -143,21 +143,21 @@ CTGTCCAGGACGCCACATGTAGTGAAACTTACATGTTCGTTGGGTTCACCCGACT";
 
 #[bench]
 fn bench_aligner_wc_local(b: &mut Bencher) {
-    let score = |a: u8, b: u8| if a == b {1i32} else {-1i32};
+    let score = |a: u8, b: u8| if a == b { 1i32 } else { -1i32 };
     let mut aligner = Aligner::with_capacity(STR_1.len(), STR_2.len(), -5, -1, &score);
-    b.iter(|| { aligner.local(STR_1, STR_2) });
+    b.iter(|| aligner.local(STR_1, STR_2));
 }
 
 #[bench]
 fn bench_aligner_wc_global(b: &mut Bencher) {
-    let score = |a: u8, b: u8| if a == b {1i32} else {-1i32};
+    let score = |a: u8, b: u8| if a == b { 1i32 } else { -1i32 };
     let mut aligner = Aligner::with_capacity(STR_1.len(), STR_2.len(), -5, -1, &score);
-    b.iter(|| { aligner.global(STR_1, STR_2) });
+    b.iter(|| aligner.global(STR_1, STR_2));
 }
 
 #[bench]
 fn bench_aligner_wc_semiglobal(b: &mut Bencher) {
-    let score = |a: u8, b: u8| if a == b {1i32} else {-1i32};
+    let score = |a: u8, b: u8| if a == b { 1i32 } else { -1i32 };
     let mut aligner = Aligner::with_capacity(STR_1.len(), STR_2.len(), -5, -1, &score);
-    b.iter(|| { aligner.semiglobal(STR_1, STR_2) });
-}
+    b.iter(|| aligner.semiglobal(STR_1, STR_2));
+}
diff --git a/benches/pattern_matching.rs b/benches/pattern_matching.rs
@@ -226,50 +226,40 @@ static PATTERN: &'static [u8] = b"GCGCGTACACACCGCCCG";
 
 #[bench]
 fn bench_shift_and(b: &mut Bencher) {
-    b.iter(|| {
-        for _ in 0..10000 {
-            let shiftand = ShiftAnd::new(PATTERN);
-            shiftand.find_all(TEXT.iter()).collect::<Vec<usize>>();
-        }
-    });
+    b.iter(|| for _ in 0..10000 {
+               let shiftand = ShiftAnd::new(PATTERN);
+               shiftand.find_all(TEXT.iter()).collect::<Vec<usize>>();
+           });
 }
 
 #[bench]
 fn bench_bndm(b: &mut Bencher) {
-    b.iter(|| {
-        for _ in 0..10000 {
-            let bndm = BNDM::new(PATTERN);
-            bndm.find_all(TEXT).collect::<Vec<usize>>();
-        }
-    });
+    b.iter(|| for _ in 0..10000 {
+               let bndm = BNDM::new(PATTERN);
+               bndm.find_all(TEXT).collect::<Vec<usize>>();
+           });
 }
 
 #[bench]
 fn bench_bom(b: &mut Bencher) {
-    b.iter(|| {
-        for _ in 0..10000 {
-            let bom = BOM::new(PATTERN);
-            bom.find_all(TEXT).collect::<Vec<usize>>();
-        }
-    });
+    b.iter(|| for _ in 0..10000 {
+               let bom = BOM::new(PATTERN);
+               bom.find_all(TEXT).collect::<Vec<usize>>();
+           });
 }
 
 #[bench]
 fn bench_horspool(b: &mut Bencher) {
-    b.iter(|| {
-        for _ in 0..10000 {
-            let horspool = Horspool::new(PATTERN);
-            horspool.find_all(TEXT).collect::<Vec<usize>>();
-        }
-    });
+    b.iter(|| for _ in 0..10000 {
+               let horspool = Horspool::new(PATTERN);
+               horspool.find_all(TEXT).collect::<Vec<usize>>();
+           });
 }
 
 #[bench]
 fn bench_kmp(b: &mut Bencher) {
-    b.iter(|| {
-        for _ in 0..10000 {
-            let kmp = KMP::new(PATTERN);
-            kmp.find_all(TEXT.iter()).collect::<Vec<usize>>();
-        }
-    });
+    b.iter(|| for _ in 0..10000 {
+               let kmp = KMP::new(PATTERN);
+               kmp.find_all(TEXT.iter()).collect::<Vec<usize>>();
+           });
 }
diff --git a/benches/suffix_array.rs b/benches/suffix_array.rs
@@ -11,4 +11,4 @@ use bio::data_structures::suffix_array::*;
 #[bench]
 fn bench_suffix_array(b: &mut Bencher) {
     b.iter(|| suffix_array(b"GCCTTAACATTATTACGCCTA$"));
-}
+}
diff --git a/src/alignment/distance.rs b/src/alignment/distance.rs
@@ -39,8 +39,10 @@ use std::result::Result;
 use utils::TextSlice;
 
 
-/// Compute the Hamming distance between two strings with `hamming`. If returns the `Result<u32, &str>` type
-/// with the first element corresponding to the distance between two strings (a number of mismatches) and the second one to the error message
+/// Compute the Hamming distance between two strings with `hamming`.
+/// It returns the `Result<u32, &str>` type
+/// with the first element corresponding to the distance between two strings
+/// (a number of mismatches) and the second one to the error message
 /// when two strings are not of equal sizes.
 ///
 /// # Example
@@ -122,11 +124,7 @@ pub fn levenshtein(alpha: TextSlice, beta: TextSlice) -> u32 {
         columns[i_cur][0] = 1 + j as u32;
         for i in 1..columns[0].len() {
             columns[i_cur][i] = min(columns[i_prev][i - 1] +
-                                    if alpha[i - 1] == *item {
-                                        0
-                                    } else {
-                                        1
-                                    },
+                                    if alpha[i - 1] == *item { 0 } else { 1 },
                                     min(columns[i_cur][i - 1] + 1, columns[i_prev][i] + 1));
         }
 

diff --git a/src/alignment/mod.rs b/src/alignment/mod.rs
@@ -55,11 +55,7 @@ impl Alignment {
              op == AlignmentOperation::Ins) as usize
         };
 
-        let clip_str = if hard_clip {
-            "H"
-        } else {
-            "S"
-        };
+        let clip_str = if hard_clip { "H" } else { "S" };
 
         let mut cigar = String::new();