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