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