poulpy_hal/api/
vec_znx.rs

1use crate::{
2    layouts::{
3        Backend, NoiseInfos, ScalarZnxBackendMut, ScalarZnxBackendRef, ScratchArena, VecZnxBackendMut, VecZnxBackendRef,
4        VecZnxBigBackendMut,
5    },
6    source::Source,
7};
8
9pub trait VecZnxNormalizeTmpBytes {
10    /// Returns the minimum number of bytes necessary for normalization.
11    fn vec_znx_normalize_tmp_bytes(&self) -> usize;
12}
13
14pub trait VecZnxZeroBackend<B: Backend> {
15    fn vec_znx_zero_backend(&self, res: &mut VecZnxBackendMut<'_, B>, res_col: usize);
16}
17
18pub trait VecZnxCopyRangeBackend<B: Backend> {
19    #[allow(clippy::too_many_arguments)]
20    fn vec_znx_copy_range_backend(
21        &self,
22        res: &mut VecZnxBackendMut<'_, B>,
23        res_col: usize,
24        res_limb: usize,
25        res_offset: usize,
26        a: &VecZnxBackendRef<'_, B>,
27        a_col: usize,
28        a_limb: usize,
29        a_offset: usize,
30        len: usize,
31    );
32}
33
34pub trait VecZnxExtractCoeffBackend<B: Backend> {
35    fn vec_znx_extract_coeff_backend(
36        &self,
37        res: &mut VecZnxBackendMut<'_, B>,
38        res_col: usize,
39        a: &VecZnxBackendRef<'_, B>,
40        a_col: usize,
41        a_coeff: usize,
42    );
43}
44
45pub trait VecZnxNormalizeCoeffBackend<B: Backend> {
46    #[allow(clippy::too_many_arguments)]
47    /// Normalizes the selected coefficient of `a` across its limbs into a 1-coeff destination column.
48    fn vec_znx_normalize_coeff_backend(
49        &self,
50        res: &mut VecZnxBackendMut<'_, B>,
51        res_base2k: usize,
52        res_offset: i64,
53        res_col: usize,
54        a: &VecZnxBackendRef<'_, B>,
55        a_base2k: usize,
56        a_col: usize,
57        a_coeff: usize,
58        scratch: &mut ScratchArena<'_, B>,
59    );
60}
61
62pub trait VecZnxHadamardProductScalarZnxBackend<B: Backend> {
63    fn vec_znx_hadamard_product_scalar_znx_backend(
64        &self,
65        res: &mut VecZnxBigBackendMut<'_, B>,
66        res_col: usize,
67        a: &VecZnxBackendRef<'_, B>,
68        a_col: usize,
69        b: &ScalarZnxBackendRef<'_, B>,
70        b_col: usize,
71    );
72}
73
74pub trait VecZnxNormalize<B: Backend> {
75    #[allow(clippy::too_many_arguments)]
76    /// Normalizes the selected column of `a` and stores the result into the selected column of `res`.
77    fn vec_znx_normalize(
78        &self,
79        res: &mut VecZnxBackendMut<'_, B>,
80        res_base2k: usize,
81        res_offset: i64,
82        res_col: usize,
83        a: &VecZnxBackendRef<'_, B>,
84        a_base2k: usize,
85        a_col: usize,
86        scratch: &mut ScratchArena<'_, B>,
87    );
88}
89
90pub trait VecZnxNormalizeAssignBackend<B: Backend> {
91    fn vec_znx_normalize_assign_backend(
92        &self,
93        base2k: usize,
94        a: &mut VecZnxBackendMut<'_, B>,
95        a_col: usize,
96        scratch: &mut ScratchArena<'_, B>,
97    );
98}
99
100pub trait VecZnxNormalizeCoeffAssignBackend<B: Backend> {
101    fn vec_znx_normalize_coeff_assign_backend(
102        &self,
103        base2k: usize,
104        a: &mut VecZnxBackendMut<'_, B>,
105        a_col: usize,
106        a_coeff: usize,
107        scratch: &mut ScratchArena<'_, B>,
108    );
109}
110
111pub trait VecZnxAddIntoBackend<B: Backend> {
112    /// Adds the selected backend-native column of `a` to the selected backend-native column of `b`.
113    fn vec_znx_add_into_backend(
114        &self,
115        res: &mut VecZnxBackendMut<'_, B>,
116        res_col: usize,
117        a: &VecZnxBackendRef<'_, B>,
118        a_col: usize,
119        b: &VecZnxBackendRef<'_, B>,
120        b_col: usize,
121    );
122}
123
124pub trait VecZnxAddAssignBackend<B: Backend> {
125    fn vec_znx_add_assign_backend(
126        &self,
127        res: &mut VecZnxBackendMut<'_, B>,
128        res_col: usize,
129        a: &VecZnxBackendRef<'_, B>,
130        a_col: usize,
131    );
132}
133
134pub trait VecZnxAddConstIntoBackend<B: Backend> {
135    #[allow(clippy::too_many_arguments)]
136    fn vec_znx_add_const_into_backend(
137        &self,
138        res: &mut VecZnxBackendMut<'_, B>,
139        res_col: usize,
140        a: &VecZnxBackendRef<'_, B>,
141        a_col: usize,
142        cnst: &VecZnxBackendRef<'_, B>,
143        cnst_col: usize,
144        cnst_coeff: usize,
145        res_limb: usize,
146        res_coeff: usize,
147    );
148}
149
150pub trait VecZnxAddConstAssignBackend<B: Backend> {
151    #[allow(clippy::too_many_arguments)]
152    fn vec_znx_add_const_assign_backend(
153        &self,
154        res: &mut VecZnxBackendMut<'_, B>,
155        res_col: usize,
156        cnst: &VecZnxBackendRef<'_, B>,
157        cnst_col: usize,
158        cnst_coeff: usize,
159        res_limb: usize,
160        res_coeff: usize,
161    );
162}
163
164pub trait VecZnxAddScalarIntoBackend<B: Backend> {
165    #[allow(clippy::too_many_arguments)]
166    fn vec_znx_add_scalar_into_backend(
167        &self,
168        res: &mut VecZnxBackendMut<'_, B>,
169        res_col: usize,
170        a: &ScalarZnxBackendRef<'_, B>,
171        a_col: usize,
172        b: &VecZnxBackendRef<'_, B>,
173        b_col: usize,
174        b_limb: usize,
175    );
176}
177
178pub trait VecZnxAddScalarAssignBackend<B: Backend> {
179    fn vec_znx_add_scalar_assign_backend(
180        &self,
181        res: &mut VecZnxBackendMut<'_, B>,
182        res_col: usize,
183        res_limb: usize,
184        a: &ScalarZnxBackendRef<'_, B>,
185        a_col: usize,
186    );
187}
188
189pub trait VecZnxSubBackend<B: Backend> {
190    fn vec_znx_sub_backend(
191        &self,
192        res: &mut VecZnxBackendMut<'_, B>,
193        res_col: usize,
194        a: &VecZnxBackendRef<'_, B>,
195        a_col: usize,
196        b: &VecZnxBackendRef<'_, B>,
197        b_col: usize,
198    );
199}
200
201pub trait VecZnxSubAssignBackend<B: Backend> {
202    fn vec_znx_sub_assign_backend(
203        &self,
204        res: &mut VecZnxBackendMut<'_, B>,
205        res_col: usize,
206        a: &VecZnxBackendRef<'_, B>,
207        a_col: usize,
208    );
209}
210
211pub trait VecZnxSubNegateAssignBackend<B: Backend> {
212    fn vec_znx_sub_negate_assign_backend(
213        &self,
214        res: &mut VecZnxBackendMut<'_, B>,
215        res_col: usize,
216        a: &VecZnxBackendRef<'_, B>,
217        a_col: usize,
218    );
219}
220
221pub trait VecZnxSubScalarBackend<B: Backend> {
222    #[allow(clippy::too_many_arguments)]
223    fn vec_znx_sub_scalar_backend(
224        &self,
225        res: &mut VecZnxBackendMut<'_, B>,
226        res_col: usize,
227        a: &ScalarZnxBackendRef<'_, B>,
228        a_col: usize,
229        b: &VecZnxBackendRef<'_, B>,
230        b_col: usize,
231        b_limb: usize,
232    );
233}
234
235pub trait VecZnxSubScalarAssignBackend<B: Backend> {
236    fn vec_znx_sub_scalar_assign_backend(
237        &self,
238        res: &mut VecZnxBackendMut<'_, B>,
239        res_col: usize,
240        res_limb: usize,
241        a: &ScalarZnxBackendRef<'_, B>,
242        a_col: usize,
243    );
244}
245
246pub trait VecZnxNegateBackend<B: Backend> {
247    fn vec_znx_negate_backend(
248        &self,
249        res: &mut VecZnxBackendMut<'_, B>,
250        res_col: usize,
251        a: &VecZnxBackendRef<'_, B>,
252        a_col: usize,
253    );
254}
255
256pub trait VecZnxNegateAssignBackend<B: Backend> {
257    fn vec_znx_negate_assign_backend(&self, a: &mut VecZnxBackendMut<'_, B>, a_col: usize);
258}
259
260/// Returns scratch bytes required for left-shift operations.
261pub trait VecZnxLshTmpBytes {
262    fn vec_znx_lsh_tmp_bytes(&self) -> usize;
263}
264
265pub trait VecZnxLshBackend<B: Backend> {
266    /// Left shift by k bits all columns of `a`.
267    #[allow(clippy::too_many_arguments)]
268    fn vec_znx_lsh_backend(
269        &self,
270        base2k: usize,
271        k: usize,
272        res: &mut VecZnxBackendMut<'_, B>,
273        res_col: usize,
274        a: &VecZnxBackendRef<'_, B>,
275        a_col: usize,
276        scratch: &mut ScratchArena<'_, B>,
277    );
278}
279
280pub trait VecZnxLshCoeffBackend<B: Backend> {
281    #[allow(clippy::too_many_arguments)]
282    fn vec_znx_lsh_coeff_backend(
283        &self,
284        base2k: usize,
285        k: usize,
286        res: &mut VecZnxBackendMut<'_, B>,
287        res_col: usize,
288        a: &VecZnxBackendRef<'_, B>,
289        a_col: usize,
290        a_coeff: usize,
291        scratch: &mut ScratchArena<'_, B>,
292    );
293}
294
295pub trait VecZnxLshAddIntoBackend<B: Backend> {
296    /// Left shift by k bits all columns of `a`.
297    #[allow(clippy::too_many_arguments)]
298    fn vec_znx_lsh_add_into_backend(
299        &self,
300        base2k: usize,
301        k: usize,
302        res: &mut VecZnxBackendMut<'_, B>,
303        res_col: usize,
304        a: &VecZnxBackendRef<'_, B>,
305        a_col: usize,
306        scratch: &mut ScratchArena<'_, B>,
307    );
308}
309
310pub trait VecZnxLshAddCoeffIntoBackend<B: Backend> {
311    #[allow(clippy::too_many_arguments)]
312    fn vec_znx_lsh_add_coeff_into_backend(
313        &self,
314        base2k: usize,
315        k: usize,
316        res: &mut VecZnxBackendMut<'_, B>,
317        res_col: usize,
318        a: &VecZnxBackendRef<'_, B>,
319        a_col: usize,
320        a_coeff: usize,
321        scratch: &mut ScratchArena<'_, B>,
322    );
323}
324
325/// Returns scratch bytes required for right-shift operations.
326pub trait VecZnxRshTmpBytes {
327    fn vec_znx_rsh_tmp_bytes(&self) -> usize;
328}
329
330pub trait VecZnxRshBackend<B: Backend> {
331    /// Right shift by k bits all columns of `a`.
332    #[allow(clippy::too_many_arguments)]
333    fn vec_znx_rsh_backend(
334        &self,
335        base2k: usize,
336        k: usize,
337        res: &mut VecZnxBackendMut<'_, B>,
338        res_col: usize,
339        a: &VecZnxBackendRef<'_, B>,
340        a_col: usize,
341        scratch: &mut ScratchArena<'_, B>,
342    );
343}
344
345pub trait VecZnxRshCoeffBackend<B: Backend> {
346    #[allow(clippy::too_many_arguments)]
347    fn vec_znx_rsh_coeff_backend(
348        &self,
349        base2k: usize,
350        k: usize,
351        res: &mut VecZnxBackendMut<'_, B>,
352        res_col: usize,
353        a: &VecZnxBackendRef<'_, B>,
354        a_col: usize,
355        a_coeff: usize,
356        scratch: &mut ScratchArena<'_, B>,
357    );
358}
359
360pub trait VecZnxRshAddIntoBackend<B: Backend> {
361    /// Right shift by k bits all columns of `a`.
362    #[allow(clippy::too_many_arguments)]
363    fn vec_znx_rsh_add_into_backend(
364        &self,
365        base2k: usize,
366        k: usize,
367        res: &mut VecZnxBackendMut<'_, B>,
368        res_col: usize,
369        a: &VecZnxBackendRef<'_, B>,
370        a_col: usize,
371        scratch: &mut ScratchArena<'_, B>,
372    );
373}
374
375pub trait VecZnxRshAddCoeffIntoBackend<B: Backend> {
376    #[allow(clippy::too_many_arguments)]
377    fn vec_znx_rsh_add_coeff_into_backend(
378        &self,
379        base2k: usize,
380        k: usize,
381        res: &mut VecZnxBackendMut<'_, B>,
382        res_col: usize,
383        a: &VecZnxBackendRef<'_, B>,
384        a_col: usize,
385        a_coeff: usize,
386        res_coeff: usize,
387        scratch: &mut ScratchArena<'_, B>,
388    );
389}
390
391pub trait VecZnxRshSubCoeffIntoBackend<B: Backend> {
392    #[allow(clippy::too_many_arguments)]
393    fn vec_znx_rsh_sub_coeff_into_backend(
394        &self,
395        base2k: usize,
396        k: usize,
397        res: &mut VecZnxBackendMut<'_, B>,
398        res_col: usize,
399        a: &VecZnxBackendRef<'_, B>,
400        a_col: usize,
401        a_coeff: usize,
402        res_coeff: usize,
403        scratch: &mut ScratchArena<'_, B>,
404    );
405}
406
407pub trait VecZnxLshSubBackend<B: Backend> {
408    /// Left shift by k bits and subtract from destination.
409    #[allow(clippy::too_many_arguments)]
410    fn vec_znx_lsh_sub_backend(
411        &self,
412        base2k: usize,
413        k: usize,
414        res: &mut VecZnxBackendMut<'_, B>,
415        res_col: usize,
416        a: &VecZnxBackendRef<'_, B>,
417        a_col: usize,
418        scratch: &mut ScratchArena<'_, B>,
419    );
420}
421
422pub trait VecZnxRshSubBackend<B: Backend> {
423    /// Right shift by k bits and subtract from destination.
424    #[allow(clippy::too_many_arguments)]
425    fn vec_znx_rsh_sub_backend(
426        &self,
427        base2k: usize,
428        k: usize,
429        res: &mut VecZnxBackendMut<'_, B>,
430        res_col: usize,
431        a: &VecZnxBackendRef<'_, B>,
432        a_col: usize,
433        scratch: &mut ScratchArena<'_, B>,
434    );
435}
436
437pub trait VecZnxLshAssignBackend<B: Backend> {
438    /// Left shift by k bits all columns of `a`.
439    fn vec_znx_lsh_assign_backend(
440        &self,
441        base2k: usize,
442        k: usize,
443        a: &mut VecZnxBackendMut<'_, B>,
444        a_col: usize,
445        scratch: &mut ScratchArena<'_, B>,
446    );
447}
448
449pub trait VecZnxRshAssignBackend<B: Backend> {
450    /// Right shift by k bits all columns of `a`.
451    fn vec_znx_rsh_assign_backend(
452        &self,
453        base2k: usize,
454        k: usize,
455        a: &mut VecZnxBackendMut<'_, B>,
456        a_col: usize,
457        scratch: &mut ScratchArena<'_, B>,
458    );
459}
460
461pub trait VecZnxRotateBackend<B: Backend> {
462    /// Multiplies the selected column of `a` by X^k and stores the result in `res_col` of `res`.
463    fn vec_znx_rotate_backend(
464        &self,
465        p: i64,
466        res: &mut VecZnxBackendMut<'_, B>,
467        res_col: usize,
468        a: &VecZnxBackendRef<'_, B>,
469        a_col: usize,
470    );
471}
472
473pub trait VecZnxRotateAssignTmpBytes {
474    fn vec_znx_rotate_assign_tmp_bytes(&self) -> usize;
475}
476
477pub trait VecZnxRotateAssignBackend<B: Backend> {
478    /// Multiplies the selected column of `a` by X^k.
479    fn vec_znx_rotate_assign_backend(
480        &self,
481        p: i64,
482        a: &mut VecZnxBackendMut<'_, B>,
483        a_col: usize,
484        scratch: &mut ScratchArena<'_, B>,
485    );
486}
487
488pub trait VecZnxAutomorphismBackend<B: Backend> {
489    /// Applies the automorphism X^i -> X^ik on the selected column of `a` and stores the result in `res_col` column of `res`.
490    fn vec_znx_automorphism_backend(
491        &self,
492        k: i64,
493        res: &mut VecZnxBackendMut<'_, B>,
494        res_col: usize,
495        a: &VecZnxBackendRef<'_, B>,
496        a_col: usize,
497    );
498}
499
500pub trait VecZnxAutomorphismAssignTmpBytes {
501    fn vec_znx_automorphism_assign_tmp_bytes(&self) -> usize;
502}
503
504pub trait VecZnxAutomorphismAssignBackend<B: Backend> {
505    /// Applies the automorphism X^i -> X^ik on the selected column of `a`.
506    fn vec_znx_automorphism_assign_backend(
507        &self,
508        k: i64,
509        res: &mut VecZnxBackendMut<'_, B>,
510        res_col: usize,
511        scratch: &mut ScratchArena<'_, B>,
512    );
513}
514
515/// Multiplies the selected column by `(X^p - 1)` in `Z[X]/(X^N + 1)`.
516pub trait VecZnxMulXpMinusOneBackend<B: Backend> {
517    fn vec_znx_mul_xp_minus_one_backend(
518        &self,
519        p: i64,
520        res: &mut VecZnxBackendMut<'_, B>,
521        res_col: usize,
522        a: &VecZnxBackendRef<'_, B>,
523        a_col: usize,
524    );
525}
526
527pub trait VecZnxMulXpMinusOneAssignTmpBytes {
528    fn vec_znx_mul_xp_minus_one_assign_tmp_bytes(&self) -> usize;
529}
530
531pub trait VecZnxMulXpMinusOneAssignBackend<B: Backend> {
532    fn vec_znx_mul_xp_minus_one_assign_backend(
533        &self,
534        p: i64,
535        res: &mut VecZnxBackendMut<'_, B>,
536        res_col: usize,
537        scratch: &mut ScratchArena<'_, B>,
538    );
539}
540
541pub trait VecZnxSplitRingTmpBytes {
542    fn vec_znx_split_ring_tmp_bytes(&self) -> usize;
543}
544
545pub trait VecZnxSplitRingBackend<B: Backend> {
546    /// Splits the selected columns of `b` into subrings and copies them them into the selected column of `res`.
547    ///
548    /// # Panics
549    ///
550    /// This method requires that all [crate::layouts::VecZnx] of b have the same ring degree
551    /// and that b.n() * b.len() <= a.n()
552    fn vec_znx_split_ring_backend(
553        &self,
554        res: &mut [VecZnxBackendMut<'_, B>],
555        res_col: usize,
556        a: &VecZnxBackendRef<'_, B>,
557        a_col: usize,
558        scratch: &mut ScratchArena<'_, B>,
559    );
560}
561
562pub trait VecZnxMergeRingsTmpBytes {
563    fn vec_znx_merge_rings_tmp_bytes(&self) -> usize;
564}
565
566pub trait VecZnxMergeRingsBackend<B: Backend> {
567    /// Merges the subrings of the selected column of `a` into the selected column of `res`.
568    ///
569    /// # Panics
570    ///
571    /// This method requires that all [crate::layouts::VecZnx] of a have the same ring degree
572    /// and that a.n() * a.len() <= b.n()
573    fn vec_znx_merge_rings_backend(
574        &self,
575        res: &mut VecZnxBackendMut<'_, B>,
576        res_col: usize,
577        a: &[VecZnxBackendRef<'_, B>],
578        a_col: usize,
579        scratch: &mut ScratchArena<'_, B>,
580    );
581}
582
583/// Switches ring degree between `a` and `res` by truncation or zero-padding.
584pub trait VecZnxSwitchRingBackend<B: Backend> {
585    fn vec_znx_switch_ring_backend(
586        &self,
587        res: &mut VecZnxBackendMut<'_, B>,
588        res_col: usize,
589        a: &VecZnxBackendRef<'_, B>,
590        a_col: usize,
591    );
592}
593
594pub trait VecZnxCopyBackend<B: Backend> {
595    fn vec_znx_copy_backend(&self, res: &mut VecZnxBackendMut<'_, B>, res_col: usize, a: &VecZnxBackendRef<'_, B>, a_col: usize);
596}
597
598pub trait ScalarZnxFillTernaryHwSourceBackend<B: Backend> {
599    fn scalar_znx_fill_ternary_hw_source_backend(
600        &self,
601        res: &mut ScalarZnxBackendMut<'_, B>,
602        res_col: usize,
603        hw: usize,
604        source: &mut Source,
605    );
606}
607
608pub trait ScalarZnxFillTernaryHwBackend<B: Backend> {
609    fn scalar_znx_fill_ternary_hw_backend(&self, res: &mut ScalarZnxBackendMut<'_, B>, res_col: usize, hw: usize, seed: [u8; 32]);
610}
611
612pub trait ScalarZnxFillTernaryProbSourceBackend<B: Backend> {
613    fn scalar_znx_fill_ternary_prob_source_backend(
614        &self,
615        res: &mut ScalarZnxBackendMut<'_, B>,
616        res_col: usize,
617        prob: f64,
618        source: &mut Source,
619    );
620}
621
622pub trait ScalarZnxFillTernaryProbBackend<B: Backend> {
623    fn scalar_znx_fill_ternary_prob_backend(
624        &self,
625        res: &mut ScalarZnxBackendMut<'_, B>,
626        res_col: usize,
627        prob: f64,
628        seed: [u8; 32],
629    );
630}
631
632pub trait ScalarZnxFillBinaryHwSourceBackend<B: Backend> {
633    fn scalar_znx_fill_binary_hw_source_backend(
634        &self,
635        res: &mut ScalarZnxBackendMut<'_, B>,
636        res_col: usize,
637        hw: usize,
638        source: &mut Source,
639    );
640}
641
642pub trait ScalarZnxFillBinaryHwBackend<B: Backend> {
643    fn scalar_znx_fill_binary_hw_backend(&self, res: &mut ScalarZnxBackendMut<'_, B>, res_col: usize, hw: usize, seed: [u8; 32]);
644}
645
646pub trait ScalarZnxFillBinaryProbSourceBackend<B: Backend> {
647    fn scalar_znx_fill_binary_prob_source_backend(
648        &self,
649        res: &mut ScalarZnxBackendMut<'_, B>,
650        res_col: usize,
651        prob: f64,
652        source: &mut Source,
653    );
654}
655
656pub trait ScalarZnxFillBinaryProbBackend<B: Backend> {
657    fn scalar_znx_fill_binary_prob_backend(
658        &self,
659        res: &mut ScalarZnxBackendMut<'_, B>,
660        res_col: usize,
661        prob: f64,
662        seed: [u8; 32],
663    );
664}
665
666pub trait ScalarZnxFillBinaryBlockSourceBackend<B: Backend> {
667    fn scalar_znx_fill_binary_block_source_backend(
668        &self,
669        res: &mut ScalarZnxBackendMut<'_, B>,
670        res_col: usize,
671        block_size: usize,
672        source: &mut Source,
673    );
674}
675
676pub trait ScalarZnxFillBinaryBlockBackend<B: Backend> {
677    fn scalar_znx_fill_binary_block_backend(
678        &self,
679        res: &mut ScalarZnxBackendMut<'_, B>,
680        res_col: usize,
681        block_size: usize,
682        seed: [u8; 32],
683    );
684}
685
686pub trait VecZnxFillUniformSourceBackend<B: Backend> {
687    /// Fills the first `size` size with uniform values in \[-2^{base2k-1}, 2^{base2k-1}\]
688    fn vec_znx_fill_uniform_source_backend(
689        &self,
690        base2k: usize,
691        res: &mut VecZnxBackendMut<'_, B>,
692        res_col: usize,
693        source: &mut Source,
694    );
695}
696
697pub trait VecZnxFillUniformBackend<B: Backend> {
698    /// Fills the selected backend-native column from a backend-defined uniform sampler seeded by `seed`.
699    fn vec_znx_fill_uniform_backend(&self, base2k: usize, res: &mut VecZnxBackendMut<'_, B>, res_col: usize, seed: [u8; 32]);
700}
701
702#[allow(clippy::too_many_arguments)]
703/// Fills the selected column with a discrete Gaussian noise vector
704/// scaled by `2^{-k}` with standard deviation `sigma`, bounded to `[-bound, bound]`.
705pub trait VecZnxFillNormalSourceBackend<B: Backend> {
706    fn vec_znx_fill_normal_source_backend(
707        &self,
708        base2k: usize,
709        res: &mut VecZnxBackendMut<'_, B>,
710        res_col: usize,
711        noise_infos: NoiseInfos,
712        source_xe: &mut Source,
713    );
714}
715
716#[allow(clippy::too_many_arguments)]
717pub trait VecZnxFillNormalBackend<B: Backend> {
718    /// Fills the selected backend-native column from a backend-defined normal sampler seeded by `seed`.
719    fn vec_znx_fill_normal_backend(
720        &self,
721        base2k: usize,
722        res: &mut VecZnxBackendMut<'_, B>,
723        res_col: usize,
724        noise_infos: NoiseInfos,
725        seed: [u8; 32],
726    );
727}
728
729#[allow(clippy::too_many_arguments)]
730pub trait VecZnxAddNormalSourceBackend<B: Backend> {
731    /// Adds a discrete normal vector scaled by 2^{-k} with the provided standard deviation and bounded to \[-bound, bound\].
732    fn vec_znx_add_normal_source_backend(
733        &self,
734        base2k: usize,
735        res: &mut VecZnxBackendMut<'_, B>,
736        res_col: usize,
737        noise_infos: NoiseInfos,
738        source_xe: &mut Source,
739    );
740}
741
742#[allow(clippy::too_many_arguments)]
743pub trait VecZnxAddNormalBackend<B: Backend> {
744    /// Adds backend-defined normal noise to the selected backend-native column using `seed`.
745    fn vec_znx_add_normal_backend(
746        &self,
747        base2k: usize,
748        res: &mut VecZnxBackendMut<'_, B>,
749        res_col: usize,
750        noise_infos: NoiseInfos,
751        seed: [u8; 32],
752    );
753}
poulpy_hal/api/vec_znx.rs

poulpy_hal/api/
vec_znx.rs
