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
325pub trait VecZnxLshAddCoeffToCoeffBackend<B: Backend> {
326    #[allow(clippy::too_many_arguments)]
327    fn vec_znx_lsh_add_coeff_to_coeff_backend(
328        &self,
329        base2k: usize,
330        k: usize,
331        res: &mut VecZnxBackendMut<'_, B>,
332        res_col: usize,
333        a: &VecZnxBackendRef<'_, B>,
334        a_col: usize,
335        a_coeff: usize,
336        res_coeff: usize,
337        scratch: &mut ScratchArena<'_, B>,
338    );
339}
340
341pub trait VecZnxLshSubCoeffToCoeffBackend<B: Backend> {
342    #[allow(clippy::too_many_arguments)]
343    fn vec_znx_lsh_sub_coeff_to_coeff_backend(
344        &self,
345        base2k: usize,
346        k: usize,
347        res: &mut VecZnxBackendMut<'_, B>,
348        res_col: usize,
349        a: &VecZnxBackendRef<'_, B>,
350        a_col: usize,
351        a_coeff: usize,
352        res_coeff: usize,
353        scratch: &mut ScratchArena<'_, B>,
354    );
355}
356
357/// Returns scratch bytes required for right-shift operations.
358pub trait VecZnxRshTmpBytes {
359    fn vec_znx_rsh_tmp_bytes(&self) -> usize;
360}
361
362pub trait VecZnxRshBackend<B: Backend> {
363    /// Right shift by k bits all columns of `a`.
364    #[allow(clippy::too_many_arguments)]
365    fn vec_znx_rsh_backend(
366        &self,
367        base2k: usize,
368        k: usize,
369        res: &mut VecZnxBackendMut<'_, B>,
370        res_col: usize,
371        a: &VecZnxBackendRef<'_, B>,
372        a_col: usize,
373        scratch: &mut ScratchArena<'_, B>,
374    );
375}
376
377pub trait VecZnxRshCoeffBackend<B: Backend> {
378    #[allow(clippy::too_many_arguments)]
379    fn vec_znx_rsh_coeff_backend(
380        &self,
381        base2k: usize,
382        k: usize,
383        res: &mut VecZnxBackendMut<'_, B>,
384        res_col: usize,
385        a: &VecZnxBackendRef<'_, B>,
386        a_col: usize,
387        a_coeff: usize,
388        scratch: &mut ScratchArena<'_, B>,
389    );
390}
391
392pub trait VecZnxRshAddIntoBackend<B: Backend> {
393    /// Right shift by k bits all columns of `a`.
394    #[allow(clippy::too_many_arguments)]
395    fn vec_znx_rsh_add_into_backend(
396        &self,
397        base2k: usize,
398        k: usize,
399        res: &mut VecZnxBackendMut<'_, B>,
400        res_col: usize,
401        a: &VecZnxBackendRef<'_, B>,
402        a_col: usize,
403        scratch: &mut ScratchArena<'_, B>,
404    );
405}
406
407pub trait VecZnxRshAddCoeffIntoBackend<B: Backend> {
408    #[allow(clippy::too_many_arguments)]
409    fn vec_znx_rsh_add_coeff_into_backend(
410        &self,
411        base2k: usize,
412        k: usize,
413        res: &mut VecZnxBackendMut<'_, B>,
414        res_col: usize,
415        a: &VecZnxBackendRef<'_, B>,
416        a_col: usize,
417        a_coeff: usize,
418        res_coeff: usize,
419        scratch: &mut ScratchArena<'_, B>,
420    );
421}
422
423pub trait VecZnxRshSubCoeffIntoBackend<B: Backend> {
424    #[allow(clippy::too_many_arguments)]
425    fn vec_znx_rsh_sub_coeff_into_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        a_coeff: usize,
434        res_coeff: usize,
435        scratch: &mut ScratchArena<'_, B>,
436    );
437}
438
439pub trait VecZnxLshSubBackend<B: Backend> {
440    /// Left shift by k bits and subtract from destination.
441    #[allow(clippy::too_many_arguments)]
442    fn vec_znx_lsh_sub_backend(
443        &self,
444        base2k: usize,
445        k: usize,
446        res: &mut VecZnxBackendMut<'_, B>,
447        res_col: usize,
448        a: &VecZnxBackendRef<'_, B>,
449        a_col: usize,
450        scratch: &mut ScratchArena<'_, B>,
451    );
452}
453
454pub trait VecZnxRshSubBackend<B: Backend> {
455    /// Right shift by k bits and subtract from destination.
456    #[allow(clippy::too_many_arguments)]
457    fn vec_znx_rsh_sub_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        scratch: &mut ScratchArena<'_, B>,
466    );
467}
468
469pub trait VecZnxLshAssignBackend<B: Backend> {
470    /// Left shift by k bits all columns of `a`.
471    fn vec_znx_lsh_assign_backend(
472        &self,
473        base2k: usize,
474        k: usize,
475        a: &mut VecZnxBackendMut<'_, B>,
476        a_col: usize,
477        scratch: &mut ScratchArena<'_, B>,
478    );
479}
480
481pub trait VecZnxRshAssignBackend<B: Backend> {
482    /// Right shift by k bits all columns of `a`.
483    fn vec_znx_rsh_assign_backend(
484        &self,
485        base2k: usize,
486        k: usize,
487        a: &mut VecZnxBackendMut<'_, B>,
488        a_col: usize,
489        scratch: &mut ScratchArena<'_, B>,
490    );
491}
492
493pub trait VecZnxRotateBackend<B: Backend> {
494    /// Multiplies the selected column of `a` by X^k and stores the result in `res_col` of `res`.
495    fn vec_znx_rotate_backend(
496        &self,
497        p: i64,
498        res: &mut VecZnxBackendMut<'_, B>,
499        res_col: usize,
500        a: &VecZnxBackendRef<'_, B>,
501        a_col: usize,
502    );
503}
504
505pub trait VecZnxRotateAssignTmpBytes {
506    fn vec_znx_rotate_assign_tmp_bytes(&self) -> usize;
507}
508
509pub trait VecZnxRotateAssignBackend<B: Backend> {
510    /// Multiplies the selected column of `a` by X^k.
511    fn vec_znx_rotate_assign_backend(
512        &self,
513        p: i64,
514        a: &mut VecZnxBackendMut<'_, B>,
515        a_col: usize,
516        scratch: &mut ScratchArena<'_, B>,
517    );
518}
519
520pub trait VecZnxAutomorphismBackend<B: Backend> {
521    /// Applies the automorphism X^i -> X^ik on the selected column of `a` and stores the result in `res_col` column of `res`.
522    fn vec_znx_automorphism_backend(
523        &self,
524        k: i64,
525        res: &mut VecZnxBackendMut<'_, B>,
526        res_col: usize,
527        a: &VecZnxBackendRef<'_, B>,
528        a_col: usize,
529    );
530}
531
532pub trait VecZnxAutomorphismAssignTmpBytes {
533    fn vec_znx_automorphism_assign_tmp_bytes(&self) -> usize;
534}
535
536pub trait VecZnxAutomorphismAssignBackend<B: Backend> {
537    /// Applies the automorphism X^i -> X^ik on the selected column of `a`.
538    fn vec_znx_automorphism_assign_backend(
539        &self,
540        k: i64,
541        res: &mut VecZnxBackendMut<'_, B>,
542        res_col: usize,
543        scratch: &mut ScratchArena<'_, B>,
544    );
545}
546
547pub trait VecZnxAutomorphismRotateBackend<B: Backend> {
548    /// Fused automorphism + rotation: computes `res = X^k * auto(p, a)` on the
549    /// selected column of `a` and stores it in `res_col` of `res`. Equivalent to
550    /// an automorphism with `p` followed by a rotation by `k`, in a single pass.
551    #[allow(clippy::too_many_arguments)]
552    fn vec_znx_automorphism_rotate_backend(
553        &self,
554        p: i64,
555        k: i64,
556        res: &mut VecZnxBackendMut<'_, B>,
557        res_col: usize,
558        a: &VecZnxBackendRef<'_, B>,
559        a_col: usize,
560    );
561}
562
563pub trait ScalarZnxAutomorphismBackend<B: Backend> {
564    /// Applies the automorphism X^i -> X^ik on the selected column of `a` and stores the result in `res_col` column of `res`.
565    fn scalar_znx_automorphism_backend(
566        &self,
567        k: i64,
568        res: &mut ScalarZnxBackendMut<'_, B>,
569        res_col: usize,
570        a: &ScalarZnxBackendRef<'_, B>,
571        a_col: usize,
572    );
573}
574
575pub trait ScalarZnxAutomorphismAssignTmpBytes {
576    fn scalar_znx_automorphism_assign_tmp_bytes(&self) -> usize;
577}
578
579pub trait ScalarZnxAutomorphismAssignBackend<B: Backend> {
580    /// Applies the automorphism X^i -> X^ik on the selected column of `a`.
581    fn scalar_znx_automorphism_assign_backend(
582        &self,
583        k: i64,
584        res: &mut ScalarZnxBackendMut<'_, B>,
585        res_col: usize,
586        scratch: &mut ScratchArena<'_, B>,
587    );
588}
589
590/// Multiplies the selected column by `(X^p - 1)` in `Z[X]/(X^N + 1)`.
591pub trait VecZnxMulXpMinusOneBackend<B: Backend> {
592    fn vec_znx_mul_xp_minus_one_backend(
593        &self,
594        p: i64,
595        res: &mut VecZnxBackendMut<'_, B>,
596        res_col: usize,
597        a: &VecZnxBackendRef<'_, B>,
598        a_col: usize,
599    );
600}
601
602pub trait VecZnxMulXpMinusOneAssignTmpBytes {
603    fn vec_znx_mul_xp_minus_one_assign_tmp_bytes(&self) -> usize;
604}
605
606pub trait VecZnxMulXpMinusOneAssignBackend<B: Backend> {
607    fn vec_znx_mul_xp_minus_one_assign_backend(
608        &self,
609        p: i64,
610        res: &mut VecZnxBackendMut<'_, B>,
611        res_col: usize,
612        scratch: &mut ScratchArena<'_, B>,
613    );
614}
615
616pub trait VecZnxSplitRingTmpBytes {
617    fn vec_znx_split_ring_tmp_bytes(&self) -> usize;
618}
619
620pub trait VecZnxSplitRingBackend<B: Backend> {
621    /// Splits the selected columns of `b` into subrings and copies them them into the selected column of `res`.
622    ///
623    /// # Panics
624    ///
625    /// This method requires that all [crate::layouts::VecZnx] of b have the same ring degree
626    /// and that b.n() * b.len() <= a.n()
627    fn vec_znx_split_ring_backend(
628        &self,
629        res: &mut [VecZnxBackendMut<'_, B>],
630        res_col: usize,
631        a: &VecZnxBackendRef<'_, B>,
632        a_col: usize,
633        scratch: &mut ScratchArena<'_, B>,
634    );
635}
636
637pub trait VecZnxMergeRingsTmpBytes {
638    fn vec_znx_merge_rings_tmp_bytes(&self) -> usize;
639}
640
641pub trait VecZnxMergeRingsBackend<B: Backend> {
642    /// Merges the subrings of the selected column of `a` into the selected column of `res`.
643    ///
644    /// # Panics
645    ///
646    /// This method requires that all [crate::layouts::VecZnx] of a have the same ring degree
647    /// and that a.n() * a.len() <= b.n()
648    fn vec_znx_merge_rings_backend(
649        &self,
650        res: &mut VecZnxBackendMut<'_, B>,
651        res_col: usize,
652        a: &[VecZnxBackendRef<'_, B>],
653        a_col: usize,
654        scratch: &mut ScratchArena<'_, B>,
655    );
656}
657
658/// Switches ring degree between `a` and `res` by truncation or zero-padding.
659pub trait VecZnxSwitchRingBackend<B: Backend> {
660    fn vec_znx_switch_ring_backend(
661        &self,
662        res: &mut VecZnxBackendMut<'_, B>,
663        res_col: usize,
664        a: &VecZnxBackendRef<'_, B>,
665        a_col: usize,
666    );
667}
668
669pub trait VecZnxCopyBackend<B: Backend> {
670    fn vec_znx_copy_backend(&self, res: &mut VecZnxBackendMut<'_, B>, res_col: usize, a: &VecZnxBackendRef<'_, B>, a_col: usize);
671}
672
673/// Per-limb square transpose of a `VecZnx`.
674///
675/// For each limb `j`, sets `res.at(c, j)[k] = a.at(k, j)[c]`.
676///
677/// # Panics
678///
679/// Requires `res.n() == a.cols()` and `res.cols() == a.n()`.
680pub trait VecZnxTransposeBackend<B: Backend> {
681    fn vec_znx_transpose_backend(&self, res: &mut VecZnxBackendMut<'_, B>, a: &VecZnxBackendRef<'_, B>);
682}
683
684pub trait ScalarZnxFillTernaryHwSourceBackend<B: Backend> {
685    fn scalar_znx_fill_ternary_hw_source_backend(
686        &self,
687        res: &mut ScalarZnxBackendMut<'_, B>,
688        res_col: usize,
689        hw: usize,
690        source: &mut Source,
691    );
692}
693
694pub trait ScalarZnxFillTernaryHwBackend<B: Backend> {
695    fn scalar_znx_fill_ternary_hw_backend(&self, res: &mut ScalarZnxBackendMut<'_, B>, res_col: usize, hw: usize, seed: [u8; 32]);
696}
697
698pub trait ScalarZnxFillTernaryProbSourceBackend<B: Backend> {
699    fn scalar_znx_fill_ternary_prob_source_backend(
700        &self,
701        res: &mut ScalarZnxBackendMut<'_, B>,
702        res_col: usize,
703        prob: f64,
704        source: &mut Source,
705    );
706}
707
708pub trait ScalarZnxFillTernaryProbBackend<B: Backend> {
709    fn scalar_znx_fill_ternary_prob_backend(
710        &self,
711        res: &mut ScalarZnxBackendMut<'_, B>,
712        res_col: usize,
713        prob: f64,
714        seed: [u8; 32],
715    );
716}
717
718pub trait ScalarZnxFillBinaryHwSourceBackend<B: Backend> {
719    fn scalar_znx_fill_binary_hw_source_backend(
720        &self,
721        res: &mut ScalarZnxBackendMut<'_, B>,
722        res_col: usize,
723        hw: usize,
724        source: &mut Source,
725    );
726}
727
728pub trait ScalarZnxFillBinaryHwBackend<B: Backend> {
729    fn scalar_znx_fill_binary_hw_backend(&self, res: &mut ScalarZnxBackendMut<'_, B>, res_col: usize, hw: usize, seed: [u8; 32]);
730}
731
732pub trait ScalarZnxFillBinaryProbSourceBackend<B: Backend> {
733    fn scalar_znx_fill_binary_prob_source_backend(
734        &self,
735        res: &mut ScalarZnxBackendMut<'_, B>,
736        res_col: usize,
737        prob: f64,
738        source: &mut Source,
739    );
740}
741
742pub trait ScalarZnxFillBinaryProbBackend<B: Backend> {
743    fn scalar_znx_fill_binary_prob_backend(
744        &self,
745        res: &mut ScalarZnxBackendMut<'_, B>,
746        res_col: usize,
747        prob: f64,
748        seed: [u8; 32],
749    );
750}
751
752pub trait ScalarZnxFillBinaryBlockSourceBackend<B: Backend> {
753    fn scalar_znx_fill_binary_block_source_backend(
754        &self,
755        res: &mut ScalarZnxBackendMut<'_, B>,
756        res_col: usize,
757        block_size: usize,
758        source: &mut Source,
759    );
760}
761
762pub trait ScalarZnxFillBinaryBlockBackend<B: Backend> {
763    fn scalar_znx_fill_binary_block_backend(
764        &self,
765        res: &mut ScalarZnxBackendMut<'_, B>,
766        res_col: usize,
767        block_size: usize,
768        seed: [u8; 32],
769    );
770}
771
772pub trait VecZnxFillUniformSourceBackend<B: Backend> {
773    /// Fills the first `size` size with uniform values in \[-2^{base2k-1}, 2^{base2k-1}\]
774    fn vec_znx_fill_uniform_source_backend(
775        &self,
776        base2k: usize,
777        res: &mut VecZnxBackendMut<'_, B>,
778        res_col: usize,
779        source: &mut Source,
780    );
781}
782
783pub trait VecZnxFillUniformBackend<B: Backend> {
784    /// Fills the selected backend-native column from a backend-defined uniform sampler seeded by `seed`.
785    fn vec_znx_fill_uniform_backend(&self, base2k: usize, res: &mut VecZnxBackendMut<'_, B>, res_col: usize, seed: [u8; 32]);
786}
787
788#[allow(clippy::too_many_arguments)]
789/// Fills the selected column with a discrete Gaussian noise vector
790/// scaled by `2^{-k}` with standard deviation `sigma`, bounded to `[-bound, bound]`.
791pub trait VecZnxFillNormalSourceBackend<B: Backend> {
792    fn vec_znx_fill_normal_source_backend(
793        &self,
794        base2k: usize,
795        res: &mut VecZnxBackendMut<'_, B>,
796        res_col: usize,
797        noise_infos: NoiseInfos,
798        source_xe: &mut Source,
799    );
800}
801
802#[allow(clippy::too_many_arguments)]
803pub trait VecZnxFillNormalBackend<B: Backend> {
804    /// Fills the selected backend-native column from a backend-defined normal sampler seeded by `seed`.
805    fn vec_znx_fill_normal_backend(
806        &self,
807        base2k: usize,
808        res: &mut VecZnxBackendMut<'_, B>,
809        res_col: usize,
810        noise_infos: NoiseInfos,
811        seed: [u8; 32],
812    );
813}
814
815#[allow(clippy::too_many_arguments)]
816pub trait VecZnxAddNormalSourceBackend<B: Backend> {
817    /// Adds a discrete normal vector scaled by 2^{-k} with the provided standard deviation and bounded to \[-bound, bound\].
818    fn vec_znx_add_normal_source_backend(
819        &self,
820        base2k: usize,
821        res: &mut VecZnxBackendMut<'_, B>,
822        res_col: usize,
823        noise_infos: NoiseInfos,
824        source_xe: &mut Source,
825    );
826}
827
828#[allow(clippy::too_many_arguments)]
829pub trait VecZnxAddNormalBackend<B: Backend> {
830    /// Adds backend-defined normal noise to the selected backend-native column using `seed`.
831    fn vec_znx_add_normal_backend(
832        &self,
833        base2k: usize,
834        res: &mut VecZnxBackendMut<'_, B>,
835        res_col: usize,
836        noise_infos: NoiseInfos,
837        seed: [u8; 32],
838    );
839}
poulpy_hal/api/vec_znx.rs

poulpy_hal/api/
vec_znx.rs
