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