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