1use crate::ffi::vec_znx_big::{
  2    delete_vec_znx_big, new_vec_znx_big, vec_znx_big_add_small, vec_znx_big_automorphism,
  3    vec_znx_big_normalize_base2k, vec_znx_big_normalize_base2k_tmp_bytes, vec_znx_big_sub_small_a,
  4    vec_znx_bigcoeff_t,
  5};
  6use crate::ffi::vec_znx_dft::vec_znx_dft_t;
  7use crate::Free;
  8use crate::{Module, VecZnx, VecZnxDft};
  9
 10pub struct VecZnxBig(pub *mut vec_znx_bigcoeff_t, pub usize);
 11
 12impl VecZnxBig {
 13    pub fn as_vec_znx_dft(&mut self) -> VecZnxDft {
 14        VecZnxDft(self.0 as *mut vec_znx_dft_t, self.1)
 15    }
 16    pub fn limbs(&self) -> usize {
 17        self.1
 18    }
 19}
 20
 21impl Free for VecZnxBig {
 22    fn free(self) {
 23        unsafe {
 24            delete_vec_znx_big(self.0);
 25        }
 26        drop(self);
 27    }
 28}
 29
 30impl Module {
 31    // Allocates a vector Z[X]/(X^N+1) that stores not normalized values.
 32    pub fn new_vec_znx_big(&self, limbs: usize) -> VecZnxBig {
 33        unsafe { VecZnxBig(new_vec_znx_big(self.0, limbs as u64), limbs) }
 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_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_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_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_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_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_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_automorphism(self.0, gal_el, b.0, b.limbs() as u64, a.0, a.limbs() as u64);
182        }
183    }
184
185    pub fn vec_znx_big_automorphism_inplace(&self, gal_el: i64, a: &mut VecZnxBig) {
186        unsafe {
187            vec_znx_big_automorphism(self.0, gal_el, a.0, a.limbs() as u64, a.0, a.limbs() as u64);
188        }
189    }
190}