poulpy/base2k/src/vec_znx_big.rs
base2k/src/vec_znx_big.rsRaw
1use crate::ffi::vec_znx_big;
2use crate::ffi::vec_znx_dft;
3use crate::{Infos, Module, VecZnxApi, 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
26pub trait VecZnxBigOps {
27 /// Allocates a vector Z[X]/(X^N+1) that stores not normalized values.
28 fn new_vec_znx_big(&self, limbs: usize) -> VecZnxBig;
29
30 /// Returns a new [VecZnxBig] with the provided bytes array as backing array.
31 ///
32 /// # Arguments
33 ///
34 /// * `limbs`: the number of limbs of the [VecZnxBig].
35 /// * `bytes`: a byte array of size at least [Module::bytes_of_vec_znx_big].
36 ///
37 /// # Panics
38 /// If `bytes.len()` < [Module::bytes_of_vec_znx_big].
39 fn new_vec_znx_big_from_bytes(&self, limbs: usize, bytes: &mut [u8]) -> VecZnxBig;
40
41 /// Returns the minimum number of bytes necessary to allocate
42 /// a new [VecZnxBig] through [VecZnxBig::from_bytes].
43 fn bytes_of_vec_znx_big(&self, limbs: usize) -> usize;
44
45 /// b <- b - a
46 fn vec_znx_big_sub_small_a_inplace<T: VecZnxApi + Infos>(&self, b: &mut VecZnxBig, a: &T);
47
48 /// c <- b - a
49 fn vec_znx_big_sub_small_a<T: VecZnxApi + Infos>(
50 &self,
51 c: &mut VecZnxBig,
52 a: &T,
53 b: &VecZnxBig,
54 );
55
56 /// c <- b + a
57 fn vec_znx_big_add_small<T: VecZnxApi + Infos>(&self, c: &mut VecZnxBig, a: &T, b: &VecZnxBig);
58
59 /// b <- b + a
60 fn vec_znx_big_add_small_inplace<T: VecZnxApi + Infos>(&self, b: &mut VecZnxBig, a: &T);
61
62 fn vec_znx_big_normalize_tmp_bytes(&self) -> usize;
63
64 /// b <- normalize(a)
65 fn vec_znx_big_normalize<T: VecZnxApi + Infos>(
66 &self,
67 log_base2k: usize,
68 b: &mut T,
69 a: &VecZnxBig,
70 tmp_bytes: &mut [u8],
71 );
72
73 fn vec_znx_big_range_normalize_base2k_tmp_bytes(&self) -> usize;
74
75 fn vec_znx_big_range_normalize_base2k<T: VecZnxApi + Infos>(
76 &self,
77 log_base2k: usize,
78 res: &mut T,
79 a: &VecZnxBig,
80 a_range_begin: usize,
81 a_range_xend: usize,
82 a_range_step: usize,
83 tmp_bytes: &mut [u8],
84 );
85
86 fn vec_znx_big_automorphism(&self, gal_el: i64, b: &mut VecZnxBig, a: &VecZnxBig);
87
88 fn vec_znx_big_automorphism_inplace(&self, gal_el: i64, a: &mut VecZnxBig);
89}
90
91impl VecZnxBigOps for Module {
92 fn new_vec_znx_big(&self, limbs: usize) -> VecZnxBig {
93 unsafe { VecZnxBig(vec_znx_big::new_vec_znx_big(self.0, limbs as u64), limbs) }
94 }
95
96 fn new_vec_znx_big_from_bytes(&self, limbs: usize, bytes: &mut [u8]) -> VecZnxBig {
97 assert!(
98 bytes.len() >= <Module as VecZnxBigOps>::bytes_of_vec_znx_big(self, limbs),
99 "invalid bytes: bytes.len()={} < bytes_of_vec_znx_dft={}",
100 bytes.len(),
101 <Module as VecZnxBigOps>::bytes_of_vec_znx_big(self, limbs)
102 );
103 VecZnxBig::from_bytes(limbs, bytes)
104 }
105
106 fn bytes_of_vec_znx_big(&self, limbs: usize) -> usize {
107 unsafe { vec_znx_big::bytes_of_vec_znx_big(self.0, limbs as u64) as usize }
108 }
109
110 fn vec_znx_big_sub_small_a_inplace<T: VecZnxApi + Infos>(&self, b: &mut VecZnxBig, a: &T) {
111 unsafe {
112 vec_znx_big::vec_znx_big_sub_small_a(
113 self.0,
114 b.0,
115 b.limbs() as u64,
116 a.as_ptr(),
117 a.limbs() as u64,
118 a.n() as u64,
119 b.0,
120 b.limbs() as u64,
121 )
122 }
123 }
124
125 fn vec_znx_big_sub_small_a<T: VecZnxApi + Infos>(
126 &self,
127 c: &mut VecZnxBig,
128 a: &T,
129 b: &VecZnxBig,
130 ) {
131 unsafe {
132 vec_znx_big::vec_znx_big_sub_small_a(
133 self.0,
134 c.0,
135 c.limbs() as u64,
136 a.as_ptr(),
137 a.limbs() as u64,
138 a.n() as u64,
139 b.0,
140 b.limbs() as u64,
141 )
142 }
143 }
144
145 fn vec_znx_big_add_small<T: VecZnxApi + Infos>(&self, c: &mut VecZnxBig, a: &T, b: &VecZnxBig) {
146 unsafe {
147 vec_znx_big::vec_znx_big_add_small(
148 self.0,
149 c.0,
150 c.limbs() as u64,
151 b.0,
152 b.limbs() as u64,
153 a.as_ptr(),
154 a.limbs() as u64,
155 a.n() as u64,
156 )
157 }
158 }
159
160 fn vec_znx_big_add_small_inplace<T: VecZnxApi + Infos>(&self, b: &mut VecZnxBig, a: &T) {
161 unsafe {
162 vec_znx_big::vec_znx_big_add_small(
163 self.0,
164 b.0,
165 b.limbs() as u64,
166 b.0,
167 b.limbs() as u64,
168 a.as_ptr(),
169 a.limbs() as u64,
170 a.n() as u64,
171 )
172 }
173 }
174
175 fn vec_znx_big_normalize_tmp_bytes(&self) -> usize {
176 unsafe { vec_znx_big::vec_znx_big_normalize_base2k_tmp_bytes(self.0) as usize }
177 }
178
179 fn vec_znx_big_normalize<T: VecZnxApi + Infos>(
180 &self,
181 log_base2k: usize,
182 b: &mut T,
183 a: &VecZnxBig,
184 tmp_bytes: &mut [u8],
185 ) {
186 assert!(
187 tmp_bytes.len() >= <Module as VecZnxBigOps>::vec_znx_big_normalize_tmp_bytes(self),
188 "invalid tmp_bytes: tmp_bytes.len()={} <= self.vec_znx_big_normalize_tmp_bytes()={}",
189 tmp_bytes.len(),
190 <Module as VecZnxBigOps>::vec_znx_big_normalize_tmp_bytes(self)
191 );
192 unsafe {
193 vec_znx_big::vec_znx_big_normalize_base2k(
194 self.0,
195 log_base2k as u64,
196 b.as_mut_ptr(),
197 b.limbs() as u64,
198 b.n() as u64,
199 a.0,
200 a.limbs() as u64,
201 tmp_bytes.as_mut_ptr(),
202 )
203 }
204 }
205
206 fn vec_znx_big_range_normalize_base2k_tmp_bytes(&self) -> usize {
207 unsafe { vec_znx_big::vec_znx_big_range_normalize_base2k_tmp_bytes(self.0) as usize }
208 }
209
210 fn vec_znx_big_range_normalize_base2k<T: VecZnxApi + Infos>(
211 &self,
212 log_base2k: usize,
213 res: &mut T,
214 a: &VecZnxBig,
215 a_range_begin: usize,
216 a_range_xend: usize,
217 a_range_step: usize,
218 tmp_bytes: &mut [u8],
219 ) {
220 assert!(
221 tmp_bytes.len() >= <Module as VecZnxBigOps>::vec_znx_big_range_normalize_base2k_tmp_bytes(self),
222 "invalid tmp_bytes: tmp_bytes.len()={} <= self.vec_znx_big_range_normalize_base2k_tmp_bytes()={}",
223 tmp_bytes.len(),
224 <Module as VecZnxBigOps>::vec_znx_big_range_normalize_base2k_tmp_bytes(self)
225 );
226 unsafe {
227 vec_znx_big::vec_znx_big_range_normalize_base2k(
228 self.0,
229 log_base2k as u64,
230 res.as_mut_ptr(),
231 res.limbs() as u64,
232 res.n() as u64,
233 a.0,
234 a_range_begin as u64,
235 a_range_xend as u64,
236 a_range_step as u64,
237 tmp_bytes.as_mut_ptr(),
238 );
239 }
240 }
241
242 fn vec_znx_big_automorphism(&self, gal_el: i64, b: &mut VecZnxBig, a: &VecZnxBig) {
243 unsafe {
244 vec_znx_big::vec_znx_big_automorphism(
245 self.0,
246 gal_el,
247 b.0,
248 b.limbs() as u64,
249 a.0,
250 a.limbs() as u64,
251 );
252 }
253 }
254
255 fn vec_znx_big_automorphism_inplace(&self, gal_el: i64, a: &mut VecZnxBig) {
256 unsafe {
257 vec_znx_big::vec_znx_big_automorphism(
258 self.0,
259 gal_el,
260 a.0,
261 a.limbs() as u64,
262 a.0,
263 a.limbs() as u64,
264 );
265 }
266 }
267}