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