fountaincode 0.0.8

Implementation of the Luby Transform Code 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
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

extern crate rand;
extern crate fountaincode;

use self::fountaincode::ltcode::{Encoder, EncoderType, Decoder};
use self::fountaincode::ltcode::CatchResult::*;

use rand::{thread_rng, Rng};


fn encode_decode_random(total_len: usize, chunk_len: usize) {
    let s:String = thread_rng().gen_ascii_chars().take(total_len).collect();
    let buf = s.into_bytes();
    let len = buf.len();
    let to_compare = buf.clone();

    let enc = Encoder::new(buf, chunk_len, EncoderType::Random);
    let mut dec = Decoder::new(len, chunk_len);

    for drop in enc {
        match dec.catch(drop) {
            Missing(stats) => {
                println!("Missing blocks {:?}", stats);
            }
            Finished(data, stats) => {
                assert_eq!(to_compare.len(), data.len());
                for i in 0..len {
                    println!("stats: {:?}", stats);
                    assert_eq!(to_compare[i], data[i]);
                }
                println!("Finished, stas: {:?}", stats);
                return
            }
        }
    }
}

fn encode_decode_systematic(total_len: usize, chunk_len: usize) {
    let s:String = thread_rng().gen_ascii_chars().take(total_len).collect();
    let buf = s.into_bytes();
    let len = buf.len();
    let to_compare = buf.clone();

    let enc = Encoder::new(buf, chunk_len, EncoderType::Systematic);
    let mut dec = Decoder::new(len, chunk_len);

    let mut cnt_drops = 0;

    for drop in enc {
        cnt_drops += 1;
        match dec.catch(drop) {
            Missing(stats) => {
                //a systematic encoder and no loss on channel should only need k symbols
                assert_eq!(stats.cnt_chunks-stats.unknown_chunks, cnt_drops)
            }
            Finished(data, stats) => {
                assert_eq!(to_compare.len(), data.len());
                assert_eq!(stats.cnt_chunks, cnt_drops);
                for i in 0..len {
                    assert_eq!(to_compare[i], data[i]);
                }
                return
            }
        }
    }
}

fn encode_decode_systematic_with_loss(total_len: usize, chunk_len: usize, loss: f32) {
    let s:String = thread_rng().gen_ascii_chars().take(total_len).collect();
    let buf = s.into_bytes();
    let len = buf.len();
    let to_compare = buf.clone();

    let enc = Encoder::new(buf, chunk_len, EncoderType::Systematic);
    let mut dec = Decoder::new(len, chunk_len);

    let mut loss_rng = thread_rng();

    for drop in enc {
        if loss_rng.next_f32() > loss {
            match dec.catch(drop) {
                Missing(_) => {
                    //a systematic encoder and no loss on channel should only need k symbols
                    //assert_eq!(stats.cnt_chunks-stats.unknown_chunks, cnt_drops)
                }
                Finished(data, _) => {
                    assert_eq!(to_compare.len(), data.len());
                    for i in 0..len {
                        assert_eq!(to_compare[i], data[i]);
                    }
                    return
                }
            }
        }
    }
}



#[test]
fn test_encode_decode_simple() {
    encode_decode_random(1_024, 512);
}

#[test]
fn encode_decode_with_uneven_sizes_random() {
    for size in 1000..1100 {
        for chunk in 100..130 {
            encode_decode_random(size, chunk);
        }
    }
}

#[test]
fn small_test_systematic_encoder() {
    encode_decode_systematic(1300, 128);
}

#[test]
fn combinations_encode_decode_with_uneven_sizes_systematic() {
    for size in 1000..1100 {
        for chunk in 100..130 {
            encode_decode_systematic(size, chunk);
        }
    }
}

#[test]
fn small_encode_decode_with_loss_begin_with_systematic() {
    encode_decode_systematic_with_loss(8, 2, 0.1);
}

#[test]
fn combinations_encode_decode_with_loss_begin_with_systematic() {
    for size in 1000..1100 {
        for chunk in 100..130 {
            for loss in vec![0.1, 0.3, 0.5, 0.9] {
                 encode_decode_systematic_with_loss(size, chunk, loss);
            }
        }
    }
}