1use backend::{Backend, Module, ScalarZnx, ScalarZnxAlloc, ZnxInfos, ZnxZero};
 2use sampling::source::Source;
 3
 4use crate::dist::Distribution;
 5
 6pub struct GLWESecret<T> {
 7    pub(crate) data: ScalarZnx<T>,
 8    pub(crate) dist: Distribution,
 9}
10
11impl GLWESecret<Vec<u8>> {
12    pub fn alloc<B: Backend>(module: &Module<B>, rank: usize) -> Self {
13        Self {
14            data: module.new_scalar_znx(rank),
15            dist: Distribution::NONE,
16        }
17    }
18
19    pub fn bytes_of<B: Backend>(module: &Module<B>, rank: usize) -> usize {
20        module.bytes_of_scalar_znx(rank)
21    }
22}
23
24impl<DataSelf> GLWESecret<DataSelf> {
25    pub fn n(&self) -> usize {
26        self.data.n()
27    }
28
29    pub fn log_n(&self) -> usize {
30        self.data.log_n()
31    }
32
33    pub fn rank(&self) -> usize {
34        self.data.cols()
35    }
36}
37
38impl<S: AsMut<[u8]> + AsRef<[u8]>> GLWESecret<S> {
39    pub fn fill_ternary_prob(&mut self, prob: f64, source: &mut Source) {
40        (0..self.rank()).for_each(|i| {
41            self.data.fill_ternary_prob(i, prob, source);
42        });
43        self.dist = Distribution::TernaryProb(prob);
44    }
45
46    pub fn fill_ternary_hw(&mut self, hw: usize, source: &mut Source) {
47        (0..self.rank()).for_each(|i| {
48            self.data.fill_ternary_hw(i, hw, source);
49        });
50        self.dist = Distribution::TernaryFixed(hw);
51    }
52
53    pub fn fill_binary_prob(&mut self, prob: f64, source: &mut Source) {
54        (0..self.rank()).for_each(|i| {
55            self.data.fill_binary_prob(i, prob, source);
56        });
57        self.dist = Distribution::BinaryProb(prob);
58    }
59
60    pub fn fill_binary_hw(&mut self, hw: usize, source: &mut Source) {
61        (0..self.rank()).for_each(|i| {
62            self.data.fill_binary_hw(i, hw, source);
63        });
64        self.dist = Distribution::BinaryFixed(hw);
65    }
66
67    pub fn fill_binary_block(&mut self, block_size: usize, source: &mut Source) {
68        (0..self.rank()).for_each(|i| {
69            self.data.fill_binary_block(i, block_size, source);
70        });
71        self.dist = Distribution::BinaryBlock(block_size);
72    }
73
74    pub fn fill_zero(&mut self) {
75        self.data.zero();
76        self.dist = Distribution::ZERO;
77    }
78
79    // pub(crate) fn prep_fourier(&mut self, module: &Module<FFT64>) {
80    // (0..self.rank()).for_each(|i| {
81    // module.svp_prepare(&mut self.data_fourier, i, &self.data, i);
82    // });
83    // }
84}