fast-nnt 0.2.4

Rust implementation of the SplitsTree NeighborNet algorithm.
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
87
88
89
90
91
92

use anyhow::{Context, Result};
use ndarray::Array2;

use crate::{
    data::splits_blocks::SplitsBlock, nexus::bitset_to_vec,
    phylo::phylo_splits_graph::PhyloSplitsGraph,
};

pub struct Nexus {
    pub labels: Vec<String>,
    pub distance_matrix: Array2<f64>,
    pub splits: SplitsBlock,
    pub graph: PhyloSplitsGraph,
}

impl Nexus {
    pub fn new(
        labels: Vec<String>,
        distance_matrix: Array2<f64>,
        splits: SplitsBlock,
        graph: PhyloSplitsGraph,
    ) -> Self {
        Nexus {
            labels,
            distance_matrix,
            splits,
            graph,
        }
    }

    pub fn get_labels(&self) -> &[String] {
        &self.labels
    }

    pub fn num_labels(&self) -> usize {
        self.labels.len()
    }

    pub fn distance_matrix(&self) -> &Array2<f64> {
        &self.distance_matrix
    }

    pub fn splits(&self) -> &SplitsBlock {
        &self.splits
    }

    pub fn num_splits(&self) -> usize {
        self.splits.nsplits()
    }

    pub fn graph(&self) -> &PhyloSplitsGraph {
        &self.graph
    }

    pub fn get_cycle(&self) -> Vec<usize> {
        self.graph.get_cycle()
    }

    pub fn get_splits_records(&self) -> Vec<(String, f64, f64, Vec<usize>, Vec<usize>)> {
        self.splits
            .get_splits()
            .iter()
            .map(|s| {
                (
                    s.get_label().unwrap_or("").to_string(),
                    s.get_weight(),
                    s.get_confidence(),
                    bitset_to_vec(s.get_a()),
                    bitset_to_vec(s.get_b()),
                )
            })
            .collect()
    }

    pub fn get_node_translations(&self) -> Result<Vec<(usize, String)>> {
        self.graph
            .get_node_translations(&self.labels)
            .context("Failed to get node translations")
    }

    pub fn get_node_positions(&self) -> Result<Vec<(usize, f64, f64)>> {
        self.graph
            .get_node_positions()
            .context("Failed to get node positions")
    }

    pub fn get_graph_edges(&self) -> Result<Vec<(usize, usize, usize, i32, f64)>> {
        self.graph
            .get_graph_edges()
            .context("Failed to get graph edges")
    }
}