adder-codec-core 0.3.5

Core library for encoding/decoding ADΔER events
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

// From https://github.com/danieleades/arithmetic-coding. Only temporary, for initial testing.
#![allow(missing_docs, unused)]
//! simple adaptive model using a fenwick tree

use arithmetic_coding_adder_dep::Model;

use super::Weights;
use crate::codec::compressed::fenwick::ValueError;

#[derive(Debug, Clone)]
pub struct FenwickModel {
    weights: Weights,
    max_denominator: u64,
    panic_on_saturation: bool,
}

#[must_use]
pub struct Builder {
    model: FenwickModel,
}

impl Builder {
    fn new(n_symbols: usize, max_denominator: u64) -> Self {
        let weights = Weights::new(n_symbols);
        let model = FenwickModel {
            weights,
            max_denominator,
            panic_on_saturation: false,
        };
        Self { model }
    }

    pub fn panic_on_saturation(mut self) -> Self {
        self.model.panic_on_saturation = true;
        self
    }

    #[must_use]
    pub fn build(self) -> FenwickModel {
        self.model
    }
}

impl FenwickModel {
    pub fn builder(n_symbols: usize, max_denominator: u64) -> Builder {
        Builder::new(n_symbols, max_denominator)
    }
}

impl Model for FenwickModel {
    type B = u64;
    type Symbol = usize;
    type ValueError = ValueError;

    fn probability(
        &self,
        symbol: Option<&Self::Symbol>,
    ) -> Result<std::ops::Range<Self::B>, Self::ValueError> {
        if let Some(s) = symbol.copied() {
            if s >= self.weights.len() {
                Err(ValueError(s))
            } else {
                Ok(self.weights.range(Some(s)))
            }
        } else {
            Ok(self.weights.range(None))
        }
    }

    fn max_denominator(&self) -> Self::B {
        self.max_denominator
    }

    fn symbol(&self, value: Self::B) -> Option<Self::Symbol> {
        self.weights.symbol(value)
    }

    fn denominator(&self) -> Self::B {
        self.weights.total()
    }

    fn update(&mut self, symbol: Option<&Self::Symbol>) {
        if self.panic_on_saturation {
            debug_assert!(
                self.denominator() < self.max_denominator,
                "hit max denominator!"
            );
        }
        if self.denominator() < self.max_denominator {
            self.weights.update(symbol.copied(), 1);
        }
    }
}