poulpy_hal/delegates/
vec_znx.rs

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

poulpy_hal/delegates/
vec_znx.rs
