poulpy/poulpy-hal/src/test_suite/vec_znx_dft.rs
poulpy-hal/src/test_suite/vec_znx_dft.rsRaw
1use rand::RngCore;
2
3use crate::{
4 api::{
5 ScratchOwnedAlloc, ScratchOwnedBorrow, VecZnxBigAlloc, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes, VecZnxDftAdd,
6 VecZnxDftAddInplace, VecZnxDftAlloc, VecZnxDftApply, VecZnxDftCopy, VecZnxDftSub, VecZnxDftSubInplace,
7 VecZnxDftSubNegateInplace, VecZnxIdftApply, VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA, VecZnxIdftApplyTmpBytes,
8 },
9 layouts::{Backend, DataViewMut, DigestU64, FillUniform, Module, ScratchOwned, VecZnx, VecZnxBig, VecZnxDft},
10 source::Source,
11};
12
13pub fn test_vec_znx_dft_add<BR: Backend, BT: Backend>(base2k: usize, module_ref: &Module<BR>, module_test: &Module<BT>)
14where
15 Module<BR>: VecZnxDftAdd<BR>
16 + VecZnxDftAlloc<BR>
17 + VecZnxDftApply<BR>
18 + VecZnxIdftApplyConsume<BR>
19 + VecZnxBigNormalize<BR>
20 + VecZnxBigNormalizeTmpBytes,
21 Module<BT>: VecZnxDftAdd<BT>
22 + VecZnxDftAlloc<BT>
23 + VecZnxDftApply<BT>
24 + VecZnxIdftApplyConsume<BT>
25 + VecZnxBigNormalize<BT>
26 + VecZnxBigNormalizeTmpBytes,
27 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
28 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
29{
30 assert_eq!(module_ref.n(), module_test.n());
31 let n: usize = module_ref.n();
32
33 let mut source: Source = Source::new([0u8; 32]);
34 let cols: usize = 2;
35
36 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(module_ref.vec_znx_big_normalize_tmp_bytes());
37 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(module_test.vec_znx_big_normalize_tmp_bytes());
38
39 for a_size in [1, 2, 3, 4] {
40 let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
41 a.fill_uniform(base2k, &mut source);
42 let a_digest = a.digest_u64();
43
44 let mut a_dft_ref: VecZnxDft<Vec<u8>, BR> = module_ref.vec_znx_dft_alloc(cols, a_size);
45 let mut a_dft_test: VecZnxDft<Vec<u8>, BT> = module_test.vec_znx_dft_alloc(cols, a_size);
46
47 for j in 0..cols {
48 module_ref.vec_znx_dft_apply(1, 0, &mut a_dft_ref, j, &a, j);
49 module_test.vec_znx_dft_apply(1, 0, &mut a_dft_test, j, &a, j);
50 }
51
52 assert_eq!(a.digest_u64(), a_digest);
53
54 let a_dft_ref_digest: u64 = a_dft_ref.digest_u64();
55 let a_dft_test_digest: u64 = a_dft_test.digest_u64();
56
57 for b_size in [1, 2, 3, 4] {
58 let mut b: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, b_size);
59 b.fill_uniform(base2k, &mut source);
60 let b_digest: u64 = b.digest_u64();
61
62 let mut b_dft_ref: VecZnxDft<Vec<u8>, BR> = module_ref.vec_znx_dft_alloc(cols, b_size);
63 let mut b_dft_test: VecZnxDft<Vec<u8>, BT> = module_test.vec_znx_dft_alloc(cols, b_size);
64
65 for j in 0..cols {
66 module_ref.vec_znx_dft_apply(1, 0, &mut b_dft_ref, j, &b, j);
67 module_test.vec_znx_dft_apply(1, 0, &mut b_dft_test, j, &b, j);
68 }
69
70 assert_eq!(b.digest_u64(), b_digest);
71
72 let b_dft_ref_digest: u64 = b_dft_ref.digest_u64();
73 let b_dft_test_digest: u64 = b_dft_test.digest_u64();
74
75 for res_size in [1, 2, 3, 4] {
76 let mut res_dft_ref: VecZnxDft<Vec<u8>, BR> = module_ref.vec_znx_dft_alloc(cols, res_size);
77 let mut res_dft_test: VecZnxDft<Vec<u8>, BT> = module_test.vec_znx_dft_alloc(cols, res_size);
78
79 // Set d to garbage
80 source.fill_bytes(res_dft_ref.data_mut());
81 source.fill_bytes(res_dft_test.data_mut());
82
83 // Reference
84 for i in 0..cols {
85 module_ref.vec_znx_dft_add(&mut res_dft_ref, i, &a_dft_ref, i, &b_dft_ref, i);
86 module_test.vec_znx_dft_add(&mut res_dft_test, i, &a_dft_test, i, &b_dft_test, i);
87 }
88
89 assert_eq!(a_dft_ref.digest_u64(), a_dft_ref_digest);
90 assert_eq!(a_dft_test.digest_u64(), a_dft_test_digest);
91 assert_eq!(b_dft_ref.digest_u64(), b_dft_ref_digest);
92 assert_eq!(b_dft_test.digest_u64(), b_dft_test_digest);
93
94 let res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_idft_apply_consume(res_dft_ref);
95 let res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_idft_apply_consume(res_dft_test);
96
97 let mut res_small_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
98 let mut res_small_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
99
100 let res_ref_digest: u64 = res_big_ref.digest_u64();
101 let res_test_digest: u64 = res_big_test.digest_u64();
102
103 for j in 0..cols {
104 module_ref.vec_znx_big_normalize(
105 base2k,
106 &mut res_small_ref,
107 j,
108 base2k,
109 &res_big_ref,
110 j,
111 scratch_ref.borrow(),
112 );
113 module_test.vec_znx_big_normalize(
114 base2k,
115 &mut res_small_test,
116 j,
117 base2k,
118 &res_big_test,
119 j,
120 scratch_test.borrow(),
121 );
122 }
123
124 assert_eq!(res_big_ref.digest_u64(), res_ref_digest);
125 assert_eq!(res_big_test.digest_u64(), res_test_digest);
126
127 assert_eq!(res_small_ref, res_small_test);
128 }
129 }
130 }
131}
132
133pub fn test_vec_znx_dft_add_inplace<BR: Backend, BT: Backend>(base2k: usize, module_ref: &Module<BR>, module_test: &Module<BT>)
134where
135 Module<BR>: VecZnxDftAddInplace<BR>
136 + VecZnxDftAlloc<BR>
137 + VecZnxDftApply<BR>
138 + VecZnxIdftApplyConsume<BR>
139 + VecZnxBigNormalize<BR>
140 + VecZnxBigNormalizeTmpBytes,
141 Module<BT>: VecZnxDftAddInplace<BT>
142 + VecZnxDftAlloc<BT>
143 + VecZnxDftApply<BT>
144 + VecZnxIdftApplyConsume<BT>
145 + VecZnxBigNormalize<BT>
146 + VecZnxBigNormalizeTmpBytes,
147 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
148 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
149{
150 assert_eq!(module_ref.n(), module_test.n());
151 let n: usize = module_ref.n();
152
153 let mut source: Source = Source::new([0u8; 32]);
154 let cols: usize = 2;
155
156 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(module_ref.vec_znx_big_normalize_tmp_bytes());
157 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(module_test.vec_znx_big_normalize_tmp_bytes());
158 for a_size in [1, 2, 3, 4] {
159 let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
160 a.fill_uniform(base2k, &mut source);
161 let a_digest = a.digest_u64();
162
163 let mut a_dft_ref: VecZnxDft<Vec<u8>, BR> = module_ref.vec_znx_dft_alloc(cols, a_size);
164 let mut a_dft_test: VecZnxDft<Vec<u8>, BT> = module_test.vec_znx_dft_alloc(cols, a_size);
165
166 for j in 0..cols {
167 module_ref.vec_znx_dft_apply(1, 0, &mut a_dft_ref, j, &a, j);
168 module_test.vec_znx_dft_apply(1, 0, &mut a_dft_test, j, &a, j);
169 }
170
171 assert_eq!(a.digest_u64(), a_digest);
172
173 let a_dft_ref_digest: u64 = a_dft_ref.digest_u64();
174 let a_dft_test_digest: u64 = a_dft_test.digest_u64();
175
176 for res_size in [1, 2, 3, 4] {
177 let mut res: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
178 res.fill_uniform(base2k, &mut source);
179 let res_digest: u64 = res.digest_u64();
180
181 let mut res_dft_ref: VecZnxDft<Vec<u8>, BR> = module_ref.vec_znx_dft_alloc(cols, res_size);
182 let mut res_dft_test: VecZnxDft<Vec<u8>, BT> = module_test.vec_znx_dft_alloc(cols, res_size);
183
184 for j in 0..cols {
185 module_ref.vec_znx_dft_apply(1, 0, &mut res_dft_ref, j, &res, j);
186 module_test.vec_znx_dft_apply(1, 0, &mut res_dft_test, j, &res, j);
187 }
188
189 assert_eq!(res.digest_u64(), res_digest);
190
191 // Reference
192 for i in 0..cols {
193 module_ref.vec_znx_dft_add_inplace(&mut res_dft_ref, i, &a_dft_ref, i);
194 module_test.vec_znx_dft_add_inplace(&mut res_dft_test, i, &a_dft_test, i);
195 }
196
197 assert_eq!(a_dft_ref.digest_u64(), a_dft_ref_digest);
198 assert_eq!(a_dft_test.digest_u64(), a_dft_test_digest);
199
200 let res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_idft_apply_consume(res_dft_ref);
201 let res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_idft_apply_consume(res_dft_test);
202
203 let mut res_small_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
204 let mut res_small_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
205
206 let res_ref_digest: u64 = res_big_ref.digest_u64();
207 let res_test_digest: u64 = res_big_test.digest_u64();
208
209 for j in 0..cols {
210 module_ref.vec_znx_big_normalize(
211 base2k,
212 &mut res_small_ref,
213 j,
214 base2k,
215 &res_big_ref,
216 j,
217 scratch_ref.borrow(),
218 );
219 module_test.vec_znx_big_normalize(
220 base2k,
221 &mut res_small_test,
222 j,
223 base2k,
224 &res_big_test,
225 j,
226 scratch_test.borrow(),
227 );
228 }
229
230 assert_eq!(res_big_ref.digest_u64(), res_ref_digest);
231 assert_eq!(res_big_test.digest_u64(), res_test_digest);
232
233 assert_eq!(res_small_ref, res_small_test);
234 }
235 }
236}
237
238pub fn test_vec_znx_copy<BR: Backend, BT: Backend>(base2k: usize, module_ref: &Module<BR>, module_test: &Module<BT>)
239where
240 Module<BR>: VecZnxDftCopy<BR>
241 + VecZnxDftAlloc<BR>
242 + VecZnxDftApply<BR>
243 + VecZnxIdftApplyConsume<BR>
244 + VecZnxBigNormalize<BR>
245 + VecZnxBigNormalizeTmpBytes,
246 Module<BT>: VecZnxDftCopy<BT>
247 + VecZnxDftAlloc<BT>
248 + VecZnxDftApply<BT>
249 + VecZnxIdftApplyConsume<BT>
250 + VecZnxBigNormalize<BT>
251 + VecZnxBigNormalizeTmpBytes,
252 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
253 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
254{
255 assert_eq!(module_ref.n(), module_test.n());
256 let n: usize = module_ref.n();
257
258 let mut source: Source = Source::new([0u8; 32]);
259 let cols: usize = 2;
260
261 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(module_ref.vec_znx_big_normalize_tmp_bytes());
262 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(module_test.vec_znx_big_normalize_tmp_bytes());
263
264 for a_size in [1, 2, 6, 11] {
265 let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
266 a.fill_uniform(base2k, &mut source);
267 let a_digest = a.digest_u64();
268
269 let mut a_dft_ref: VecZnxDft<Vec<u8>, BR> = module_ref.vec_znx_dft_alloc(cols, a_size);
270 let mut a_dft_test: VecZnxDft<Vec<u8>, BT> = module_test.vec_znx_dft_alloc(cols, a_size);
271
272 for j in 0..cols {
273 module_ref.vec_znx_dft_apply(1, 0, &mut a_dft_ref, j, &a, j);
274 module_test.vec_znx_dft_apply(1, 0, &mut a_dft_test, j, &a, j);
275 }
276
277 assert_eq!(a.digest_u64(), a_digest);
278
279 let a_dft_ref_digest: u64 = a_dft_ref.digest_u64();
280 let a_dft_test_digest: u64 = a_dft_test.digest_u64();
281
282 for res_size in [1, 2, 6, 11] {
283 for params in [[1, 0], [1, 1], [1, 2], [2, 2]] {
284 let steps: usize = params[0];
285 let offset: usize = params[1];
286
287 let mut res_dft_ref: VecZnxDft<Vec<u8>, BR> = module_ref.vec_znx_dft_alloc(cols, res_size);
288 let mut res_dft_test: VecZnxDft<Vec<u8>, BT> = module_test.vec_znx_dft_alloc(cols, res_size);
289
290 // Set d to garbage
291 source.fill_bytes(res_dft_ref.data_mut());
292 source.fill_bytes(res_dft_test.data_mut());
293
294 // Reference
295 for i in 0..cols {
296 module_ref.vec_znx_dft_copy(steps, offset, &mut res_dft_ref, i, &a_dft_ref, i);
297 module_test.vec_znx_dft_copy(steps, offset, &mut res_dft_test, i, &a_dft_test, i);
298 }
299
300 assert_eq!(a_dft_ref.digest_u64(), a_dft_ref_digest);
301 assert_eq!(a_dft_test.digest_u64(), a_dft_test_digest);
302
303 let res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_idft_apply_consume(res_dft_ref);
304 let res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_idft_apply_consume(res_dft_test);
305
306 let mut res_small_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
307 let mut res_small_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
308
309 let res_ref_digest: u64 = res_big_ref.digest_u64();
310 let res_test_digest: u64 = res_big_test.digest_u64();
311
312 for j in 0..cols {
313 module_ref.vec_znx_big_normalize(
314 base2k,
315 &mut res_small_ref,
316 j,
317 base2k,
318 &res_big_ref,
319 j,
320 scratch_ref.borrow(),
321 );
322 module_test.vec_znx_big_normalize(
323 base2k,
324 &mut res_small_test,
325 j,
326 base2k,
327 &res_big_test,
328 j,
329 scratch_test.borrow(),
330 );
331 }
332
333 assert_eq!(res_big_ref.digest_u64(), res_ref_digest);
334 assert_eq!(res_big_test.digest_u64(), res_test_digest);
335
336 assert_eq!(res_small_ref, res_small_test);
337 }
338 }
339 }
340}
341
342pub fn test_vec_znx_idft_apply<BR: Backend, BT: Backend>(base2k: usize, module_ref: &Module<BR>, module_test: &Module<BT>)
343where
344 Module<BR>: VecZnxDftApply<BR>
345 + VecZnxDftAlloc<BR>
346 + VecZnxBigAlloc<BR>
347 + VecZnxBigNormalize<BR>
348 + VecZnxBigNormalizeTmpBytes
349 + VecZnxIdftApply<BR>,
350 Module<BT>: VecZnxDftApply<BT>
351 + VecZnxDftAlloc<BT>
352 + VecZnxBigAlloc<BT>
353 + VecZnxBigNormalize<BT>
354 + VecZnxBigNormalizeTmpBytes
355 + VecZnxIdftApply<BT>,
356 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
357 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
358{
359 assert_eq!(module_ref.n(), module_test.n());
360 let n: usize = module_ref.n();
361
362 let mut source: Source = Source::new([0u8; 32]);
363 let cols: usize = 2;
364
365 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(module_ref.vec_znx_big_normalize_tmp_bytes());
366 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(module_test.vec_znx_big_normalize_tmp_bytes());
367
368 for a_size in [1, 2, 3, 4] {
369 let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
370 a.fill_uniform(base2k, &mut source);
371 let a_digest: u64 = a.digest_u64();
372
373 for res_size in [1, 2, 3, 4] {
374 for params in [[1, 0], [1, 1], [1, 2], [2, 2]] {
375 let steps: usize = params[0];
376 let offset: usize = params[1];
377
378 let mut res_dft_ref: VecZnxDft<Vec<u8>, BR> = module_ref.vec_znx_dft_alloc(cols, a_size);
379 let mut res_dft_test: VecZnxDft<Vec<u8>, BT> = module_test.vec_znx_dft_alloc(cols, a_size);
380
381 for j in 0..cols {
382 module_ref.vec_znx_dft_apply(steps, offset, &mut res_dft_ref, j, &a, j);
383 module_test.vec_znx_dft_apply(steps, offset, &mut res_dft_test, j, &a, j);
384 }
385
386 assert_eq!(a.digest_u64(), a_digest);
387 let res_dft_ref_digest: u64 = res_dft_ref.digest_u64();
388 let rest_dft_test_digest: u64 = res_dft_test.digest_u64();
389
390 let mut res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, res_size);
391 let mut res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, res_size);
392
393 for j in 0..cols {
394 module_ref.vec_znx_idft_apply(&mut res_big_ref, j, &res_dft_ref, j, scratch_ref.borrow());
395 module_test.vec_znx_idft_apply(
396 &mut res_big_test,
397 j,
398 &res_dft_test,
399 j,
400 scratch_test.borrow(),
401 );
402 }
403
404 assert_eq!(res_dft_ref.digest_u64(), res_dft_ref_digest);
405 assert_eq!(res_dft_test.digest_u64(), rest_dft_test_digest);
406
407 let mut res_small_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
408 let mut res_small_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
409
410 let res_ref_digest: u64 = res_big_ref.digest_u64();
411 let res_test_digest: u64 = res_big_test.digest_u64();
412
413 for j in 0..cols {
414 module_ref.vec_znx_big_normalize(
415 base2k,
416 &mut res_small_ref,
417 j,
418 base2k,
419 &res_big_ref,
420 j,
421 scratch_ref.borrow(),
422 );
423 module_test.vec_znx_big_normalize(
424 base2k,
425 &mut res_small_test,
426 j,
427 base2k,
428 &res_big_test,
429 j,
430 scratch_test.borrow(),
431 );
432 }
433
434 assert_eq!(res_big_ref.digest_u64(), res_ref_digest);
435 assert_eq!(res_big_test.digest_u64(), res_test_digest);
436
437 assert_eq!(res_small_ref, res_small_test);
438 }
439 }
440 }
441}
442
443pub fn test_vec_znx_idft_apply_tmpa<BR: Backend, BT: Backend>(base2k: usize, module_ref: &Module<BR>, module_test: &Module<BT>)
444where
445 Module<BR>: VecZnxDftApply<BR>
446 + VecZnxDftAlloc<BR>
447 + VecZnxBigAlloc<BR>
448 + VecZnxBigNormalize<BR>
449 + VecZnxBigNormalizeTmpBytes
450 + VecZnxIdftApplyTmpA<BR>,
451 Module<BT>: VecZnxDftApply<BT>
452 + VecZnxDftAlloc<BT>
453 + VecZnxBigAlloc<BT>
454 + VecZnxBigNormalize<BT>
455 + VecZnxBigNormalizeTmpBytes
456 + VecZnxIdftApplyTmpA<BT>,
457 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
458 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
459{
460 assert_eq!(module_ref.n(), module_test.n());
461 let n: usize = module_ref.n();
462
463 let mut source: Source = Source::new([0u8; 32]);
464 let cols: usize = 2;
465
466 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(module_ref.vec_znx_big_normalize_tmp_bytes());
467 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(module_test.vec_znx_big_normalize_tmp_bytes());
468
469 for a_size in [1, 2, 3, 4] {
470 let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
471 a.fill_uniform(base2k, &mut source);
472 let a_digest: u64 = a.digest_u64();
473
474 for res_size in [1, 2, 3, 4] {
475 for params in [[1, 0], [1, 1], [1, 2], [2, 2]] {
476 let steps: usize = params[0];
477 let offset: usize = params[1];
478
479 let mut res_dft_ref: VecZnxDft<Vec<u8>, BR> = module_ref.vec_znx_dft_alloc(cols, a_size);
480 let mut res_dft_test: VecZnxDft<Vec<u8>, BT> = module_test.vec_znx_dft_alloc(cols, a_size);
481
482 for j in 0..cols {
483 module_ref.vec_znx_dft_apply(steps, offset, &mut res_dft_ref, j, &a, j);
484 module_test.vec_znx_dft_apply(steps, offset, &mut res_dft_test, j, &a, j);
485 }
486
487 assert_eq!(a.digest_u64(), a_digest);
488
489 let mut res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, res_size);
490 let mut res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, res_size);
491
492 for j in 0..cols {
493 module_ref.vec_znx_idft_apply_tmpa(&mut res_big_ref, j, &mut res_dft_ref, j);
494 module_test.vec_znx_idft_apply_tmpa(&mut res_big_test, j, &mut res_dft_test, j);
495 }
496
497 let mut res_small_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
498 let mut res_small_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
499
500 let res_ref_digest: u64 = res_big_ref.digest_u64();
501 let res_test_digest: u64 = res_big_test.digest_u64();
502
503 for j in 0..cols {
504 module_ref.vec_znx_big_normalize(
505 base2k,
506 &mut res_small_ref,
507 j,
508 base2k,
509 &res_big_ref,
510 j,
511 scratch_ref.borrow(),
512 );
513 module_test.vec_znx_big_normalize(
514 base2k,
515 &mut res_small_test,
516 j,
517 base2k,
518 &res_big_test,
519 j,
520 scratch_test.borrow(),
521 );
522 }
523
524 assert_eq!(res_big_ref.digest_u64(), res_ref_digest);
525 assert_eq!(res_big_test.digest_u64(), res_test_digest);
526
527 assert_eq!(res_small_ref, res_small_test);
528 }
529 }
530 }
531}
532
533pub fn test_vec_znx_idft_apply_consume<BR: Backend, BT: Backend>(base2k: usize, module_ref: &Module<BR>, module_test: &Module<BT>)
534where
535 Module<BR>: VecZnxDftApply<BR>
536 + VecZnxIdftApplyTmpBytes
537 + VecZnxDftAlloc<BR>
538 + VecZnxBigNormalize<BR>
539 + VecZnxBigNormalizeTmpBytes
540 + VecZnxIdftApplyConsume<BR>,
541 Module<BT>: VecZnxDftApply<BT>
542 + VecZnxIdftApplyTmpBytes
543 + VecZnxDftAlloc<BT>
544 + VecZnxBigNormalize<BT>
545 + VecZnxBigNormalizeTmpBytes
546 + VecZnxIdftApplyConsume<BT>,
547 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
548 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
549{
550 assert_eq!(module_ref.n(), module_test.n());
551 let n: usize = module_ref.n();
552
553 let mut source: Source = Source::new([0u8; 32]);
554 let cols: usize = 2;
555
556 let mut scratch_ref: ScratchOwned<BR> =
557 ScratchOwned::alloc(module_ref.vec_znx_big_normalize_tmp_bytes() | module_ref.vec_znx_idft_apply_tmp_bytes());
558 let mut scratch_test: ScratchOwned<BT> =
559 ScratchOwned::alloc(module_test.vec_znx_big_normalize_tmp_bytes() | module_test.vec_znx_idft_apply_tmp_bytes());
560
561 for a_size in [1, 2, 3, 4] {
562 let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
563 a.fill_uniform(base2k, &mut source);
564 let a_digest: u64 = a.digest_u64();
565
566 for res_size in [1, 2, 3, 4] {
567 for params in [[1, 0], [1, 1], [1, 2], [2, 2]] {
568 let steps: usize = params[0];
569 let offset: usize = params[1];
570
571 let mut res_dft_ref: VecZnxDft<Vec<u8>, BR> = module_ref.vec_znx_dft_alloc(cols, a_size);
572 let mut res_dft_test: VecZnxDft<Vec<u8>, BT> = module_test.vec_znx_dft_alloc(cols, a_size);
573
574 for j in 0..cols {
575 module_ref.vec_znx_dft_apply(steps, offset, &mut res_dft_ref, j, &a, j);
576 module_test.vec_znx_dft_apply(steps, offset, &mut res_dft_test, j, &a, j);
577 }
578
579 assert_eq!(a.digest_u64(), a_digest);
580
581 let res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_idft_apply_consume(res_dft_ref);
582 let res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_idft_apply_consume(res_dft_test);
583
584 let mut res_small_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
585 let mut res_small_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
586
587 let res_ref_digest: u64 = res_big_ref.digest_u64();
588 let res_test_digest: u64 = res_big_test.digest_u64();
589
590 for j in 0..cols {
591 module_ref.vec_znx_big_normalize(
592 base2k,
593 &mut res_small_ref,
594 j,
595 base2k,
596 &res_big_ref,
597 j,
598 scratch_ref.borrow(),
599 );
600 module_test.vec_znx_big_normalize(
601 base2k,
602 &mut res_small_test,
603 j,
604 base2k,
605 &res_big_test,
606 j,
607 scratch_test.borrow(),
608 );
609 }
610
611 assert_eq!(res_big_ref.digest_u64(), res_ref_digest);
612 assert_eq!(res_big_test.digest_u64(), res_test_digest);
613
614 assert_eq!(res_small_ref, res_small_test);
615 }
616 }
617 }
618}
619
620pub fn test_vec_znx_dft_sub<BR: Backend, BT: Backend>(base2k: usize, module_ref: &Module<BR>, module_test: &Module<BT>)
621where
622 Module<BR>: VecZnxDftSub<BR>
623 + VecZnxDftAlloc<BR>
624 + VecZnxDftApply<BR>
625 + VecZnxIdftApplyConsume<BR>
626 + VecZnxBigNormalize<BR>
627 + VecZnxBigNormalizeTmpBytes,
628 Module<BT>: VecZnxDftSub<BT>
629 + VecZnxDftAlloc<BT>
630 + VecZnxDftApply<BT>
631 + VecZnxIdftApplyConsume<BT>
632 + VecZnxBigNormalize<BT>
633 + VecZnxBigNormalizeTmpBytes,
634 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
635 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
636{
637 assert_eq!(module_ref.n(), module_test.n());
638 let n: usize = module_ref.n();
639
640 let mut source: Source = Source::new([0u8; 32]);
641 let cols: usize = 2;
642
643 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(module_ref.vec_znx_big_normalize_tmp_bytes());
644 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(module_test.vec_znx_big_normalize_tmp_bytes());
645
646 for a_size in [1, 2, 3, 4] {
647 let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
648 a.fill_uniform(base2k, &mut source);
649 let a_digest = a.digest_u64();
650
651 let mut a_dft_ref: VecZnxDft<Vec<u8>, BR> = module_ref.vec_znx_dft_alloc(cols, a_size);
652 let mut a_dft_test: VecZnxDft<Vec<u8>, BT> = module_test.vec_znx_dft_alloc(cols, a_size);
653
654 for j in 0..cols {
655 module_ref.vec_znx_dft_apply(1, 0, &mut a_dft_ref, j, &a, j);
656 module_test.vec_znx_dft_apply(1, 0, &mut a_dft_test, j, &a, j);
657 }
658
659 assert_eq!(a.digest_u64(), a_digest);
660
661 let a_dft_ref_digest: u64 = a_dft_ref.digest_u64();
662 let a_dft_test_digest: u64 = a_dft_test.digest_u64();
663
664 for b_size in [1, 2, 3, 4] {
665 let mut b: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, b_size);
666 b.fill_uniform(base2k, &mut source);
667 let b_digest: u64 = b.digest_u64();
668
669 let mut b_dft_ref: VecZnxDft<Vec<u8>, BR> = module_ref.vec_znx_dft_alloc(cols, b_size);
670 let mut b_dft_test: VecZnxDft<Vec<u8>, BT> = module_test.vec_znx_dft_alloc(cols, b_size);
671
672 for j in 0..cols {
673 module_ref.vec_znx_dft_apply(1, 0, &mut b_dft_ref, j, &b, j);
674 module_test.vec_znx_dft_apply(1, 0, &mut b_dft_test, j, &b, j);
675 }
676
677 assert_eq!(b.digest_u64(), b_digest);
678
679 let b_dft_ref_digest: u64 = b_dft_ref.digest_u64();
680 let b_dft_test_digest: u64 = b_dft_test.digest_u64();
681
682 for res_size in [1, 2, 3, 4] {
683 let mut res_dft_ref: VecZnxDft<Vec<u8>, BR> = module_ref.vec_znx_dft_alloc(cols, res_size);
684 let mut res_dft_test: VecZnxDft<Vec<u8>, BT> = module_test.vec_znx_dft_alloc(cols, res_size);
685
686 // Set d to garbage
687 source.fill_bytes(res_dft_ref.data_mut());
688 source.fill_bytes(res_dft_test.data_mut());
689
690 // Reference
691 for i in 0..cols {
692 module_ref.vec_znx_dft_sub(&mut res_dft_ref, i, &a_dft_ref, i, &b_dft_ref, i);
693 module_test.vec_znx_dft_sub(&mut res_dft_test, i, &a_dft_test, i, &b_dft_test, i);
694 }
695
696 assert_eq!(a_dft_ref.digest_u64(), a_dft_ref_digest);
697 assert_eq!(a_dft_test.digest_u64(), a_dft_test_digest);
698 assert_eq!(b_dft_ref.digest_u64(), b_dft_ref_digest);
699 assert_eq!(b_dft_test.digest_u64(), b_dft_test_digest);
700
701 let res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_idft_apply_consume(res_dft_ref);
702 let res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_idft_apply_consume(res_dft_test);
703
704 let mut res_small_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
705 let mut res_small_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
706
707 let res_ref_digest: u64 = res_big_ref.digest_u64();
708 let res_test_digest: u64 = res_big_test.digest_u64();
709
710 for j in 0..cols {
711 module_ref.vec_znx_big_normalize(
712 base2k,
713 &mut res_small_ref,
714 j,
715 base2k,
716 &res_big_ref,
717 j,
718 scratch_ref.borrow(),
719 );
720 module_test.vec_znx_big_normalize(
721 base2k,
722 &mut res_small_test,
723 j,
724 base2k,
725 &res_big_test,
726 j,
727 scratch_test.borrow(),
728 );
729 }
730
731 assert_eq!(res_big_ref.digest_u64(), res_ref_digest);
732 assert_eq!(res_big_test.digest_u64(), res_test_digest);
733
734 assert_eq!(res_small_ref, res_small_test);
735 }
736 }
737 }
738}
739
740pub fn test_vec_znx_dft_sub_inplace<BR: Backend, BT: Backend>(base2k: usize, module_ref: &Module<BR>, module_test: &Module<BT>)
741where
742 Module<BR>: VecZnxDftSubInplace<BR>
743 + VecZnxDftAlloc<BR>
744 + VecZnxDftApply<BR>
745 + VecZnxIdftApplyConsume<BR>
746 + VecZnxBigNormalize<BR>
747 + VecZnxBigNormalizeTmpBytes,
748 Module<BT>: VecZnxDftSubInplace<BT>
749 + VecZnxDftAlloc<BT>
750 + VecZnxDftApply<BT>
751 + VecZnxIdftApplyConsume<BT>
752 + VecZnxBigNormalize<BT>
753 + VecZnxBigNormalizeTmpBytes,
754 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
755 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
756{
757 assert_eq!(module_ref.n(), module_test.n());
758 let n: usize = module_ref.n();
759
760 let mut source: Source = Source::new([0u8; 32]);
761 let cols: usize = 2;
762
763 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(module_ref.vec_znx_big_normalize_tmp_bytes());
764 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(module_test.vec_znx_big_normalize_tmp_bytes());
765 for a_size in [1, 2, 3, 4] {
766 let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
767 a.fill_uniform(base2k, &mut source);
768 let a_digest = a.digest_u64();
769
770 let mut a_dft_ref: VecZnxDft<Vec<u8>, BR> = module_ref.vec_znx_dft_alloc(cols, a_size);
771 let mut a_dft_test: VecZnxDft<Vec<u8>, BT> = module_test.vec_znx_dft_alloc(cols, a_size);
772
773 for j in 0..cols {
774 module_ref.vec_znx_dft_apply(1, 0, &mut a_dft_ref, j, &a, j);
775 module_test.vec_znx_dft_apply(1, 0, &mut a_dft_test, j, &a, j);
776 }
777
778 assert_eq!(a.digest_u64(), a_digest);
779
780 let a_dft_ref_digest: u64 = a_dft_ref.digest_u64();
781 let a_dft_test_digest: u64 = a_dft_test.digest_u64();
782
783 for res_size in [1, 2, 3, 4] {
784 let mut res: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
785 res.fill_uniform(base2k, &mut source);
786 let res_digest: u64 = res.digest_u64();
787
788 let mut res_dft_ref: VecZnxDft<Vec<u8>, BR> = module_ref.vec_znx_dft_alloc(cols, res_size);
789 let mut res_dft_test: VecZnxDft<Vec<u8>, BT> = module_test.vec_znx_dft_alloc(cols, res_size);
790
791 for j in 0..cols {
792 module_ref.vec_znx_dft_apply(1, 0, &mut res_dft_ref, j, &res, j);
793 module_test.vec_znx_dft_apply(1, 0, &mut res_dft_test, j, &res, j);
794 }
795
796 assert_eq!(res.digest_u64(), res_digest);
797
798 // Reference
799 for i in 0..cols {
800 module_ref.vec_znx_dft_sub_inplace(&mut res_dft_ref, i, &a_dft_ref, i);
801 module_test.vec_znx_dft_sub_inplace(&mut res_dft_test, i, &a_dft_test, i);
802 }
803
804 assert_eq!(a_dft_ref.digest_u64(), a_dft_ref_digest);
805 assert_eq!(a_dft_test.digest_u64(), a_dft_test_digest);
806
807 let res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_idft_apply_consume(res_dft_ref);
808 let res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_idft_apply_consume(res_dft_test);
809
810 let mut res_small_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
811 let mut res_small_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
812
813 let res_ref_digest: u64 = res_big_ref.digest_u64();
814 let res_test_digest: u64 = res_big_test.digest_u64();
815
816 for j in 0..cols {
817 module_ref.vec_znx_big_normalize(
818 base2k,
819 &mut res_small_ref,
820 j,
821 base2k,
822 &res_big_ref,
823 j,
824 scratch_ref.borrow(),
825 );
826 module_test.vec_znx_big_normalize(
827 base2k,
828 &mut res_small_test,
829 j,
830 base2k,
831 &res_big_test,
832 j,
833 scratch_test.borrow(),
834 );
835 }
836
837 assert_eq!(res_big_ref.digest_u64(), res_ref_digest);
838 assert_eq!(res_big_test.digest_u64(), res_test_digest);
839
840 assert_eq!(res_small_ref, res_small_test);
841 }
842 }
843}
844
845pub fn test_vec_znx_dft_sub_negate_inplace<BR: Backend, BT: Backend>(
846 base2k: usize,
847 module_ref: &Module<BR>,
848 module_test: &Module<BT>,
849) where
850 Module<BR>: VecZnxDftSubNegateInplace<BR>
851 + VecZnxDftAlloc<BR>
852 + VecZnxDftApply<BR>
853 + VecZnxIdftApplyConsume<BR>
854 + VecZnxBigNormalize<BR>
855 + VecZnxBigNormalizeTmpBytes,
856 Module<BT>: VecZnxDftSubNegateInplace<BT>
857 + VecZnxDftAlloc<BT>
858 + VecZnxDftApply<BT>
859 + VecZnxIdftApplyConsume<BT>
860 + VecZnxBigNormalize<BT>
861 + VecZnxBigNormalizeTmpBytes,
862 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
863 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
864{
865 assert_eq!(module_ref.n(), module_test.n());
866 let n: usize = module_ref.n();
867
868 let mut source: Source = Source::new([0u8; 32]);
869 let cols: usize = 2;
870
871 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(module_ref.vec_znx_big_normalize_tmp_bytes());
872 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(module_test.vec_znx_big_normalize_tmp_bytes());
873 for a_size in [1, 2, 3, 4] {
874 let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
875 a.fill_uniform(base2k, &mut source);
876 let a_digest = a.digest_u64();
877
878 let mut a_dft_ref: VecZnxDft<Vec<u8>, BR> = module_ref.vec_znx_dft_alloc(cols, a_size);
879 let mut a_dft_test: VecZnxDft<Vec<u8>, BT> = module_test.vec_znx_dft_alloc(cols, a_size);
880
881 for j in 0..cols {
882 module_ref.vec_znx_dft_apply(1, 0, &mut a_dft_ref, j, &a, j);
883 module_test.vec_znx_dft_apply(1, 0, &mut a_dft_test, j, &a, j);
884 }
885
886 assert_eq!(a.digest_u64(), a_digest);
887
888 let a_dft_ref_digest: u64 = a_dft_ref.digest_u64();
889 let a_dft_test_digest: u64 = a_dft_test.digest_u64();
890
891 for res_size in [1, 2, 3, 4] {
892 let mut res: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
893 res.fill_uniform(base2k, &mut source);
894 let res_digest: u64 = res.digest_u64();
895
896 let mut res_dft_ref: VecZnxDft<Vec<u8>, BR> = module_ref.vec_znx_dft_alloc(cols, res_size);
897 let mut res_dft_test: VecZnxDft<Vec<u8>, BT> = module_test.vec_znx_dft_alloc(cols, res_size);
898
899 for j in 0..cols {
900 module_ref.vec_znx_dft_apply(1, 0, &mut res_dft_ref, j, &res, j);
901 module_test.vec_znx_dft_apply(1, 0, &mut res_dft_test, j, &res, j);
902 }
903
904 assert_eq!(res.digest_u64(), res_digest);
905
906 // Reference
907 for i in 0..cols {
908 module_ref.vec_znx_dft_sub_negate_inplace(&mut res_dft_ref, i, &a_dft_ref, i);
909 module_test.vec_znx_dft_sub_negate_inplace(&mut res_dft_test, i, &a_dft_test, i);
910 }
911
912 assert_eq!(a_dft_ref.digest_u64(), a_dft_ref_digest);
913 assert_eq!(a_dft_test.digest_u64(), a_dft_test_digest);
914
915 let res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_idft_apply_consume(res_dft_ref);
916 let res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_idft_apply_consume(res_dft_test);
917
918 let mut res_small_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
919 let mut res_small_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
920
921 let res_ref_digest: u64 = res_big_ref.digest_u64();
922 let res_test_digest: u64 = res_big_test.digest_u64();
923
924 for j in 0..cols {
925 module_ref.vec_znx_big_normalize(
926 base2k,
927 &mut res_small_ref,
928 j,
929 base2k,
930 &res_big_ref,
931 j,
932 scratch_ref.borrow(),
933 );
934 module_test.vec_znx_big_normalize(
935 base2k,
936 &mut res_small_test,
937 j,
938 base2k,
939 &res_big_test,
940 j,
941 scratch_test.borrow(),
942 );
943 }
944
945 assert_eq!(res_big_ref.digest_u64(), res_ref_digest);
946 assert_eq!(res_big_test.digest_u64(), res_test_digest);
947
948 assert_eq!(res_small_ref, res_small_test);
949 }
950 }
951}