1use crate::{
2 api::{
3 ScalarZnxAutomorphismAssignBackend, ScalarZnxAutomorphismAssignTmpBytes, ScalarZnxAutomorphismBackend,
4 ScalarZnxFillBinaryBlockBackend, ScalarZnxFillBinaryBlockSourceBackend, ScalarZnxFillBinaryHwBackend,
5 ScalarZnxFillBinaryHwSourceBackend, ScalarZnxFillBinaryProbBackend, ScalarZnxFillBinaryProbSourceBackend,
6 ScalarZnxFillTernaryHwBackend, ScalarZnxFillTernaryHwSourceBackend, ScalarZnxFillTernaryProbBackend,
7 ScalarZnxFillTernaryProbSourceBackend, VecZnxAddAssignBackend, VecZnxAddConstAssignBackend, VecZnxAddConstIntoBackend,
8 VecZnxAddIntoBackend, VecZnxAddNormalBackend, VecZnxAddNormalSourceBackend, VecZnxAddScalarAssignBackend,
9 VecZnxAddScalarIntoBackend, VecZnxAutomorphismAssignBackend, VecZnxAutomorphismAssignTmpBytes, VecZnxAutomorphismBackend,
10 VecZnxAutomorphismRotateBackend, VecZnxCopyBackend, VecZnxCopyRangeBackend, VecZnxExtractCoeffBackend,
11 VecZnxFillNormalBackend, VecZnxFillNormalSourceBackend, VecZnxFillUniformBackend, VecZnxFillUniformSourceBackend,
12 VecZnxHadamardProductScalarZnxBackend, VecZnxLshAddCoeffIntoBackend, VecZnxLshAddCoeffToCoeffBackend,
13 VecZnxLshAddIntoBackend, VecZnxLshAssignBackend, VecZnxLshBackend, VecZnxLshCoeffBackend, VecZnxLshSubBackend,
14 VecZnxLshSubCoeffToCoeffBackend, VecZnxLshTmpBytes, VecZnxMergeRingsBackend, VecZnxMergeRingsTmpBytes,
15 VecZnxMulXpMinusOneAssignBackend, VecZnxMulXpMinusOneAssignTmpBytes, VecZnxMulXpMinusOneBackend,
16 VecZnxNegateAssignBackend, VecZnxNegateBackend, VecZnxNormalize, VecZnxNormalizeAssignBackend,
17 VecZnxNormalizeCoeffAssignBackend, VecZnxNormalizeCoeffBackend, VecZnxNormalizeTmpBytes, VecZnxRotateAssignBackend,
18 VecZnxRotateAssignTmpBytes, VecZnxRotateBackend, VecZnxRshAddCoeffIntoBackend, VecZnxRshAddIntoBackend,
19 VecZnxRshAssignBackend, VecZnxRshBackend, VecZnxRshCoeffBackend, VecZnxRshSubBackend, VecZnxRshSubCoeffIntoBackend,
20 VecZnxRshTmpBytes, VecZnxSplitRingBackend, VecZnxSplitRingTmpBytes, VecZnxSubAssignBackend, VecZnxSubBackend,
21 VecZnxSubNegateAssignBackend, VecZnxSubScalarAssignBackend, VecZnxSubScalarBackend, VecZnxSwitchRingBackend,
22 VecZnxTransposeBackend, VecZnxZeroBackend,
23 },
24 layouts::{
25 Backend, Module, NoiseInfos, ScalarZnxBackendMut, ScalarZnxBackendRef, ScratchArena, VecZnxBackendMut, VecZnxBackendRef,
26 VecZnxBigBackendMut, scalar_znx_as_vec_znx_backend_mut_from_mut, scalar_znx_as_vec_znx_backend_ref_from_ref,
27 },
28 oep::HalVecZnxImpl,
29 source::Source,
30};
31
32macro_rules! impl_vec_znx_delegate {
33 ($trait:ty, $($body:item)+) => {
34 impl<B> $trait for Module<B>
35 where
36 B: Backend + HalVecZnxImpl<B>,
37 {
38 $($body)+
39 }
40 };
41}
42
43impl_vec_znx_delegate!(
44 VecZnxZeroBackend<B>,
45 fn vec_znx_zero_backend(&self, res: &mut VecZnxBackendMut<'_, B>, res_col: usize) {
46 B::vec_znx_zero_backend(self, res, res_col);
47 }
48);
49
50impl_vec_znx_delegate!(
51 VecZnxNormalizeTmpBytes,
52 fn vec_znx_normalize_tmp_bytes(&self) -> usize {
53 B::vec_znx_normalize_tmp_bytes_backend(self)
54 }
55);
56
57impl_vec_znx_delegate!(
58 VecZnxNormalize<B>,
59 #[allow(clippy::too_many_arguments)]
60 fn vec_znx_normalize(
61 &self,
62 res: &mut VecZnxBackendMut<'_, B>,
63 res_base2k: usize,
64 res_offset: i64,
65 res_col: usize,
66 a: &VecZnxBackendRef<'_, B>,
67 a_base2k: usize,
68 a_col: usize,
69 scratch: &mut ScratchArena<'_, B>,
70 ) {
71 B::vec_znx_normalize_backend(self, res, res_base2k, res_offset, res_col, a, a_base2k, a_col, scratch)
72 }
73);
74
75impl_vec_znx_delegate!(
76 VecZnxNormalizeAssignBackend<B>,
77 fn vec_znx_normalize_assign_backend(
78 &self,
79 base2k: usize,
80 a: &mut VecZnxBackendMut<'_, B>,
81 a_col: usize,
82 scratch: &mut ScratchArena<'_, B>,
83 ) {
84 B::vec_znx_normalize_assign_backend(self, base2k, a, a_col, scratch)
85 }
86);
87
88impl_vec_znx_delegate!(
89 VecZnxNormalizeCoeffAssignBackend<B>,
90 fn vec_znx_normalize_coeff_assign_backend(
91 &self,
92 base2k: usize,
93 a: &mut VecZnxBackendMut<'_, B>,
94 a_col: usize,
95 a_coeff: usize,
96 scratch: &mut ScratchArena<'_, B>,
97 ) {
98 B::vec_znx_normalize_coeff_assign_backend(self, base2k, a, a_col, a_coeff, scratch)
99 }
100);
101
102impl_vec_znx_delegate!(
103 VecZnxNormalizeCoeffBackend<B>,
104 #[allow(clippy::too_many_arguments)]
105 fn vec_znx_normalize_coeff_backend(
106 &self,
107 res: &mut VecZnxBackendMut<'_, B>,
108 res_base2k: usize,
109 res_offset: i64,
110 res_col: usize,
111 a: &VecZnxBackendRef<'_, B>,
112 a_base2k: usize,
113 a_col: usize,
114 a_coeff: usize,
115 scratch: &mut ScratchArena<'_, B>,
116 ) {
117 B::vec_znx_normalize_coeff_backend(
118 self, res, res_base2k, res_offset, res_col, a, a_base2k, a_col, a_coeff, scratch,
119 )
120 }
121);
122
123impl_vec_znx_delegate!(
124 VecZnxAddIntoBackend<B>,
125 fn vec_znx_add_into_backend(
126 &self,
127 res: &mut VecZnxBackendMut<'_, B>,
128 res_col: usize,
129 a: &VecZnxBackendRef<'_, B>,
130 a_col: usize,
131 b: &VecZnxBackendRef<'_, B>,
132 b_col: usize,
133 ) {
134 B::vec_znx_add_into_backend(self, res, res_col, a, a_col, b, b_col)
135 }
136);
137
138impl_vec_znx_delegate!(
139 VecZnxAddAssignBackend<B>,
140 fn vec_znx_add_assign_backend(
141 &self,
142 res: &mut VecZnxBackendMut<'_, B>,
143 res_col: usize,
144 a: &VecZnxBackendRef<'_, B>,
145 a_col: usize,
146 ) {
147 B::vec_znx_add_assign_backend(self, res, res_col, a, a_col)
148 }
149);
150
151impl_vec_znx_delegate!(
152 VecZnxCopyRangeBackend<B>,
153 fn vec_znx_copy_range_backend(
154 &self,
155 res: &mut VecZnxBackendMut<'_, B>,
156 res_col: usize,
157 res_limb: usize,
158 res_offset: usize,
159 a: &VecZnxBackendRef<'_, B>,
160 a_col: usize,
161 a_limb: usize,
162 a_offset: usize,
163 len: usize,
164 ) {
165 B::vec_znx_copy_range_backend(self, res, res_col, res_limb, res_offset, a, a_col, a_limb, a_offset, len)
166 }
167);
168
169impl_vec_znx_delegate!(
170 VecZnxExtractCoeffBackend<B>,
171 fn vec_znx_extract_coeff_backend(
172 &self,
173 res: &mut VecZnxBackendMut<'_, B>,
174 res_col: usize,
175 a: &VecZnxBackendRef<'_, B>,
176 a_col: usize,
177 a_coeff: usize,
178 ) {
179 B::vec_znx_extract_coeff_backend(self, res, res_col, a, a_col, a_coeff)
180 }
181);
182
183impl_vec_znx_delegate!(
184 VecZnxAddConstIntoBackend<B>,
185 fn vec_znx_add_const_into_backend(
186 &self,
187 res: &mut VecZnxBackendMut<'_, B>,
188 res_col: usize,
189 a: &VecZnxBackendRef<'_, B>,
190 a_col: usize,
191 cnst: &VecZnxBackendRef<'_, B>,
192 cnst_col: usize,
193 cnst_coeff: usize,
194 res_limb: usize,
195 res_coeff: usize,
196 ) {
197 B::vec_znx_add_const_into_backend(self, res, res_col, a, a_col, cnst, cnst_col, cnst_coeff, res_limb, res_coeff)
198 }
199);
200
201impl_vec_znx_delegate!(
202 VecZnxAddConstAssignBackend<B>,
203 fn vec_znx_add_const_assign_backend(
204 &self,
205 res: &mut VecZnxBackendMut<'_, B>,
206 res_col: usize,
207 cnst: &VecZnxBackendRef<'_, B>,
208 cnst_col: usize,
209 cnst_coeff: usize,
210 res_limb: usize,
211 res_coeff: usize,
212 ) {
213 B::vec_znx_add_const_assign_backend(self, res, res_col, cnst, cnst_col, cnst_coeff, res_limb, res_coeff)
214 }
215);
216
217impl_vec_znx_delegate!(
218 VecZnxHadamardProductScalarZnxBackend<B>,
219 fn vec_znx_hadamard_product_scalar_znx_backend(
220 &self,
221 res: &mut VecZnxBigBackendMut<'_, B>,
222 res_col: usize,
223 a: &VecZnxBackendRef<'_, B>,
224 a_col: usize,
225 b: &ScalarZnxBackendRef<'_, B>,
226 b_col: usize,
227 ) {
228 B::vec_znx_hadamard_product_scalar_znx_backend(self, res, res_col, a, a_col, b, b_col)
229 }
230);
231
232impl_vec_znx_delegate!(
233 VecZnxAddScalarIntoBackend<B>,
234 fn vec_znx_add_scalar_into_backend(
235 &self,
236 res: &mut VecZnxBackendMut<'_, B>,
237 res_col: usize,
238 a: &ScalarZnxBackendRef<'_, B>,
239 a_col: usize,
240 b: &VecZnxBackendRef<'_, B>,
241 b_col: usize,
242 b_limb: usize,
243 ) {
244 B::vec_znx_add_scalar_into_backend(self, res, res_col, a, a_col, b, b_col, b_limb)
245 }
246);
247
248impl_vec_znx_delegate!(
249 VecZnxAddScalarAssignBackend<B>,
250 fn vec_znx_add_scalar_assign_backend(
251 &self,
252 res: &mut VecZnxBackendMut<'_, B>,
253 res_col: usize,
254 res_limb: usize,
255 a: &ScalarZnxBackendRef<'_, B>,
256 a_col: usize,
257 ) {
258 B::vec_znx_add_scalar_assign_backend(self, res, res_col, res_limb, a, a_col)
259 }
260);
261
262impl_vec_znx_delegate!(
263 VecZnxSubBackend<B>,
264 fn vec_znx_sub_backend(
265 &self,
266 res: &mut VecZnxBackendMut<'_, B>,
267 res_col: usize,
268 a: &VecZnxBackendRef<'_, B>,
269 a_col: usize,
270 b: &VecZnxBackendRef<'_, B>,
271 b_col: usize,
272 ) {
273 B::vec_znx_sub_backend(self, res, res_col, a, a_col, b, b_col)
274 }
275);
276
277impl_vec_znx_delegate!(
278 VecZnxSubAssignBackend<B>,
279 fn vec_znx_sub_assign_backend(
280 &self,
281 res: &mut VecZnxBackendMut<'_, B>,
282 res_col: usize,
283 a: &VecZnxBackendRef<'_, B>,
284 a_col: usize,
285 ) {
286 B::vec_znx_sub_assign_backend(self, res, res_col, a, a_col)
287 }
288);
289
290impl_vec_znx_delegate!(
291 VecZnxSubNegateAssignBackend<B>,
292 fn vec_znx_sub_negate_assign_backend(
293 &self,
294 res: &mut VecZnxBackendMut<'_, B>,
295 res_col: usize,
296 a: &VecZnxBackendRef<'_, B>,
297 a_col: usize,
298 ) {
299 B::vec_znx_sub_negate_assign_backend(self, res, res_col, a, a_col)
300 }
301);
302
303impl_vec_znx_delegate!(
304 VecZnxSubScalarBackend<B>,
305 fn vec_znx_sub_scalar_backend(
306 &self,
307 res: &mut VecZnxBackendMut<'_, B>,
308 res_col: usize,
309 a: &ScalarZnxBackendRef<'_, B>,
310 a_col: usize,
311 b: &VecZnxBackendRef<'_, B>,
312 b_col: usize,
313 b_limb: usize,
314 ) {
315 B::vec_znx_sub_scalar_backend(self, res, res_col, a, a_col, b, b_col, b_limb)
316 }
317);
318
319impl_vec_znx_delegate!(
320 VecZnxSubScalarAssignBackend<B>,
321 fn vec_znx_sub_scalar_assign_backend(
322 &self,
323 res: &mut VecZnxBackendMut<'_, B>,
324 res_col: usize,
325 res_limb: usize,
326 a: &ScalarZnxBackendRef<'_, B>,
327 a_col: usize,
328 ) {
329 B::vec_znx_sub_scalar_assign_backend(self, res, res_col, res_limb, a, a_col)
330 }
331);
332
333impl_vec_znx_delegate!(
334 VecZnxNegateBackend<B>,
335 fn vec_znx_negate_backend(
336 &self,
337 res: &mut VecZnxBackendMut<'_, B>,
338 res_col: usize,
339 a: &VecZnxBackendRef<'_, B>,
340 a_col: usize,
341 ) {
342 B::vec_znx_negate_backend(self, res, res_col, a, a_col)
343 }
344);
345
346impl_vec_znx_delegate!(
347 VecZnxNegateAssignBackend<B>,
348 fn vec_znx_negate_assign_backend(&self, a: &mut VecZnxBackendMut<'_, B>, a_col: usize) {
349 B::vec_znx_negate_assign_backend(self, a, a_col)
350 }
351);
352
353impl_vec_znx_delegate!(
354 VecZnxRshTmpBytes,
355 fn vec_znx_rsh_tmp_bytes(&self) -> usize {
356 B::vec_znx_rsh_tmp_bytes_backend(self)
357 }
358);
359
360impl_vec_znx_delegate!(
361 VecZnxLshTmpBytes,
362 fn vec_znx_lsh_tmp_bytes(&self) -> usize {
363 B::vec_znx_lsh_tmp_bytes_backend(self)
364 }
365);
366
367impl_vec_znx_delegate!(
368 VecZnxLshBackend<B>,
369 fn vec_znx_lsh_backend(
370 &self,
371 base2k: usize,
372 k: usize,
373 res: &mut VecZnxBackendMut<'_, B>,
374 res_col: usize,
375 a: &VecZnxBackendRef<'_, B>,
376 a_col: usize,
377 scratch: &mut ScratchArena<'_, B>,
378 ) {
379 B::vec_znx_lsh_backend(self, base2k, k, res, res_col, a, a_col, scratch)
380 }
381);
382
383impl_vec_znx_delegate!(
384 VecZnxLshCoeffBackend<B>,
385 fn vec_znx_lsh_coeff_backend(
386 &self,
387 base2k: usize,
388 k: usize,
389 res: &mut VecZnxBackendMut<'_, B>,
390 res_col: usize,
391 a: &VecZnxBackendRef<'_, B>,
392 a_col: usize,
393 a_coeff: usize,
394 scratch: &mut ScratchArena<'_, B>,
395 ) {
396 B::vec_znx_lsh_coeff_backend(self, base2k, k, res, res_col, a, a_col, a_coeff, scratch)
397 }
398);
399
400impl_vec_znx_delegate!(
401 VecZnxLshAddIntoBackend<B>,
402 fn vec_znx_lsh_add_into_backend(
403 &self,
404 base2k: usize,
405 k: usize,
406 res: &mut VecZnxBackendMut<'_, B>,
407 res_col: usize,
408 a: &VecZnxBackendRef<'_, B>,
409 a_col: usize,
410 scratch: &mut ScratchArena<'_, B>,
411 ) {
412 B::vec_znx_lsh_add_into_backend(self, base2k, k, res, res_col, a, a_col, scratch)
413 }
414);
415
416impl_vec_znx_delegate!(
417 VecZnxLshAddCoeffIntoBackend<B>,
418 fn vec_znx_lsh_add_coeff_into_backend(
419 &self,
420 base2k: usize,
421 k: usize,
422 res: &mut VecZnxBackendMut<'_, B>,
423 res_col: usize,
424 a: &VecZnxBackendRef<'_, B>,
425 a_col: usize,
426 a_coeff: usize,
427 scratch: &mut ScratchArena<'_, B>,
428 ) {
429 B::vec_znx_lsh_add_coeff_into_backend(self, base2k, k, res, res_col, a, a_col, a_coeff, scratch)
430 }
431);
432
433impl_vec_znx_delegate!(
434 VecZnxLshAddCoeffToCoeffBackend<B>,
435 fn vec_znx_lsh_add_coeff_to_coeff_backend(
436 &self,
437 base2k: usize,
438 k: usize,
439 res: &mut VecZnxBackendMut<'_, B>,
440 res_col: usize,
441 a: &VecZnxBackendRef<'_, B>,
442 a_col: usize,
443 a_coeff: usize,
444 res_coeff: usize,
445 scratch: &mut ScratchArena<'_, B>,
446 ) {
447 B::vec_znx_lsh_add_coeff_to_coeff_backend(self, base2k, k, res, res_col, a, a_col, a_coeff, res_coeff, scratch)
448 }
449);
450
451impl_vec_znx_delegate!(
452 VecZnxLshSubCoeffToCoeffBackend<B>,
453 fn vec_znx_lsh_sub_coeff_to_coeff_backend(
454 &self,
455 base2k: usize,
456 k: usize,
457 res: &mut VecZnxBackendMut<'_, B>,
458 res_col: usize,
459 a: &VecZnxBackendRef<'_, B>,
460 a_col: usize,
461 a_coeff: usize,
462 res_coeff: usize,
463 scratch: &mut ScratchArena<'_, B>,
464 ) {
465 B::vec_znx_lsh_sub_coeff_to_coeff_backend(self, base2k, k, res, res_col, a, a_col, a_coeff, res_coeff, scratch)
466 }
467);
468
469impl_vec_znx_delegate!(
470 VecZnxRshBackend<B>,
471 fn vec_znx_rsh_backend(
472 &self,
473 base2k: usize,
474 k: usize,
475 res: &mut VecZnxBackendMut<'_, B>,
476 res_col: usize,
477 a: &VecZnxBackendRef<'_, B>,
478 a_col: usize,
479 scratch: &mut ScratchArena<'_, B>,
480 ) {
481 B::vec_znx_rsh_backend(self, base2k, k, res, res_col, a, a_col, scratch)
482 }
483);
484
485impl_vec_znx_delegate!(
486 VecZnxRshCoeffBackend<B>,
487 fn vec_znx_rsh_coeff_backend(
488 &self,
489 base2k: usize,
490 k: usize,
491 res: &mut VecZnxBackendMut<'_, B>,
492 res_col: usize,
493 a: &VecZnxBackendRef<'_, B>,
494 a_col: usize,
495 a_coeff: usize,
496 scratch: &mut ScratchArena<'_, B>,
497 ) {
498 B::vec_znx_rsh_coeff_backend(self, base2k, k, res, res_col, a, a_col, a_coeff, scratch)
499 }
500);
501
502impl_vec_znx_delegate!(
503 VecZnxRshAddIntoBackend<B>,
504 fn vec_znx_rsh_add_into_backend(
505 &self,
506 base2k: usize,
507 k: usize,
508 res: &mut VecZnxBackendMut<'_, B>,
509 res_col: usize,
510 a: &VecZnxBackendRef<'_, B>,
511 a_col: usize,
512 scratch: &mut ScratchArena<'_, B>,
513 ) {
514 B::vec_znx_rsh_add_into_backend(self, base2k, k, res, res_col, a, a_col, scratch)
515 }
516);
517
518impl_vec_znx_delegate!(
519 VecZnxRshAddCoeffIntoBackend<B>,
520 fn vec_znx_rsh_add_coeff_into_backend(
521 &self,
522 base2k: usize,
523 k: usize,
524 res: &mut VecZnxBackendMut<'_, B>,
525 res_col: usize,
526 a: &VecZnxBackendRef<'_, B>,
527 a_col: usize,
528 a_coeff: usize,
529 res_coeff: usize,
530 scratch: &mut ScratchArena<'_, B>,
531 ) {
532 B::vec_znx_rsh_add_coeff_into_backend(self, base2k, k, res, res_col, a, a_col, a_coeff, res_coeff, scratch)
533 }
534);
535
536impl_vec_znx_delegate!(
537 VecZnxRshSubCoeffIntoBackend<B>,
538 fn vec_znx_rsh_sub_coeff_into_backend(
539 &self,
540 base2k: usize,
541 k: usize,
542 res: &mut VecZnxBackendMut<'_, B>,
543 res_col: usize,
544 a: &VecZnxBackendRef<'_, B>,
545 a_col: usize,
546 a_coeff: usize,
547 res_coeff: usize,
548 scratch: &mut ScratchArena<'_, B>,
549 ) {
550 B::vec_znx_rsh_sub_coeff_into_backend(self, base2k, k, res, res_col, a, a_col, a_coeff, res_coeff, scratch)
551 }
552);
553
554impl_vec_znx_delegate!(
555 VecZnxLshSubBackend<B>,
556 fn vec_znx_lsh_sub_backend(
557 &self,
558 base2k: usize,
559 k: usize,
560 res: &mut VecZnxBackendMut<'_, B>,
561 res_col: usize,
562 a: &VecZnxBackendRef<'_, B>,
563 a_col: usize,
564 scratch: &mut ScratchArena<'_, B>,
565 ) {
566 B::vec_znx_lsh_sub_backend(self, base2k, k, res, res_col, a, a_col, scratch)
567 }
568);
569
570impl_vec_znx_delegate!(
571 VecZnxRshSubBackend<B>,
572 fn vec_znx_rsh_sub_backend(
573 &self,
574 base2k: usize,
575 k: usize,
576 res: &mut VecZnxBackendMut<'_, B>,
577 res_col: usize,
578 a: &VecZnxBackendRef<'_, B>,
579 a_col: usize,
580 scratch: &mut ScratchArena<'_, B>,
581 ) {
582 B::vec_znx_rsh_sub_backend(self, base2k, k, res, res_col, a, a_col, scratch)
583 }
584);
585
586impl_vec_znx_delegate!(
587 VecZnxLshAssignBackend<B>,
588 fn vec_znx_lsh_assign_backend(
589 &self,
590 base2k: usize,
591 k: usize,
592 a: &mut VecZnxBackendMut<'_, B>,
593 a_col: usize,
594 scratch: &mut ScratchArena<'_, B>,
595 ) {
596 B::vec_znx_lsh_assign_backend(self, base2k, k, a, a_col, scratch)
597 }
598);
599
600impl_vec_znx_delegate!(
601 VecZnxRshAssignBackend<B>,
602 fn vec_znx_rsh_assign_backend(
603 &self,
604 base2k: usize,
605 k: usize,
606 a: &mut VecZnxBackendMut<'_, B>,
607 a_col: usize,
608 scratch: &mut ScratchArena<'_, B>,
609 ) {
610 B::vec_znx_rsh_assign_backend(self, base2k, k, a, a_col, scratch)
611 }
612);
613
614impl_vec_znx_delegate!(
615 VecZnxRotateBackend<B>,
616 fn vec_znx_rotate_backend(
617 &self,
618 k: i64,
619 res: &mut VecZnxBackendMut<'_, B>,
620 res_col: usize,
621 a: &VecZnxBackendRef<'_, B>,
622 a_col: usize,
623 ) {
624 B::vec_znx_rotate_backend(self, k, res, res_col, a, a_col)
625 }
626);
627
628impl_vec_znx_delegate!(
629 VecZnxRotateAssignTmpBytes,
630 fn vec_znx_rotate_assign_tmp_bytes(&self) -> usize {
631 B::vec_znx_rotate_assign_tmp_bytes_backend(self)
632 }
633);
634
635impl_vec_znx_delegate!(
636 VecZnxRotateAssignBackend<B>,
637 fn vec_znx_rotate_assign_backend(
638 &self,
639 k: i64,
640 a: &mut VecZnxBackendMut<'_, B>,
641 a_col: usize,
642 scratch: &mut ScratchArena<'_, B>,
643 ) {
644 B::vec_znx_rotate_assign_backend(self, k, a, a_col, scratch)
645 }
646);
647
648impl_vec_znx_delegate!(
649 VecZnxAutomorphismBackend<B>,
650 fn vec_znx_automorphism_backend(
651 &self,
652 k: i64,
653 res: &mut VecZnxBackendMut<'_, B>,
654 res_col: usize,
655 a: &VecZnxBackendRef<'_, B>,
656 a_col: usize,
657 ) {
658 B::vec_znx_automorphism_backend(self, k, res, res_col, a, a_col)
659 }
660);
661
662impl_vec_znx_delegate!(
663 VecZnxAutomorphismAssignTmpBytes,
664 fn vec_znx_automorphism_assign_tmp_bytes(&self) -> usize {
665 B::vec_znx_automorphism_assign_tmp_bytes_backend(self)
666 }
667);
668
669impl_vec_znx_delegate!(
670 VecZnxAutomorphismAssignBackend<B>,
671 fn vec_znx_automorphism_assign_backend(
672 &self,
673 k: i64,
674 res: &mut VecZnxBackendMut<'_, B>,
675 res_col: usize,
676 scratch: &mut ScratchArena<'_, B>,
677 ) {
678 B::vec_znx_automorphism_assign_backend(self, k, res, res_col, scratch)
679 }
680);
681
682impl_vec_znx_delegate!(
683 VecZnxAutomorphismRotateBackend<B>,
684 fn vec_znx_automorphism_rotate_backend(
685 &self,
686 p: i64,
687 k: i64,
688 res: &mut VecZnxBackendMut<'_, B>,
689 res_col: usize,
690 a: &VecZnxBackendRef<'_, B>,
691 a_col: usize,
692 ) {
693 B::vec_znx_automorphism_rotate_backend(self, p, k, res, res_col, a, a_col)
694 }
695);
696
697impl_vec_znx_delegate!(
698 ScalarZnxAutomorphismBackend<B>,
699 fn scalar_znx_automorphism_backend(
700 &self,
701 k: i64,
702 res: &mut ScalarZnxBackendMut<'_, B>,
703 res_col: usize,
704 a: &ScalarZnxBackendRef<'_, B>,
705 a_col: usize,
706 ) {
707 let mut res_vec = scalar_znx_as_vec_znx_backend_mut_from_mut::<B>(res);
708 let a_vec = scalar_znx_as_vec_znx_backend_ref_from_ref::<B>(a);
709 B::vec_znx_automorphism_backend(self, k, &mut res_vec, res_col, &a_vec, a_col)
710 }
711);
712
713impl_vec_znx_delegate!(
714 ScalarZnxAutomorphismAssignTmpBytes,
715 fn scalar_znx_automorphism_assign_tmp_bytes(&self) -> usize {
716 B::vec_znx_automorphism_assign_tmp_bytes_backend(self)
717 }
718);
719
720impl_vec_znx_delegate!(
721 ScalarZnxAutomorphismAssignBackend<B>,
722 fn scalar_znx_automorphism_assign_backend(
723 &self,
724 k: i64,
725 res: &mut ScalarZnxBackendMut<'_, B>,
726 res_col: usize,
727 scratch: &mut ScratchArena<'_, B>,
728 ) {
729 let mut res_vec = scalar_znx_as_vec_znx_backend_mut_from_mut::<B>(res);
730 B::vec_znx_automorphism_assign_backend(self, k, &mut res_vec, res_col, scratch)
731 }
732);
733
734impl_vec_znx_delegate!(
735 VecZnxMulXpMinusOneBackend<B>,
736 fn vec_znx_mul_xp_minus_one_backend(
737 &self,
738 p: i64,
739 res: &mut VecZnxBackendMut<'_, B>,
740 res_col: usize,
741 a: &VecZnxBackendRef<'_, B>,
742 a_col: usize,
743 ) {
744 B::vec_znx_mul_xp_minus_one_backend(self, p, res, res_col, a, a_col);
745 }
746);
747
748impl_vec_znx_delegate!(
749 VecZnxMulXpMinusOneAssignTmpBytes,
750 fn vec_znx_mul_xp_minus_one_assign_tmp_bytes(&self) -> usize {
751 B::vec_znx_mul_xp_minus_one_assign_tmp_bytes_backend(self)
752 }
753);
754
755impl_vec_znx_delegate!(
756 VecZnxMulXpMinusOneAssignBackend<B>,
757 fn vec_znx_mul_xp_minus_one_assign_backend(
758 &self,
759 p: i64,
760 res: &mut VecZnxBackendMut<'_, B>,
761 res_col: usize,
762 scratch: &mut ScratchArena<'_, B>,
763 ) {
764 B::vec_znx_mul_xp_minus_one_assign_backend(self, p, res, res_col, scratch)
765 }
766);
767
768impl_vec_znx_delegate!(
769 VecZnxSplitRingTmpBytes,
770 fn vec_znx_split_ring_tmp_bytes(&self) -> usize {
771 B::vec_znx_split_ring_tmp_bytes_backend(self)
772 }
773);
774
775impl_vec_znx_delegate!(
776 VecZnxSplitRingBackend<B>,
777 fn vec_znx_split_ring_backend(
778 &self,
779 res: &mut [VecZnxBackendMut<'_, B>],
780 res_col: usize,
781 a: &VecZnxBackendRef<'_, B>,
782 a_col: usize,
783 scratch: &mut ScratchArena<'_, B>,
784 ) {
785 B::vec_znx_split_ring_backend(self, res, res_col, a, a_col, scratch)
786 }
787);
788
789impl_vec_znx_delegate!(
790 VecZnxMergeRingsTmpBytes,
791 fn vec_znx_merge_rings_tmp_bytes(&self) -> usize {
792 B::vec_znx_merge_rings_tmp_bytes_backend(self)
793 }
794);
795
796impl_vec_znx_delegate!(
797 VecZnxMergeRingsBackend<B>,
798 fn vec_znx_merge_rings_backend(
799 &self,
800 res: &mut VecZnxBackendMut<'_, B>,
801 res_col: usize,
802 a: &[VecZnxBackendRef<'_, B>],
803 a_col: usize,
804 scratch: &mut ScratchArena<'_, B>,
805 ) {
806 B::vec_znx_merge_rings_backend(self, res, res_col, a, a_col, scratch)
807 }
808);
809
810impl_vec_znx_delegate!(
811 VecZnxSwitchRingBackend<B>,
812 fn vec_znx_switch_ring_backend(
813 &self,
814 res: &mut VecZnxBackendMut<'_, B>,
815 res_col: usize,
816 a: &VecZnxBackendRef<'_, B>,
817 a_col: usize,
818 ) {
819 B::vec_znx_switch_ring_backend(self, res, res_col, a, a_col);
820 }
821);
822
823impl_vec_znx_delegate!(
824 VecZnxCopyBackend<B>,
825 fn vec_znx_copy_backend(&self, res: &mut VecZnxBackendMut<'_, B>, res_col: usize, a: &VecZnxBackendRef<'_, B>, a_col: usize) {
826 B::vec_znx_copy_backend(self, res, res_col, a, a_col);
827 }
828);
829
830impl_vec_znx_delegate!(
831 VecZnxTransposeBackend<B>,
832 fn vec_znx_transpose_backend(&self, res: &mut VecZnxBackendMut<'_, B>, a: &VecZnxBackendRef<'_, B>) {
833 B::vec_znx_transpose_backend(self, res, a);
834 }
835);
836
837impl_vec_znx_delegate!(
838 ScalarZnxFillTernaryHwSourceBackend<B>,
839 fn scalar_znx_fill_ternary_hw_source_backend(
840 &self,
841 res: &mut ScalarZnxBackendMut<'_, B>,
842 res_col: usize,
843 hw: usize,
844 source: &mut Source,
845 ) {
846 B::scalar_znx_fill_ternary_hw_backend(self, res, res_col, hw, source.new_seed());
847 }
848);
849
850impl_vec_znx_delegate!(
851 ScalarZnxFillTernaryHwBackend<B>,
852 fn scalar_znx_fill_ternary_hw_backend(
853 &self,
854 res: &mut ScalarZnxBackendMut<'_, B>,
855 res_col: usize,
856 hw: usize,
857 seed: [u8; 32],
858 ) {
859 B::scalar_znx_fill_ternary_hw_backend(self, res, res_col, hw, seed);
860 }
861);
862
863impl_vec_znx_delegate!(
864 ScalarZnxFillTernaryProbSourceBackend<B>,
865 fn scalar_znx_fill_ternary_prob_source_backend(
866 &self,
867 res: &mut ScalarZnxBackendMut<'_, B>,
868 res_col: usize,
869 prob: f64,
870 source: &mut Source,
871 ) {
872 B::scalar_znx_fill_ternary_prob_backend(self, res, res_col, prob, source.new_seed());
873 }
874);
875
876impl_vec_znx_delegate!(
877 ScalarZnxFillTernaryProbBackend<B>,
878 fn scalar_znx_fill_ternary_prob_backend(
879 &self,
880 res: &mut ScalarZnxBackendMut<'_, B>,
881 res_col: usize,
882 prob: f64,
883 seed: [u8; 32],
884 ) {
885 B::scalar_znx_fill_ternary_prob_backend(self, res, res_col, prob, seed);
886 }
887);
888
889impl_vec_znx_delegate!(
890 ScalarZnxFillBinaryHwSourceBackend<B>,
891 fn scalar_znx_fill_binary_hw_source_backend(
892 &self,
893 res: &mut ScalarZnxBackendMut<'_, B>,
894 res_col: usize,
895 hw: usize,
896 source: &mut Source,
897 ) {
898 B::scalar_znx_fill_binary_hw_backend(self, res, res_col, hw, source.new_seed());
899 }
900);
901
902impl_vec_znx_delegate!(
903 ScalarZnxFillBinaryHwBackend<B>,
904 fn scalar_znx_fill_binary_hw_backend(&self, res: &mut ScalarZnxBackendMut<'_, B>, res_col: usize, hw: usize, seed: [u8; 32]) {
905 B::scalar_znx_fill_binary_hw_backend(self, res, res_col, hw, seed);
906 }
907);
908
909impl_vec_znx_delegate!(
910 ScalarZnxFillBinaryProbSourceBackend<B>,
911 fn scalar_znx_fill_binary_prob_source_backend(
912 &self,
913 res: &mut ScalarZnxBackendMut<'_, B>,
914 res_col: usize,
915 prob: f64,
916 source: &mut Source,
917 ) {
918 B::scalar_znx_fill_binary_prob_backend(self, res, res_col, prob, source.new_seed());
919 }
920);
921
922impl_vec_znx_delegate!(
923 ScalarZnxFillBinaryProbBackend<B>,
924 fn scalar_znx_fill_binary_prob_backend(
925 &self,
926 res: &mut ScalarZnxBackendMut<'_, B>,
927 res_col: usize,
928 prob: f64,
929 seed: [u8; 32],
930 ) {
931 B::scalar_znx_fill_binary_prob_backend(self, res, res_col, prob, seed);
932 }
933);
934
935impl_vec_znx_delegate!(
936 ScalarZnxFillBinaryBlockSourceBackend<B>,
937 fn scalar_znx_fill_binary_block_source_backend(
938 &self,
939 res: &mut ScalarZnxBackendMut<'_, B>,
940 res_col: usize,
941 block_size: usize,
942 source: &mut Source,
943 ) {
944 B::scalar_znx_fill_binary_block_backend(self, res, res_col, block_size, source.new_seed());
945 }
946);
947
948impl_vec_znx_delegate!(
949 ScalarZnxFillBinaryBlockBackend<B>,
950 fn scalar_znx_fill_binary_block_backend(
951 &self,
952 res: &mut ScalarZnxBackendMut<'_, B>,
953 res_col: usize,
954 block_size: usize,
955 seed: [u8; 32],
956 ) {
957 B::scalar_znx_fill_binary_block_backend(self, res, res_col, block_size, seed);
958 }
959);
960
961impl_vec_znx_delegate!(
962 VecZnxFillUniformSourceBackend<B>,
963 fn vec_znx_fill_uniform_source_backend(
964 &self,
965 base2k: usize,
966 res: &mut VecZnxBackendMut<'_, B>,
967 res_col: usize,
968 source: &mut Source,
969 ) {
970 B::vec_znx_fill_uniform_backend(self, base2k, res, res_col, source.new_seed());
971 }
972);
973
974impl_vec_znx_delegate!(
975 VecZnxFillUniformBackend<B>,
976 fn vec_znx_fill_uniform_backend(&self, base2k: usize, res: &mut VecZnxBackendMut<'_, B>, res_col: usize, seed: [u8; 32]) {
977 B::vec_znx_fill_uniform_backend(self, base2k, res, res_col, seed);
978 }
979);
980
981impl_vec_znx_delegate!(
982 VecZnxFillNormalSourceBackend<B>,
983 fn vec_znx_fill_normal_source_backend(
984 &self,
985 base2k: usize,
986 res: &mut VecZnxBackendMut<'_, B>,
987 res_col: usize,
988 noise_infos: NoiseInfos,
989 source_xe: &mut Source,
990 ) {
991 B::vec_znx_fill_normal_backend(self, base2k, res, res_col, noise_infos, source_xe.new_seed());
992 }
993);
994
995impl_vec_znx_delegate!(
996 VecZnxFillNormalBackend<B>,
997 fn vec_znx_fill_normal_backend(
998 &self,
999 base2k: usize,
1000 res: &mut VecZnxBackendMut<'_, B>,
1001 res_col: usize,
1002 noise_infos: NoiseInfos,
1003 seed: [u8; 32],
1004 ) {
1005 B::vec_znx_fill_normal_backend(self, base2k, res, res_col, noise_infos, seed);
1006 }
1007);
1008
1009impl_vec_znx_delegate!(
1010 VecZnxAddNormalSourceBackend<B>,
1011 fn vec_znx_add_normal_source_backend(
1012 &self,
1013 base2k: usize,
1014 res: &mut VecZnxBackendMut<'_, B>,
1015 res_col: usize,
1016 noise_infos: NoiseInfos,
1017 source_xe: &mut Source,
1018 ) {
1019 B::vec_znx_add_normal_backend(self, base2k, res, res_col, noise_infos, source_xe.new_seed());
1020 }
1021);
1022
1023impl_vec_znx_delegate!(
1024 VecZnxAddNormalBackend<B>,
1025 fn vec_znx_add_normal_backend(
1026 &self,
1027 base2k: usize,
1028 res: &mut VecZnxBackendMut<'_, B>,
1029 res_col: usize,
1030 noise_infos: NoiseInfos,
1031 seed: [u8; 32],
1032 ) {
1033 B::vec_znx_add_normal_backend(self, base2k, res, res_col, noise_infos, seed);
1034 }
1035);