poulpy-hal 0.5.0

A crate providing layouts and a trait-based hardware acceleration layer with open extension points, matching the API and types of spqlios-arithmetic.
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

use dashu_float::{FBig, round::mode::HalfEven};

use crate::layouts::{Backend, DataRef, VecZnx, VecZnxBig, VecZnxBigToRef, ZnxInfos};

/// Summary statistics (max absolute value and standard deviation) of a
/// polynomial vector's decoded floating-point coefficients.
pub struct Stats {
    max: f64,
    std: f64,
}

impl Stats {
    /// Returns the maximum absolute coefficient value.
    pub fn max(&self) -> f64 {
        self.max
    }

    /// Returns the standard deviation of the coefficients.
    pub fn std(&self) -> f64 {
        self.std
    }
}

impl<D: DataRef> VecZnx<D> {
    /// Computes [`Stats`] (max absolute value and standard deviation) for
    /// column `col` by decoding all limbs into arbitrary-precision floats.
    pub fn stats(&self, base2k: usize, col: usize) -> Stats {
        let mut data: Vec<FBig<HalfEven>> = (0..self.n()).map(|_| FBig::ZERO).collect();
        self.decode_vec_float(base2k, col, &mut data);

        // std = sqrt(sum((xi - avg)^2) / n)
        let mut avg: FBig<HalfEven> = FBig::ZERO;
        let mut max: FBig<HalfEven> = FBig::ZERO;

        data.iter().for_each(|x| {
            avg = avg.clone() + x.clone();
            let abs_x = if x < &FBig::<HalfEven>::ZERO { -x.clone() } else { x.clone() };
            if abs_x > max {
                max = abs_x;
            }
        });
        avg /= FBig::from(data.len() as i64);
        data.iter_mut().for_each(|x| {
            *x = x.clone() - avg.clone();
        });
        let mut variance: FBig<HalfEven> = FBig::ZERO;
        data.iter().for_each(|x| {
            variance = variance.clone() + x.clone() * x.clone();
        });
        variance /= FBig::from(data.len() as i64);

        // Final output is f64; to_f64() always succeeds (returns nearest f64).
        // f64::try_from(FBig) fails with LossOfPrecision for nearly all values.
        Stats {
            std: variance.to_f64().value().sqrt(),
            max: max.to_f64().value(),
        }
    }
}

impl<D: DataRef, B: Backend + Backend<ScalarBig = i64>> VecZnxBig<D, B> {
    pub fn stats(&self, base2k: usize, col: usize) -> Stats {
        let self_ref: VecZnxBig<&[u8], B> = self.to_ref();
        let znx: VecZnx<&[u8]> = VecZnx {
            data: self_ref.data,
            n: self_ref.n,
            cols: self_ref.cols,
            size: self_ref.size,
            max_size: self_ref.max_size,
        };
        znx.stats(base2k, col)
    }
}