1use crate::ffi::vec_znx_big;
  2use crate::ffi::vec_znx_dft;
  3use crate::{Infos, Module, VecZnx, VecZnxDft};
  4
  5pub struct VecZnxBig(pub *mut vec_znx_big::vec_znx_bigcoeff_t, pub usize);
  6
  7impl VecZnxBig {
  8    /// Casts a contiguous array of [u8] into as a [VecZnxDft].
  9    /// User must ensure that data is properly alligned and that
 10    /// the size of data is at least equal to [Module::bytes_of_vec_znx_big].
 11    pub fn from_bytes(&self, limbs: usize, data: &mut [u8]) -> VecZnxBig {
 12        VecZnxBig(
 13            data.as_mut_ptr() as *mut vec_znx_big::vec_znx_bigcoeff_t,
 14            limbs,
 15        )
 16    }
 17
 18    pub fn as_vec_znx_dft(&mut self) -> VecZnxDft {
 19        VecZnxDft(self.0 as *mut vec_znx_dft::vec_znx_dft_t, self.1)
 20    }
 21    pub fn limbs(&self) -> usize {
 22        self.1
 23    }
 24}
 25
 26impl Module {
 27    // Allocates a vector Z[X]/(X^N+1) that stores not normalized values.
 28    pub fn new_vec_znx_big(&self, limbs: usize) -> VecZnxBig {
 29        unsafe { VecZnxBig(vec_znx_big::new_vec_znx_big(self.0, limbs as u64), limbs) }
 30    }
 31
 32    pub fn bytes_of_vec_znx_big(&self, limbs: usize) -> usize {
 33        unsafe { vec_znx_big::bytes_of_vec_znx_big(self.0, limbs as u64) as usize }
 34    }
 35
 36    // b <- b - a
 37    pub fn vec_znx_big_sub_small_a_inplace(&self, b: &mut VecZnxBig, a: &VecZnx) {
 38        let limbs: usize = a.limbs();
 39        assert!(
 40            b.limbs() >= limbs,
 41            "invalid c_vector: b.limbs()={} < a.limbs()={}",
 42            b.limbs(),
 43            limbs
 44        );
 45        unsafe {
 46            vec_znx_big::vec_znx_big_sub_small_a(
 47                self.0,
 48                b.0,
 49                b.limbs() as u64,
 50                a.as_ptr(),
 51                limbs as u64,
 52                a.n() as u64,
 53                b.0,
 54                b.limbs() as u64,
 55            )
 56        }
 57    }
 58
 59    // c <- b - a
 60    pub fn vec_znx_big_sub_small_a(&self, c: &mut VecZnxBig, a: &VecZnx, b: &VecZnxBig) {
 61        let limbs: usize = a.limbs();
 62        assert!(
 63            b.limbs() >= limbs,
 64            "invalid c: b.limbs()={} < a.limbs()={}",
 65            b.limbs(),
 66            limbs
 67        );
 68        assert!(
 69            c.limbs() >= limbs,
 70            "invalid c: c.limbs()={} < a.limbs()={}",
 71            c.limbs(),
 72            limbs
 73        );
 74        unsafe {
 75            vec_znx_big::vec_znx_big_sub_small_a(
 76                self.0,
 77                c.0,
 78                c.limbs() as u64,
 79                a.as_ptr(),
 80                limbs as u64,
 81                a.n() as u64,
 82                b.0,
 83                b.limbs() as u64,
 84            )
 85        }
 86    }
 87
 88    // c <- b + a
 89    pub fn vec_znx_big_add_small(&self, c: &mut VecZnxBig, a: &VecZnx, b: &VecZnxBig) {
 90        let limbs: usize = a.limbs();
 91        assert!(
 92            b.limbs() >= limbs,
 93            "invalid c: b.limbs()={} < a.limbs()={}",
 94            b.limbs(),
 95            limbs
 96        );
 97        assert!(
 98            c.limbs() >= limbs,
 99            "invalid c: c.limbs()={} < a.limbs()={}",
100            c.limbs(),
101            limbs
102        );
103        unsafe {
104            vec_znx_big::vec_znx_big_add_small(
105                self.0,
106                c.0,
107                limbs as u64,
108                b.0,
109                limbs as u64,
110                a.as_ptr(),
111                limbs as u64,
112                a.n() as u64,
113            )
114        }
115    }
116
117    // b <- b + a
118    pub fn vec_znx_big_add_small_inplace(&self, b: &mut VecZnxBig, a: &VecZnx) {
119        let limbs: usize = a.limbs();
120        assert!(
121            b.limbs() >= limbs,
122            "invalid c_vector: b.limbs()={} < a.limbs()={}",
123            b.limbs(),
124            limbs
125        );
126        unsafe {
127            vec_znx_big::vec_znx_big_add_small(
128                self.0,
129                b.0,
130                limbs as u64,
131                b.0,
132                limbs as u64,
133                a.as_ptr(),
134                limbs as u64,
135                a.n() as u64,
136            )
137        }
138    }
139
140    pub fn vec_znx_big_normalize_tmp_bytes(&self) -> usize {
141        unsafe { vec_znx_big::vec_znx_big_normalize_base2k_tmp_bytes(self.0) as usize }
142    }
143
144    // b <- normalize(a)
145    pub fn vec_znx_big_normalize(
146        &self,
147        log_base2k: usize,
148        b: &mut VecZnx,
149        a: &VecZnxBig,
150        tmp_bytes: &mut [u8],
151    ) {
152        let limbs: usize = b.limbs();
153        assert!(
154            b.limbs() >= limbs,
155            "invalid c_vector: b.limbs()={} < a.limbs()={}",
156            b.limbs(),
157            limbs
158        );
159        assert!(
160            tmp_bytes.len() >= self.vec_znx_big_normalize_tmp_bytes(),
161            "invalid tmp_bytes: tmp_bytes.len()={} <= self.vec_znx_big_normalize_tmp_bytes()={}",
162            tmp_bytes.len(),
163            self.vec_znx_big_normalize_tmp_bytes()
164        );
165        unsafe {
166            vec_znx_big::vec_znx_big_normalize_base2k(
167                self.0,
168                log_base2k as u64,
169                b.as_mut_ptr(),
170                limbs as u64,
171                b.n() as u64,
172                a.0,
173                limbs as u64,
174                tmp_bytes.as_mut_ptr(),
175            )
176        }
177    }
178
179    pub fn vec_znx_big_automorphism(&self, gal_el: i64, b: &mut VecZnxBig, a: &VecZnxBig) {
180        unsafe {
181            vec_znx_big::vec_znx_big_automorphism(
182                self.0,
183                gal_el,
184                b.0,
185                b.limbs() as u64,
186                a.0,
187                a.limbs() as u64,
188            );
189        }
190    }
191
192    pub fn vec_znx_big_automorphism_inplace(&self, gal_el: i64, a: &mut VecZnxBig) {
193        unsafe {
194            vec_znx_big::vec_znx_big_automorphism(
195                self.0,
196                gal_el,
197                a.0,
198                a.limbs() as u64,
199                a.0,
200                a.limbs() as u64,
201            );
202        }
203    }
204}