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