poulpy/base2k/src/vec_znx_big.rs
base2k/src/vec_znx_big.rsRaw
1use crate::ffi::vec_znx_big::{self, vec_znx_bigcoeff_t};
2use crate::{alloc_aligned, assert_alignement, Infos, Module, VecZnx, VecZnxDft, MODULETYPE};
3
4pub struct VecZnxBig {
5 pub data: Vec<u8>,
6 pub ptr: *mut u8,
7 pub n: usize,
8 pub cols: usize,
9 pub backend: MODULETYPE,
10}
11
12impl VecZnxBig {
13 /// Returns a new [VecZnxBig] with the provided data as backing array.
14 /// User must ensure that data is properly alligned and that
15 /// the size of data is at least equal to [Module::bytes_of_vec_znx_big].
16 pub fn from_bytes(module: &Module, cols: usize, bytes: &mut [u8]) -> Self {
17 #[cfg(debug_assertions)]
18 {
19 assert_alignement(bytes.as_ptr())
20 };
21 unsafe {
22 Self {
23 data: Vec::from_raw_parts(bytes.as_mut_ptr(), bytes.len(), bytes.len()),
24 ptr: bytes.as_mut_ptr(),
25 n: module.n(),
26 cols: cols,
27 backend: module.backend,
28 }
29 }
30 }
31
32 pub fn from_bytes_borrow(module: &Module, cols: usize, bytes: &mut [u8]) -> Self {
33 #[cfg(debug_assertions)]
34 {
35 assert_eq!(bytes.len(), module.bytes_of_vec_znx_big(cols));
36 assert_alignement(bytes.as_ptr());
37 }
38 Self {
39 data: Vec::new(),
40 ptr: bytes.as_mut_ptr(),
41 n: module.n(),
42 cols: cols,
43 backend: module.backend,
44 }
45 }
46
47 pub fn as_vec_znx_dft(&mut self) -> VecZnxDft {
48 VecZnxDft {
49 data: Vec::new(),
50 ptr: self.ptr,
51 n: self.n,
52 cols: self.cols,
53 backend: self.backend,
54 }
55 }
56
57 pub fn n(&self) -> usize {
58 self.n
59 }
60
61 pub fn cols(&self) -> usize {
62 self.cols
63 }
64
65 pub fn backend(&self) -> MODULETYPE {
66 self.backend
67 }
68}
69
70pub trait VecZnxBigOps {
71 /// Allocates a vector Z[X]/(X^N+1) that stores not normalized values.
72 fn new_vec_znx_big(&self, cols: usize) -> VecZnxBig;
73
74 /// Returns a new [VecZnxBig] with the provided bytes array as backing array.
75 ///
76 /// # Arguments
77 ///
78 /// * `cols`: the number of cols of the [VecZnxBig].
79 /// * `bytes`: a byte array of size at least [Module::bytes_of_vec_znx_big].
80 ///
81 /// # Panics
82 /// If `bytes.len()` < [Module::bytes_of_vec_znx_big].
83 fn new_vec_znx_big_from_bytes(&self, cols: usize, bytes: &mut [u8]) -> VecZnxBig;
84
85 /// Returns the minimum number of bytes necessary to allocate
86 /// a new [VecZnxBig] through [VecZnxBig::from_bytes].
87 fn bytes_of_vec_znx_big(&self, cols: usize) -> usize;
88
89 /// b <- b - a
90 fn vec_znx_big_sub_small_a_inplace(&self, b: &mut VecZnxBig, a: &VecZnx);
91
92 /// c <- b - a
93 fn vec_znx_big_sub_small_a(&self, c: &mut VecZnxBig, a: &VecZnx, b: &VecZnxBig);
94
95 /// c <- b + a
96 fn vec_znx_big_add_small(&self, c: &mut VecZnxBig, a: &VecZnx, b: &VecZnxBig);
97
98 /// b <- b + a
99 fn vec_znx_big_add_small_inplace(&self, b: &mut VecZnxBig, a: &VecZnx);
100
101 fn vec_znx_big_normalize_tmp_bytes(&self) -> usize;
102
103 /// b <- normalize(a)
104 fn vec_znx_big_normalize(
105 &self,
106 log_base2k: usize,
107 b: &mut VecZnx,
108 a: &VecZnxBig,
109 tmp_bytes: &mut [u8],
110 );
111
112 fn vec_znx_big_range_normalize_base2k_tmp_bytes(&self) -> usize;
113
114 fn vec_znx_big_range_normalize_base2k(
115 &self,
116 log_base2k: usize,
117 res: &mut VecZnx,
118 a: &VecZnxBig,
119 a_range_begin: usize,
120 a_range_xend: usize,
121 a_range_step: usize,
122 tmp_bytes: &mut [u8],
123 );
124
125 fn vec_znx_big_automorphism(&self, gal_el: i64, b: &mut VecZnxBig, a: &VecZnxBig);
126
127 fn vec_znx_big_automorphism_inplace(&self, gal_el: i64, a: &mut VecZnxBig);
128}
129
130impl VecZnxBigOps for Module {
131 fn new_vec_znx_big(&self, cols: usize) -> VecZnxBig {
132 let mut data: Vec<u8> = alloc_aligned::<u8>(self.bytes_of_vec_znx_big(cols));
133 let ptr: *mut u8 = data.as_mut_ptr();
134 VecZnxBig {
135 data: data,
136 ptr: ptr,
137 n: self.n(),
138 cols: cols,
139 backend: self.backend(),
140 }
141 }
142
143 fn new_vec_znx_big_from_bytes(&self, cols: usize, bytes: &mut [u8]) -> VecZnxBig {
144 debug_assert!(
145 bytes.len() >= <Module as VecZnxBigOps>::bytes_of_vec_znx_big(self, cols),
146 "invalid bytes: bytes.len()={} < bytes_of_vec_znx_dft={}",
147 bytes.len(),
148 <Module as VecZnxBigOps>::bytes_of_vec_znx_big(self, cols)
149 );
150 #[cfg(debug_assertions)]
151 {
152 assert_alignement(bytes.as_ptr())
153 }
154 VecZnxBig::from_bytes(self, cols, bytes)
155 }
156
157 fn bytes_of_vec_znx_big(&self, cols: usize) -> usize {
158 unsafe { vec_znx_big::bytes_of_vec_znx_big(self.ptr, cols as u64) as usize }
159 }
160
161 fn vec_znx_big_sub_small_a_inplace(&self, b: &mut VecZnxBig, a: &VecZnx) {
162 unsafe {
163 vec_znx_big::vec_znx_big_sub_small_a(
164 self.ptr,
165 b.ptr as *mut vec_znx_bigcoeff_t,
166 b.cols() as u64,
167 a.as_ptr(),
168 a.cols() as u64,
169 a.n() as u64,
170 b.ptr as *mut vec_znx_bigcoeff_t,
171 b.cols() as u64,
172 )
173 }
174 }
175
176 fn vec_znx_big_sub_small_a(&self, c: &mut VecZnxBig, a: &VecZnx, b: &VecZnxBig) {
177 unsafe {
178 vec_znx_big::vec_znx_big_sub_small_a(
179 self.ptr,
180 c.ptr as *mut vec_znx_bigcoeff_t,
181 c.cols() as u64,
182 a.as_ptr(),
183 a.cols() as u64,
184 a.n() as u64,
185 b.ptr as *mut vec_znx_bigcoeff_t,
186 b.cols() as u64,
187 )
188 }
189 }
190
191 fn vec_znx_big_add_small(&self, c: &mut VecZnxBig, a: &VecZnx, b: &VecZnxBig) {
192 unsafe {
193 vec_znx_big::vec_znx_big_add_small(
194 self.ptr,
195 c.ptr as *mut vec_znx_bigcoeff_t,
196 c.cols() as u64,
197 b.ptr as *mut vec_znx_bigcoeff_t,
198 b.cols() as u64,
199 a.as_ptr(),
200 a.cols() as u64,
201 a.n() as u64,
202 )
203 }
204 }
205
206 fn vec_znx_big_add_small_inplace(&self, b: &mut VecZnxBig, a: &VecZnx) {
207 unsafe {
208 vec_znx_big::vec_znx_big_add_small(
209 self.ptr,
210 b.ptr as *mut vec_znx_bigcoeff_t,
211 b.cols() as u64,
212 b.ptr as *mut vec_znx_bigcoeff_t,
213 b.cols() as u64,
214 a.as_ptr(),
215 a.cols() as u64,
216 a.n() as u64,
217 )
218 }
219 }
220
221 fn vec_znx_big_normalize_tmp_bytes(&self) -> usize {
222 unsafe { vec_znx_big::vec_znx_big_normalize_base2k_tmp_bytes(self.ptr) as usize }
223 }
224
225 fn vec_znx_big_normalize(
226 &self,
227 log_base2k: usize,
228 b: &mut VecZnx,
229 a: &VecZnxBig,
230 tmp_bytes: &mut [u8],
231 ) {
232 debug_assert!(
233 tmp_bytes.len() >= <Module as VecZnxBigOps>::vec_znx_big_normalize_tmp_bytes(self),
234 "invalid tmp_bytes: tmp_bytes.len()={} <= self.vec_znx_big_normalize_tmp_bytes()={}",
235 tmp_bytes.len(),
236 <Module as VecZnxBigOps>::vec_znx_big_normalize_tmp_bytes(self)
237 );
238 #[cfg(debug_assertions)]
239 {
240 assert_alignement(tmp_bytes.as_ptr())
241 }
242 unsafe {
243 vec_znx_big::vec_znx_big_normalize_base2k(
244 self.ptr,
245 log_base2k as u64,
246 b.as_mut_ptr(),
247 b.cols() as u64,
248 b.n() as u64,
249 a.ptr as *mut vec_znx_bigcoeff_t,
250 a.cols() as u64,
251 tmp_bytes.as_mut_ptr(),
252 )
253 }
254 }
255
256 fn vec_znx_big_range_normalize_base2k_tmp_bytes(&self) -> usize {
257 unsafe { vec_znx_big::vec_znx_big_range_normalize_base2k_tmp_bytes(self.ptr) as usize }
258 }
259
260 fn vec_znx_big_range_normalize_base2k(
261 &self,
262 log_base2k: usize,
263 res: &mut VecZnx,
264 a: &VecZnxBig,
265 a_range_begin: usize,
266 a_range_xend: usize,
267 a_range_step: usize,
268 tmp_bytes: &mut [u8],
269 ) {
270 debug_assert!(
271 tmp_bytes.len() >= <Module as VecZnxBigOps>::vec_znx_big_range_normalize_base2k_tmp_bytes(self),
272 "invalid tmp_bytes: tmp_bytes.len()={} <= self.vec_znx_big_range_normalize_base2k_tmp_bytes()={}",
273 tmp_bytes.len(),
274 <Module as VecZnxBigOps>::vec_znx_big_range_normalize_base2k_tmp_bytes(self)
275 );
276 #[cfg(debug_assertions)]
277 {
278 assert_alignement(tmp_bytes.as_ptr())
279 }
280 unsafe {
281 vec_znx_big::vec_znx_big_range_normalize_base2k(
282 self.ptr,
283 log_base2k as u64,
284 res.as_mut_ptr(),
285 res.cols() as u64,
286 res.n() as u64,
287 a.ptr as *mut vec_znx_bigcoeff_t,
288 a_range_begin as u64,
289 a_range_xend as u64,
290 a_range_step as u64,
291 tmp_bytes.as_mut_ptr(),
292 );
293 }
294 }
295
296 fn vec_znx_big_automorphism(&self, gal_el: i64, b: &mut VecZnxBig, a: &VecZnxBig) {
297 unsafe {
298 vec_znx_big::vec_znx_big_automorphism(
299 self.ptr,
300 gal_el,
301 b.ptr as *mut vec_znx_bigcoeff_t,
302 b.cols() as u64,
303 a.ptr as *mut vec_znx_bigcoeff_t,
304 a.cols() as u64,
305 );
306 }
307 }
308
309 fn vec_znx_big_automorphism_inplace(&self, gal_el: i64, a: &mut VecZnxBig) {
310 unsafe {
311 vec_znx_big::vec_znx_big_automorphism(
312 self.ptr,
313 gal_el,
314 a.ptr as *mut vec_znx_bigcoeff_t,
315 a.cols() as u64,
316 a.ptr as *mut vec_znx_bigcoeff_t,
317 a.cols() as u64,
318 );
319 }
320 }
321}