speedytree 0.1.0

Canonical and RapidNJ implementations of Neighbor-joining in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

use crate::ResultBox;
use std::io::{self};
/// Distance matrix data structure
#[derive(Debug, Clone)]
pub struct DistanceMatrix {
    /// Distance matrix
    pub matrix: Vec<Vec<f64>>,
    /// Names of the taxa
    pub names: Vec<String>,
}

/// Distance matrix from a [PHYLIP](https://phylipweb.github.io/phylip/) file
impl DistanceMatrix {
    pub fn read_from_phylip<R>(mut reader: R) -> ResultBox<DistanceMatrix>
    where
        R: io::BufRead,
    {
        let mut line = String::new();
        reader.read_line(&mut line)?;
        let n = line.trim().parse::<usize>()?;
        // Read the next n lines to get the names of the sequences (first word), and parse the vector
        let mut names = Vec::with_capacity(n);
        let mut matrix = Vec::with_capacity(n);
        for _ in 0..n {
            line.clear();
            reader.read_line(&mut line)?;
            let mut words = line.split_whitespace();
            names.push(words.next().expect("Valid Phylip format").to_string());
            matrix.push(
                words
                    .map(|s| s.parse::<f64>().expect("Valid Phylip format"))
                    .collect::<Vec<f64>>(),
            );
        }
        Ok(DistanceMatrix { matrix, names })
    }
    /// Size of the distance matrix
    pub fn size(&self) -> usize {
        self.matrix.len()
    }
    pub fn build(matrix: Vec<Vec<f64>>, names: Vec<String>) -> ResultBox<DistanceMatrix> {
        if matrix.len() != names.len() {
            return Err("Matrix and names have different lengths".into());
        }
        Ok(DistanceMatrix { matrix, names })
    }
}

// Test
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_distance_matrix_from_stdin() {
        // create test case
        let input = "4
A 0.0 5.0 9.0 9.0
B 5.0 0.0 10.0 10.0
C 9.0 10.0 0.0 8.0
D 9.0 10.0 8.0 0.0
"
        .as_bytes();
        // run function
        let distance_matrix = DistanceMatrix::read_from_phylip::<&[u8]>(input).unwrap();
        // check result
        assert_eq!(
            distance_matrix.matrix,
            vec![
                vec![0.0, 5.0, 9.0, 9.0],
                vec![5.0, 0.0, 10.0, 10.0],
                vec![9.0, 10.0, 0.0, 8.0],
                vec![9.0, 10.0, 8.0, 0.0],
            ]
        );
        assert_eq!(
            distance_matrix.names,
            vec![
                "A".to_string(),
                "B".to_string(),
                "C".to_string(),
                "D".to_string()
            ]
        );
    }
}