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