wisard 0.0.3

WiSARD nets implementation 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

use bitvec::{order::BitOrder, store::BitStore, vec::BitVec, view::BitView};
use serde::{de::DeserializeOwned, Serialize};

use crate::encode::SampleEncoder;
use crate::sample::{Label, Sample};

/// A logarithmic thermometer encoder.
#[derive(Debug)]
pub struct Slice {
    start: u8,
    end: u8,
}

impl Slice {
    pub fn new(start: u8, end: u8) -> Self {
        Self { start, end }
    }
}

impl<L, T, O> SampleEncoder<L, T, O> for Slice
where
    L: Label,
    T: BitStore + DeserializeOwned,
    T::Mem: Serialize,
    O: BitOrder,
{
    fn encode_inplace(&self, sample: &mut Sample<L, T, O>) {
        let start = self.start as usize;
        let end = self.end as usize;
        let size = end - start;
        let out_size = (sample.len() / sample.vsize()) * size;
        let mut bits = BitVec::<T, O>::with_capacity(out_size);

        for value in sample.iter_values() {
            let mut orig_value = 0usize;
            orig_value.view_bits_mut::<O>()[..value.len()]
                .clone_from_bitslice(value);

            let slice_value = &orig_value.view_bits::<O>()[start..end];
            bits.extend_from_bitslice(slice_value);
        }

        sample.set_raw_bits(bits);
        sample.set_vsize(end - start);
    }
}

#[cfg(test)]
mod tests {
    use bitvec::prelude::*;

    use super::*;

    #[test]
    fn slice_in2_out1() {
        let mut sample = Sample::from_raw_parts(
            bitvec![
                0, 0, //
                1, 0, //
                0, 1, //
                1, 1, //
            ],
            2,
            0usize,
        );
        let sample_slice = Sample::from_raw_parts(
            bitvec![
                0, //
                0, //
                1, //
                1, //
            ],
            1,
            0usize,
        );
        Slice::new(1, 2).encode_inplace(&mut sample);
        assert_eq!(sample, sample_slice);
    }

    #[test]
    fn slice_in3_out1() {
        let mut sample = Sample::from_raw_parts(
            bitvec![
                0, 0, 0, //
                0, 1, 0, //
                0, 0, 1, //
                0, 1, 1, //
            ],
            3,
            0usize,
        );
        let sample_slice = Sample::from_raw_parts(
            bitvec![
                0, //
                1, //
                0, //
                1, //
            ],
            1,
            0usize,
        );
        Slice::new(1, 2).encode_inplace(&mut sample);
        assert_eq!(sample, sample_slice);
    }
}