gbwt 0.3.0

Partial reimplementation of the GBWT.
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use super::*;

use crate::support;

use simple_sds::serialize;

//-----------------------------------------------------------------------------

#[test]
fn statistics() {
    let filename = support::get_test_data("example.gg");
    let graph: Graph = serialize::load_from(&filename).unwrap();

    assert_eq!(graph.nodes(), 12, "Invalid number of nodes");
    assert!(!graph.is_empty(), "The graph should not be empty");
    assert_eq!(graph.sequences(), 15, "Invalid number of sequences");
    assert_eq!(graph.segments(), 0, "The graph should not contain segments");
}

#[test]
fn sequences() {
    let filename = support::get_test_data("example.gg");
    let graph: Graph = serialize::load_from(&filename).unwrap();
    let truth: Vec<&str> = vec!["G", "A", "T", "T", "A", "C", "A", "", "", "", "G", "A", "T", "T", "A"];

    for i in 0..graph.sequences() {
        assert_eq!(graph.sequence(i), truth[i].as_bytes(), "Invalid sequence {}", i);
        assert_eq!(graph.sequence_len(i), truth[i].len(), "Invalid sequence length {}", i);
    }

    assert_eq!(graph.iter().len(), graph.sequences(), "Invalid number of sequences from an iterator");
    assert!(graph.iter().eq(truth.iter().map(|x| x.as_bytes())), "Invalid sequences from an iterator");
}

#[test]
fn serialize() {
    let filename = support::get_test_data("example.gg");
    let graph: Graph = serialize::load_from(&filename).unwrap();
    serialize::test(&graph, "graph", None, true);
}

#[test]
fn no_translation() {
    let filename = support::get_test_data("example.gg");
    let graph: Graph = serialize::load_from(&filename).unwrap();

    assert!(!graph.has_translation(), "The graph should not contain a node-to-segment translation");
    let mut iter = graph.segment_iter();
    assert_eq!(iter.next(), None, "Got a segment from an iterator");
}

//-----------------------------------------------------------------------------

#[test]
fn statistics_trans() {
    let filename = support::get_test_data("translation.gg");
    let graph: Graph = serialize::load_from(&filename).unwrap();

    assert_eq!(graph.nodes(), 9, "Invalid number of nodes");
    assert!(!graph.is_empty(), "The graph should not be empty");
    assert_eq!(graph.sequences(), 11, "Invalid number of sequences");
    assert_eq!(graph.segments(), 8, "Invalid number of segments");
}

#[test]
fn sequences_trans() {
    let filename = support::get_test_data("translation.gg");
    let graph: Graph = serialize::load_from(&filename).unwrap();
    let truth: Vec<&str> = vec!["GA", "T", "T", "A", "CA", "G", "", "", "A", "T", "TA"];

    for i in 0..graph.sequences() {
        assert_eq!(graph.sequence(i), truth[i].as_bytes(), "Invalid sequence {}", i);
        assert_eq!(graph.sequence_len(i), truth[i].len(), "Invalid sequence length {}", i);
    }

    assert_eq!(graph.iter().len(), graph.sequences(), "Invalid number of sequences from an iterator");
    assert!(graph.iter().eq(truth.iter().map(|x| x.as_bytes())), "Invalid sequences from an iterator");
}

#[test]
fn serialize_trans() {
    let filename = support::get_test_data("translation.gg");
    let graph: Graph = serialize::load_from(&filename).unwrap();
    serialize::test(&graph, "graph-translation", None, true);
}

#[test]
fn translation() {
    let filename = support::get_test_data("translation.gg");
    let graph: Graph = serialize::load_from(&filename).unwrap();
    let truth: Vec<Segment> = vec![
        Segment::from_fields(0, "s11".as_bytes(), 1..3, "GAT".as_bytes()),
        Segment::from_fields(1, "s12".as_bytes(), 3..4, "T".as_bytes()),
        Segment::from_fields(2, "s13".as_bytes(), 4..5, "A".as_bytes()),
        Segment::from_fields(3, "s14".as_bytes(), 5..7, "CAG".as_bytes()),
        Segment::from_fields(4, "".as_bytes(), 7..9, "".as_bytes()),
        Segment::from_fields(5, "s15".as_bytes(), 9..10, "A".as_bytes()),
        Segment::from_fields(6, "s16".as_bytes(), 10..11, "T".as_bytes()),
        Segment::from_fields(7, "s17".as_bytes(), 11..12, "TA".as_bytes()),
    ];

    assert!(graph.has_translation(), "The graph does not contain a node-to-segment translation");

    for i in 0..graph.segments() {
        assert_eq!(graph.segment(i), truth[i], "Invalid segment {}", i);
        for j in truth[i].nodes.clone() {
            assert_eq!(graph.node_to_segment(j), truth[i], "Invalid segment for node {}", j);
        }
        assert_eq!(graph.segment_name(i), truth[i].name, "Invalid name for segment {}", i);
        assert_eq!(graph.segment_nodes(i), truth[i].nodes, "Invalid node range for segment {}", i);
        assert_eq!(graph.segment_sequence(i), truth[i].sequence, "Invalid sequence for segment {}", i);
        assert_eq!(graph.segment_len(i), truth[i].sequence.len(), "Invalid sequence length for segment {}", i);
    }

    // Iterate forward.
    assert_eq!(graph.segment_iter().len(), graph.segments(), "Invalid number of segments from an iterator");
    assert!(graph.segment_iter().eq(truth.iter().cloned()), "Invalid segments from an iterator (forward)");

    // Iterate backward.
    assert!(graph.segment_iter().rev().eq(truth.iter().rev().cloned()), "Invalid segments from an iterator (backward)");
}

//-----------------------------------------------------------------------------