1use poulpy_hal::{
  2    api::ModuleN,
  3    layouts::{Backend, DataMut, Module, Scratch, ZnxView, ZnxViewMut, ZnxZero},
  4};
  5
  6use crate::{
  7    GLWEKeyswitch, GLWERotate, ScratchTakeCore,
  8    layouts::{GGLWEInfos, GGLWEPreparedToRef, GLWE, GLWEInfos, GLWELayout, GLWEToRef, LWE, LWEInfos, LWEToMut, Rank},
  9};
 10
 11pub trait LWESampleExtract
 12where
 13    Self: ModuleN,
 14{
 15    fn lwe_sample_extract<R, A>(&self, res: &mut R, a: &A)
 16    where
 17        R: LWEToMut,
 18        A: GLWEToRef,
 19    {
 20        let res: &mut LWE<&mut [u8]> = &mut res.to_mut();
 21        let a: &GLWE<&[u8]> = &a.to_ref();
 22
 23        assert!(res.n() <= a.n());
 24        assert_eq!(a.n(), self.n() as u32);
 25        assert!(res.base2k() == a.base2k());
 26
 27        let min_size: usize = res.size().min(a.size());
 28        let n: usize = res.n().into();
 29
 30        res.data.zero();
 31        (0..min_size).for_each(|i| {
 32            let data_lwe: &mut [i64] = res.data.at_mut(0, i);
 33            data_lwe[0] = a.data.at(0, i)[0];
 34            data_lwe[1..].copy_from_slice(&a.data.at(1, i)[..n]);
 35        });
 36    }
 37}
 38
 39impl<BE: Backend> LWESampleExtract for Module<BE> where Self: ModuleN {}
 40impl<BE: Backend> LWEFromGLWE<BE> for Module<BE> where Self: GLWEKeyswitch<BE> + LWESampleExtract + GLWERotate<BE> {}
 41
 42pub trait LWEFromGLWE<BE: Backend>
 43where
 44    Self: GLWEKeyswitch<BE> + LWESampleExtract + GLWERotate<BE>,
 45{
 46    fn lwe_from_glwe_tmp_bytes<R, A, K>(&self, lwe_infos: &R, glwe_infos: &A, key_infos: &K) -> usize
 47    where
 48        R: LWEInfos,
 49        A: GLWEInfos,
 50        K: GGLWEInfos,
 51    {
 52        let res_infos: GLWELayout = GLWELayout {
 53            n: self.n().into(),
 54            base2k: lwe_infos.base2k(),
 55            k: lwe_infos.k(),
 56            rank: Rank(1),
 57        };
 58
 59        GLWE::bytes_of(self.n().into(), lwe_infos.base2k(), lwe_infos.k(), 1u32.into())
 60            + GLWE::bytes_of_from_infos(glwe_infos)
 61            + self.glwe_keyswitch_tmp_bytes(&res_infos, glwe_infos, key_infos)
 62    }
 63
 64    fn lwe_from_glwe<R, A, K>(&self, res: &mut R, a: &A, a_idx: usize, key: &K, scratch: &mut Scratch<BE>)
 65    where
 66        R: LWEToMut,
 67        A: GLWEToRef,
 68        K: GGLWEPreparedToRef<BE> + GGLWEInfos,
 69        Scratch<BE>: ScratchTakeCore<BE>,
 70    {
 71        let res: &mut LWE<&mut [u8]> = &mut res.to_mut();
 72        let a: &GLWE<&[u8]> = &a.to_ref();
 73
 74        assert_eq!(a.n(), self.n() as u32);
 75        assert_eq!(key.n(), self.n() as u32);
 76        assert!(res.n() <= self.n() as u32);
 77
 78        let glwe_layout: GLWELayout = GLWELayout {
 79            n: self.n().into(),
 80            base2k: res.base2k(),
 81            k: res.k(),
 82            rank: Rank(1),
 83        };
 84
 85        let (mut tmp_glwe_rank_1, scratch_1) = scratch.take_glwe(&glwe_layout);
 86
 87        match a_idx {
 88            0 => {
 89                self.glwe_keyswitch(&mut tmp_glwe_rank_1, a, key, scratch_1);
 90            }
 91            _ => {
 92                let (mut tmp_glwe_in, scratch_2) = scratch_1.take_glwe(a);
 93                self.glwe_rotate(-(a_idx as i64), &mut tmp_glwe_in, a);
 94                self.glwe_keyswitch(&mut tmp_glwe_rank_1, &tmp_glwe_in, key, scratch_2);
 95            }
 96        }
 97
 98        self.lwe_sample_extract(res, &tmp_glwe_rank_1);
 99    }
100}
101
102impl LWE<Vec<u8>> {
103    pub fn from_glwe_tmp_bytes<R, A, K, M, BE: Backend>(module: &M, lwe_infos: &R, glwe_infos: &A, key_infos: &K) -> usize
104    where
105        R: LWEInfos,
106        A: GLWEInfos,
107        K: GGLWEInfos,
108        M: LWEFromGLWE<BE>,
109    {
110        module.lwe_from_glwe_tmp_bytes(lwe_infos, glwe_infos, key_infos)
111    }
112}
113
114impl<D: DataMut> LWE<D> {
115    pub fn sample_extract<A, M>(&mut self, module: &M, a: &A)
116    where
117        A: GLWEToRef,
118        M: LWESampleExtract,
119    {
120        module.lwe_sample_extract(self, a);
121    }
122
123    pub fn from_glwe<A, K, M, BE: Backend>(&mut self, module: &M, a: &A, a_idx: usize, key: &K, scratch: &mut Scratch<BE>)
124    where
125        A: GLWEToRef,
126        K: GGLWEPreparedToRef<BE> + GGLWEInfos,
127        M: LWEFromGLWE<BE>,
128        Scratch<BE>: ScratchTakeCore<BE>,
129    {
130        module.lwe_from_glwe(self, a, a_idx, key, scratch);
131    }
132}