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

poulpy_hal/delegates/
vec_znx.rs
