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