quantized_pathfinding/utils/
quantizer.rs

1use crate::traits::FiniteFloat;
2
3#[derive(Debug, Clone, Copy)]
4pub struct Quantizer<T: FiniteFloat> {
5    a: T,                    // Lower bound of input range
6    b: T,                    // Upper bound of input range
7    pub n_levels: usize,     // ex. N=4: 0,1,2,3
8    step_size: T,
9}
10
11impl<T: FiniteFloat> Quantizer<T> {
12    pub fn with_n(a: T, b: T, n_levels: usize) -> Self {
13        let step_size = (b - a) / T::from_usize(n_levels - 1);
14        Quantizer { a, b, n_levels, step_size }
15    }
16
17    pub fn with_step_size(a: T, b: T, step_size: T) -> Self {
18        let n_levels = ((b - a) / step_size + T::from_usize(1)).to_usize();
19        Quantizer { a, b, n_levels, step_size }
20    }
21
22    pub fn quantize(&self, x: T) -> usize {
23        ((x - self.a) / self.step_size).round().to_usize()
24    }
25
26    pub fn dequantize(&self, n: usize) -> T {
27        self.a + T::from_usize(n) * self.step_size
28    }
29}
30
31// for convenience
32pub type QuantizerF32 = Quantizer<f32>;
33pub type QuantizerF64 = Quantizer<f64>;