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    /// Returns a new [VecZnxBig] with the provided data as backing array.
  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(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    /// Returns the minimum number of bytes necessary to allocate
 33    /// a new [VecZnxBig] through [VecZnxBig::from_bytes].
 34    pub fn bytes_of_vec_znx_big(&self, limbs: usize) -> usize {
 35        unsafe { vec_znx_big::bytes_of_vec_znx_big(self.0, limbs as u64) as usize }
 36    }
 37
 38    // b <- b - a
 39    pub fn vec_znx_big_sub_small_a_inplace(&self, b: &mut VecZnxBig, a: &VecZnx) {
 40        unsafe {
 41            vec_znx_big::vec_znx_big_sub_small_a(
 42                self.0,
 43                b.0,
 44                b.limbs() as u64,
 45                a.as_ptr(),
 46                a.limbs() as u64,
 47                a.n() as u64,
 48                b.0,
 49                b.limbs() as u64,
 50            )
 51        }
 52    }
 53
 54    // c <- b - a
 55    pub fn vec_znx_big_sub_small_a(&self, c: &mut VecZnxBig, a: &VecZnx, b: &VecZnxBig) {
 56        unsafe {
 57            vec_znx_big::vec_znx_big_sub_small_a(
 58                self.0,
 59                c.0,
 60                c.limbs() as u64,
 61                a.as_ptr(),
 62                a.limbs() as u64,
 63                a.n() as u64,
 64                b.0,
 65                b.limbs() as u64,
 66            )
 67        }
 68    }
 69
 70    // c <- b + a
 71    pub fn vec_znx_big_add_small(&self, c: &mut VecZnxBig, a: &VecZnx, b: &VecZnxBig) {
 72        unsafe {
 73            vec_znx_big::vec_znx_big_add_small(
 74                self.0,
 75                c.0,
 76                c.limbs() as u64,
 77                b.0,
 78                b.limbs() as u64,
 79                a.as_ptr(),
 80                a.limbs() as u64,
 81                a.n() as u64,
 82            )
 83        }
 84    }
 85
 86    // b <- b + a
 87    pub fn vec_znx_big_add_small_inplace(&self, b: &mut VecZnxBig, a: &VecZnx) {
 88        unsafe {
 89            vec_znx_big::vec_znx_big_add_small(
 90                self.0,
 91                b.0,
 92                b.limbs() as u64,
 93                b.0,
 94                b.limbs() as u64,
 95                a.as_ptr(),
 96                a.limbs() as u64,
 97                a.n() as u64,
 98            )
 99        }
100    }
101
102    pub fn vec_znx_big_normalize_tmp_bytes(&self) -> usize {
103        unsafe { vec_znx_big::vec_znx_big_normalize_base2k_tmp_bytes(self.0) as usize }
104    }
105
106    // b <- normalize(a)
107    pub fn vec_znx_big_normalize(
108        &self,
109        log_base2k: usize,
110        b: &mut VecZnx,
111        a: &VecZnxBig,
112        tmp_bytes: &mut [u8],
113    ) {
114        assert!(
115            tmp_bytes.len() >= self.vec_znx_big_normalize_tmp_bytes(),
116            "invalid tmp_bytes: tmp_bytes.len()={} <= self.vec_znx_big_normalize_tmp_bytes()={}",
117            tmp_bytes.len(),
118            self.vec_znx_big_normalize_tmp_bytes()
119        );
120        unsafe {
121            vec_znx_big::vec_znx_big_normalize_base2k(
122                self.0,
123                log_base2k as u64,
124                b.as_mut_ptr(),
125                b.limbs() as u64,
126                b.n() as u64,
127                a.0,
128                a.limbs() as u64,
129                tmp_bytes.as_mut_ptr(),
130            )
131        }
132    }
133
134    pub fn vec_znx_big_automorphism(&self, gal_el: i64, b: &mut VecZnxBig, a: &VecZnxBig) {
135        unsafe {
136            vec_znx_big::vec_znx_big_automorphism(
137                self.0,
138                gal_el,
139                b.0,
140                b.limbs() as u64,
141                a.0,
142                a.limbs() as u64,
143            );
144        }
145    }
146
147    pub fn vec_znx_big_automorphism_inplace(&self, gal_el: i64, a: &mut VecZnxBig) {
148        unsafe {
149            vec_znx_big::vec_znx_big_automorphism(
150                self.0,
151                gal_el,
152                a.0,
153                a.limbs() as u64,
154                a.0,
155                a.limbs() as u64,
156            );
157        }
158    }
159}