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