poulpy/poulpy-hal/src/test_suite/vec_znx_big.rs
poulpy-hal/src/test_suite/vec_znx_big.rsRaw
1use rand::RngCore;
2
3use crate::{
4 api::{
5 ScratchOwnedAlloc, ScratchOwnedBorrow, VecZnxBigAdd, VecZnxBigAddInplace, VecZnxBigAddSmall, VecZnxBigAddSmallInplace,
6 VecZnxBigAlloc, VecZnxBigAutomorphism, VecZnxBigAutomorphismInplace, VecZnxBigAutomorphismInplaceTmpBytes,
7 VecZnxBigFromSmall, VecZnxBigNegate, VecZnxBigNegateInplace, VecZnxBigNormalize, VecZnxBigNormalizeTmpBytes,
8 VecZnxBigSub, VecZnxBigSubInplace, VecZnxBigSubNegateInplace, VecZnxBigSubSmallA, VecZnxBigSubSmallB,
9 VecZnxBigSubSmallInplace, VecZnxBigSubSmallNegateInplace,
10 },
11 layouts::{Backend, DataViewMut, DigestU64, FillUniform, Module, ScratchOwned, VecZnx, VecZnxBig},
12 source::Source,
13};
14
15pub fn test_vec_znx_big_add<BR: Backend, BT: Backend>(base2k: usize, module_ref: &Module<BR>, module_test: &Module<BT>)
16where
17 Module<BR>:
18 VecZnxBigAdd<BR> + VecZnxBigAlloc<BR> + VecZnxBigFromSmall<BR> + VecZnxBigNormalize<BR> + VecZnxBigNormalizeTmpBytes,
19 Module<BT>:
20 VecZnxBigAdd<BT> + VecZnxBigAlloc<BT> + VecZnxBigFromSmall<BT> + VecZnxBigNormalize<BT> + VecZnxBigNormalizeTmpBytes,
21 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
22 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
23{
24 assert_eq!(module_ref.n(), module_test.n());
25 let n: usize = module_ref.n();
26
27 let mut source: Source = Source::new([0u8; 32]);
28 let cols: usize = 2;
29
30 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(module_ref.vec_znx_big_normalize_tmp_bytes());
31 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(module_test.vec_znx_big_normalize_tmp_bytes());
32
33 for a_size in [1, 2, 3, 4] {
34 let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
35 a.fill_uniform(base2k, &mut source);
36 let a_digest = a.digest_u64();
37
38 let mut a_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, a_size);
39 let mut a_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, a_size);
40
41 for j in 0..cols {
42 module_ref.vec_znx_big_from_small(&mut a_ref, j, &a, j);
43 module_test.vec_znx_big_from_small(&mut a_test, j, &a, j);
44 }
45
46 assert_eq!(a.digest_u64(), a_digest);
47
48 let a_ref_digest: u64 = a_ref.digest_u64();
49 let a_test_digest: u64 = a_test.digest_u64();
50
51 for b_size in [1, 2, 3, 4] {
52 let mut b: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, b_size);
53 b.fill_uniform(base2k, &mut source);
54 let b_digest = b.digest_u64();
55
56 let mut b_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, b_size);
57 let mut b_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, b_size);
58
59 for j in 0..cols {
60 module_ref.vec_znx_big_from_small(&mut b_ref, j, &b, j);
61 module_test.vec_znx_big_from_small(&mut b_test, j, &b, j);
62 }
63
64 assert_eq!(b.digest_u64(), b_digest);
65
66 let b_ref_digest: u64 = b_ref.digest_u64();
67 let b_test_digest: u64 = b_test.digest_u64();
68
69 for res_size in [1, 2, 3, 4] {
70 let mut res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, res_size);
71 let mut res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, res_size);
72
73 // Set res to garbage
74 source.fill_bytes(res_big_ref.data_mut());
75 source.fill_bytes(res_big_test.data_mut());
76
77 // Reference
78 for i in 0..cols {
79 module_ref.vec_znx_big_add(&mut res_big_ref, i, &a_ref, i, &b_ref, i);
80 module_test.vec_znx_big_add(&mut res_big_test, i, &a_test, i, &b_test, i);
81 }
82
83 assert_eq!(a_ref.digest_u64(), a_ref_digest);
84 assert_eq!(a_test.digest_u64(), a_test_digest);
85 assert_eq!(b_ref.digest_u64(), b_ref_digest);
86 assert_eq!(b_test.digest_u64(), b_test_digest);
87
88 let mut res_small_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
89 let mut res_small_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
90
91 let res_ref_digest: u64 = res_big_ref.digest_u64();
92 let res_test_digest: u64 = res_big_test.digest_u64();
93
94 for j in 0..cols {
95 module_ref.vec_znx_big_normalize(
96 base2k,
97 &mut res_small_ref,
98 j,
99 base2k,
100 &res_big_ref,
101 j,
102 scratch_ref.borrow(),
103 );
104 module_test.vec_znx_big_normalize(
105 base2k,
106 &mut res_small_test,
107 j,
108 base2k,
109 &res_big_test,
110 j,
111 scratch_test.borrow(),
112 );
113 }
114
115 assert_eq!(res_big_ref.digest_u64(), res_ref_digest);
116 assert_eq!(res_big_test.digest_u64(), res_test_digest);
117
118 assert_eq!(res_small_ref, res_small_test);
119 }
120 }
121 }
122}
123
124pub fn test_vec_znx_big_add_inplace<BR: Backend, BT: Backend>(base2k: usize, module_ref: &Module<BR>, module_test: &Module<BT>)
125where
126 Module<BR>: VecZnxBigAddInplace<BR>
127 + VecZnxBigAlloc<BR>
128 + VecZnxBigFromSmall<BR>
129 + VecZnxBigNormalize<BR>
130 + VecZnxBigNormalizeTmpBytes,
131 Module<BT>: VecZnxBigAddInplace<BT>
132 + VecZnxBigAlloc<BT>
133 + VecZnxBigFromSmall<BT>
134 + VecZnxBigNormalize<BT>
135 + VecZnxBigNormalizeTmpBytes,
136 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
137 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
138{
139 assert_eq!(module_ref.n(), module_test.n());
140 let n: usize = module_ref.n();
141
142 let mut source: Source = Source::new([0u8; 32]);
143 let cols: usize = 2;
144
145 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(module_ref.vec_znx_big_normalize_tmp_bytes());
146 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(module_test.vec_znx_big_normalize_tmp_bytes());
147
148 for a_size in [1, 2, 3, 4] {
149 let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
150 a.fill_uniform(base2k, &mut source);
151
152 let mut a_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, a_size);
153 let mut a_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, a_size);
154
155 for j in 0..cols {
156 module_ref.vec_znx_big_from_small(&mut a_ref, j, &a, j);
157 module_test.vec_znx_big_from_small(&mut a_test, j, &a, j);
158 }
159
160 let a_ref_digest: u64 = a_ref.digest_u64();
161 let a_test_digest: u64 = a_test.digest_u64();
162
163 for res_size in [1, 2, 3, 4] {
164 let mut res: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
165 res.fill_uniform(base2k, &mut source);
166
167 let mut res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, res_size);
168 let mut res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, res_size);
169
170 for j in 0..cols {
171 module_ref.vec_znx_big_from_small(&mut res_big_ref, j, &res, j);
172 module_test.vec_znx_big_from_small(&mut res_big_test, j, &res, j);
173 }
174
175 for i in 0..cols {
176 module_ref.vec_znx_big_add_inplace(&mut res_big_ref, i, &a_ref, i);
177 module_test.vec_znx_big_add_inplace(&mut res_big_test, i, &a_test, i);
178 }
179
180 assert_eq!(a_ref.digest_u64(), a_ref_digest);
181 assert_eq!(a_test.digest_u64(), a_test_digest);
182
183 let mut res_small_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
184 let mut res_small_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
185
186 let res_ref_digest: u64 = res_big_ref.digest_u64();
187 let res_test_digest: u64 = res_big_test.digest_u64();
188
189 for j in 0..cols {
190 module_ref.vec_znx_big_normalize(
191 base2k,
192 &mut res_small_ref,
193 j,
194 base2k,
195 &res_big_ref,
196 j,
197 scratch_ref.borrow(),
198 );
199 module_test.vec_znx_big_normalize(
200 base2k,
201 &mut res_small_test,
202 j,
203 base2k,
204 &res_big_test,
205 j,
206 scratch_test.borrow(),
207 );
208 }
209
210 assert_eq!(res_big_ref.digest_u64(), res_ref_digest);
211 assert_eq!(res_big_test.digest_u64(), res_test_digest);
212
213 assert_eq!(res_small_ref, res_small_test);
214 }
215 }
216}
217
218pub fn test_vec_znx_big_add_small<BR: Backend, BT: Backend>(base2k: usize, module_ref: &Module<BR>, module_test: &Module<BT>)
219where
220 Module<BR>:
221 VecZnxBigAddSmall<BR> + VecZnxBigAlloc<BR> + VecZnxBigFromSmall<BR> + VecZnxBigNormalize<BR> + VecZnxBigNormalizeTmpBytes,
222 Module<BT>:
223 VecZnxBigAddSmall<BT> + VecZnxBigAlloc<BT> + VecZnxBigFromSmall<BT> + VecZnxBigNormalize<BT> + VecZnxBigNormalizeTmpBytes,
224 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
225 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
226{
227 assert_eq!(module_ref.n(), module_test.n());
228 let n: usize = module_ref.n();
229
230 let mut source: Source = Source::new([0u8; 32]);
231 let cols: usize = 2;
232
233 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(module_ref.vec_znx_big_normalize_tmp_bytes());
234 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(module_test.vec_znx_big_normalize_tmp_bytes());
235
236 for a_size in [1, 2, 3, 4] {
237 let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
238 a.fill_uniform(base2k, &mut source);
239
240 let mut a_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, a_size);
241 let mut a_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, a_size);
242
243 for j in 0..cols {
244 module_ref.vec_znx_big_from_small(&mut a_ref, j, &a, j);
245 module_test.vec_znx_big_from_small(&mut a_test, j, &a, j);
246 }
247
248 let a_ref_digest: u64 = a_ref.digest_u64();
249 let a_test_digest: u64 = a_test.digest_u64();
250
251 for b_size in [1, 2, 3, 4] {
252 let mut b: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, b_size);
253 b.fill_uniform(base2k, &mut source);
254 let b_digest: u64 = b.digest_u64();
255
256 for res_size in [1, 2, 3, 4] {
257 let mut res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, res_size);
258 let mut res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, res_size);
259
260 // Set res to garbage
261 source.fill_bytes(res_big_ref.data_mut());
262 source.fill_bytes(res_big_test.data_mut());
263
264 // Reference
265 for i in 0..cols {
266 module_ref.vec_znx_big_add_small(&mut res_big_ref, i, &a_ref, i, &b, i);
267 module_test.vec_znx_big_add_small(&mut res_big_test, i, &a_test, i, &b, i);
268 }
269
270 assert_eq!(a_ref.digest_u64(), a_ref_digest);
271 assert_eq!(a_test.digest_u64(), a_test_digest);
272 assert_eq!(b.digest_u64(), b_digest);
273
274 let mut res_small_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
275 let mut res_small_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
276
277 let res_ref_digest: u64 = res_big_ref.digest_u64();
278 let res_test_digest: u64 = res_big_test.digest_u64();
279
280 for j in 0..cols {
281 module_ref.vec_znx_big_normalize(
282 base2k,
283 &mut res_small_ref,
284 j,
285 base2k,
286 &res_big_ref,
287 j,
288 scratch_ref.borrow(),
289 );
290 module_test.vec_znx_big_normalize(
291 base2k,
292 &mut res_small_test,
293 j,
294 base2k,
295 &res_big_test,
296 j,
297 scratch_test.borrow(),
298 );
299 }
300
301 assert_eq!(res_big_ref.digest_u64(), res_ref_digest);
302 assert_eq!(res_big_test.digest_u64(), res_test_digest);
303
304 assert_eq!(res_small_ref, res_small_test);
305 }
306 }
307 }
308}
309
310pub fn test_vec_znx_big_add_small_inplace<BR: Backend, BT: Backend>(
311 base2k: usize,
312 module_ref: &Module<BR>,
313 module_test: &Module<BT>,
314) where
315 Module<BR>: VecZnxBigAddSmallInplace<BR>
316 + VecZnxBigAlloc<BR>
317 + VecZnxBigFromSmall<BR>
318 + VecZnxBigNormalize<BR>
319 + VecZnxBigNormalizeTmpBytes,
320 Module<BT>: VecZnxBigAddSmallInplace<BT>
321 + VecZnxBigAlloc<BT>
322 + VecZnxBigFromSmall<BT>
323 + VecZnxBigNormalize<BT>
324 + VecZnxBigNormalizeTmpBytes,
325 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
326 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
327{
328 assert_eq!(module_ref.n(), module_test.n());
329 let n: usize = module_ref.n();
330
331 let mut source: Source = Source::new([0u8; 32]);
332 let cols: usize = 2;
333
334 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(module_ref.vec_znx_big_normalize_tmp_bytes());
335 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(module_test.vec_znx_big_normalize_tmp_bytes());
336
337 for a_size in [1, 2, 3, 4] {
338 let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
339 a.fill_uniform(base2k, &mut source);
340
341 let a_digest: u64 = a.digest_u64();
342
343 for res_size in [1, 2, 3, 4] {
344 let mut res: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
345 res.fill_uniform(base2k, &mut source);
346
347 let mut res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, res_size);
348 let mut res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, res_size);
349
350 for j in 0..cols {
351 module_ref.vec_znx_big_from_small(&mut res_big_ref, j, &res, j);
352 module_test.vec_znx_big_from_small(&mut res_big_test, j, &res, j);
353 }
354
355 for i in 0..cols {
356 module_ref.vec_znx_big_add_small_inplace(&mut res_big_ref, i, &a, i);
357 module_test.vec_znx_big_add_small_inplace(&mut res_big_test, i, &a, i);
358 }
359
360 assert_eq!(a.digest_u64(), a_digest);
361
362 let mut res_small_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
363 let mut res_small_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
364
365 let res_ref_digest: u64 = res_big_ref.digest_u64();
366 let res_test_digest: u64 = res_big_test.digest_u64();
367
368 for j in 0..cols {
369 module_ref.vec_znx_big_normalize(
370 base2k,
371 &mut res_small_ref,
372 j,
373 base2k,
374 &res_big_ref,
375 j,
376 scratch_ref.borrow(),
377 );
378 module_test.vec_znx_big_normalize(
379 base2k,
380 &mut res_small_test,
381 j,
382 base2k,
383 &res_big_test,
384 j,
385 scratch_test.borrow(),
386 );
387 }
388
389 assert_eq!(res_big_ref.digest_u64(), res_ref_digest);
390 assert_eq!(res_big_test.digest_u64(), res_test_digest);
391
392 assert_eq!(res_small_ref, res_small_test);
393 }
394 }
395}
396
397pub fn test_vec_znx_big_automorphism<BR: Backend, BT: Backend>(base2k: usize, module_ref: &Module<BR>, module_test: &Module<BT>)
398where
399 Module<BR>: VecZnxBigAutomorphism<BR>
400 + VecZnxBigAlloc<BR>
401 + VecZnxBigFromSmall<BR>
402 + VecZnxBigNormalize<BR>
403 + VecZnxBigNormalizeTmpBytes,
404 Module<BT>: VecZnxBigAutomorphism<BT>
405 + VecZnxBigAlloc<BT>
406 + VecZnxBigFromSmall<BT>
407 + VecZnxBigNormalize<BT>
408 + VecZnxBigNormalizeTmpBytes,
409 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
410 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
411{
412 assert_eq!(module_ref.n(), module_test.n());
413 let n: usize = module_ref.n();
414
415 let mut source: Source = Source::new([0u8; 32]);
416 let cols: usize = 2;
417
418 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(module_ref.vec_znx_big_normalize_tmp_bytes());
419 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(module_test.vec_znx_big_normalize_tmp_bytes());
420
421 for a_size in [1, 2, 3, 4] {
422 let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
423 a.fill_uniform(base2k, &mut source);
424
425 let mut a_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, a_size);
426 let mut a_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, a_size);
427
428 for j in 0..cols {
429 module_ref.vec_znx_big_from_small(&mut a_ref, j, &a, j);
430 module_test.vec_znx_big_from_small(&mut a_test, j, &a, j);
431 }
432
433 let a_ref_digest: u64 = a_ref.digest_u64();
434 let a_test_digest: u64 = a_test.digest_u64();
435
436 for res_size in [1, 2, 3, 4] {
437 for p in [-5, 5] {
438 let mut res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, res_size);
439 let mut res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, res_size);
440
441 // Set res to garbage
442 source.fill_bytes(res_big_ref.data_mut());
443 source.fill_bytes(res_big_test.data_mut());
444
445 // Reference
446 for i in 0..cols {
447 module_ref.vec_znx_big_automorphism(p, &mut res_big_ref, i, &a_ref, i);
448 module_test.vec_znx_big_automorphism(p, &mut res_big_test, i, &a_test, i);
449 }
450
451 assert_eq!(a_ref.digest_u64(), a_ref_digest);
452 assert_eq!(a_test.digest_u64(), a_test_digest);
453
454 let mut res_small_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
455 let mut res_small_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
456
457 let res_ref_digest: u64 = res_big_ref.digest_u64();
458 let res_test_digest: u64 = res_big_test.digest_u64();
459
460 for j in 0..cols {
461 module_ref.vec_znx_big_normalize(
462 base2k,
463 &mut res_small_ref,
464 j,
465 base2k,
466 &res_big_ref,
467 j,
468 scratch_ref.borrow(),
469 );
470 module_test.vec_znx_big_normalize(
471 base2k,
472 &mut res_small_test,
473 j,
474 base2k,
475 &res_big_test,
476 j,
477 scratch_test.borrow(),
478 );
479 }
480
481 assert_eq!(res_big_ref.digest_u64(), res_ref_digest);
482 assert_eq!(res_big_test.digest_u64(), res_test_digest);
483
484 assert_eq!(res_small_ref, res_small_test);
485 }
486 }
487 }
488}
489
490pub fn test_vec_znx_big_automorphism_inplace<BR: Backend, BT: Backend>(
491 base2k: usize,
492 module_ref: &Module<BR>,
493 module_test: &Module<BT>,
494) where
495 Module<BR>: VecZnxBigAutomorphismInplace<BR>
496 + VecZnxBigAlloc<BR>
497 + VecZnxBigFromSmall<BR>
498 + VecZnxBigAutomorphismInplaceTmpBytes
499 + VecZnxBigNormalize<BR>
500 + VecZnxBigNormalizeTmpBytes,
501 Module<BT>: VecZnxBigAutomorphismInplace<BT>
502 + VecZnxBigAlloc<BT>
503 + VecZnxBigFromSmall<BT>
504 + VecZnxBigAutomorphismInplaceTmpBytes
505 + VecZnxBigNormalize<BT>
506 + VecZnxBigNormalizeTmpBytes,
507 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
508 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
509{
510 assert_eq!(module_ref.n(), module_test.n());
511 let n: usize = module_ref.n();
512
513 let mut source: Source = Source::new([0u8; 32]);
514 let cols: usize = 2;
515
516 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(
517 module_ref.vec_znx_big_automorphism_inplace_tmp_bytes() | module_ref.vec_znx_big_normalize_tmp_bytes(),
518 );
519 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(
520 module_test.vec_znx_big_automorphism_inplace_tmp_bytes() | module_test.vec_znx_big_normalize_tmp_bytes(),
521 );
522
523 for res_size in [1, 2, 3, 4] {
524 let mut res: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
525 res.fill_uniform(base2k, &mut source);
526
527 let mut res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, res_size);
528 let mut res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, res_size);
529
530 for p in [-5, 5] {
531 for j in 0..cols {
532 module_ref.vec_znx_big_from_small(&mut res_big_ref, j, &res, j);
533 module_test.vec_znx_big_from_small(&mut res_big_test, j, &res, j);
534 }
535
536 for i in 0..cols {
537 module_ref.vec_znx_big_automorphism_inplace(p, &mut res_big_ref, i, scratch_ref.borrow());
538 module_test.vec_znx_big_automorphism_inplace(p, &mut res_big_test, i, scratch_test.borrow());
539 }
540
541 let mut res_small_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
542 let mut res_small_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
543
544 let res_ref_digest: u64 = res_big_ref.digest_u64();
545 let res_test_digest: u64 = res_big_test.digest_u64();
546
547 for j in 0..cols {
548 module_ref.vec_znx_big_normalize(
549 base2k,
550 &mut res_small_ref,
551 j,
552 base2k,
553 &res_big_ref,
554 j,
555 scratch_ref.borrow(),
556 );
557 module_test.vec_znx_big_normalize(
558 base2k,
559 &mut res_small_test,
560 j,
561 base2k,
562 &res_big_test,
563 j,
564 scratch_test.borrow(),
565 );
566 }
567
568 assert_eq!(res_big_ref.digest_u64(), res_ref_digest);
569 assert_eq!(res_big_test.digest_u64(), res_test_digest);
570
571 assert_eq!(res_small_ref, res_small_test);
572 }
573 }
574}
575
576pub fn test_vec_znx_big_negate<BR: Backend, BT: Backend>(base2k: usize, module_ref: &Module<BR>, module_test: &Module<BT>)
577where
578 Module<BR>:
579 VecZnxBigNegate<BR> + VecZnxBigAlloc<BR> + VecZnxBigFromSmall<BR> + VecZnxBigNormalize<BR> + VecZnxBigNormalizeTmpBytes,
580 Module<BT>:
581 VecZnxBigNegate<BT> + VecZnxBigAlloc<BT> + VecZnxBigFromSmall<BT> + VecZnxBigNormalize<BT> + VecZnxBigNormalizeTmpBytes,
582 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
583 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
584{
585 assert_eq!(module_ref.n(), module_test.n());
586 let n: usize = module_ref.n();
587
588 let mut source: Source = Source::new([0u8; 32]);
589 let cols: usize = 2;
590
591 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(module_ref.vec_znx_big_normalize_tmp_bytes());
592 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(module_test.vec_znx_big_normalize_tmp_bytes());
593
594 for a_size in [1, 2, 3, 4] {
595 let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
596 a.fill_uniform(base2k, &mut source);
597
598 let mut a_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, a_size);
599 let mut a_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, a_size);
600
601 for j in 0..cols {
602 module_ref.vec_znx_big_from_small(&mut a_ref, j, &a, j);
603 module_test.vec_znx_big_from_small(&mut a_test, j, &a, j);
604 }
605
606 let a_ref_digest: u64 = a_ref.digest_u64();
607 let a_test_digest: u64 = a_test.digest_u64();
608
609 for res_size in [1, 2, 3, 4] {
610 let mut res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, res_size);
611 let mut res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, res_size);
612
613 // Set res to garbage
614 source.fill_bytes(res_big_ref.data_mut());
615 source.fill_bytes(res_big_test.data_mut());
616
617 // Reference
618 for i in 0..cols {
619 module_ref.vec_znx_big_negate(&mut res_big_ref, i, &a_ref, i);
620 module_test.vec_znx_big_negate(&mut res_big_test, i, &a_test, i);
621 }
622
623 assert_eq!(a_ref.digest_u64(), a_ref_digest);
624 assert_eq!(a_test.digest_u64(), a_test_digest);
625
626 let mut res_small_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
627 let mut res_small_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
628
629 let res_ref_digest: u64 = res_big_ref.digest_u64();
630 let res_test_digest: u64 = res_big_test.digest_u64();
631
632 for j in 0..cols {
633 module_ref.vec_znx_big_normalize(
634 base2k,
635 &mut res_small_ref,
636 j,
637 base2k,
638 &res_big_ref,
639 j,
640 scratch_ref.borrow(),
641 );
642 module_test.vec_znx_big_normalize(
643 base2k,
644 &mut res_small_test,
645 j,
646 base2k,
647 &res_big_test,
648 j,
649 scratch_test.borrow(),
650 );
651 }
652
653 assert_eq!(res_big_ref.digest_u64(), res_ref_digest);
654 assert_eq!(res_big_test.digest_u64(), res_test_digest);
655
656 assert_eq!(res_small_ref, res_small_test);
657 }
658 }
659}
660
661pub fn test_vec_znx_big_negate_inplace<BR: Backend, BT: Backend>(base2k: usize, module_ref: &Module<BR>, module_test: &Module<BT>)
662where
663 Module<BR>: VecZnxBigNegateInplace<BR>
664 + VecZnxBigAlloc<BR>
665 + VecZnxBigFromSmall<BR>
666 + VecZnxBigAutomorphismInplaceTmpBytes
667 + VecZnxBigNormalize<BR>
668 + VecZnxBigNormalizeTmpBytes,
669 Module<BT>: VecZnxBigNegateInplace<BT>
670 + VecZnxBigAlloc<BT>
671 + VecZnxBigFromSmall<BT>
672 + VecZnxBigAutomorphismInplaceTmpBytes
673 + VecZnxBigNormalize<BT>
674 + VecZnxBigNormalizeTmpBytes,
675 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
676 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
677{
678 assert_eq!(module_ref.n(), module_test.n());
679 let n: usize = module_ref.n();
680
681 let mut source: Source = Source::new([0u8; 32]);
682 let cols: usize = 2;
683
684 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(module_ref.vec_znx_big_normalize_tmp_bytes());
685 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(module_test.vec_znx_big_normalize_tmp_bytes());
686
687 for res_size in [1, 2, 3, 4] {
688 let mut res: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
689 res.fill_uniform(base2k, &mut source);
690
691 let mut res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, res_size);
692 let mut res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, res_size);
693
694 for j in 0..cols {
695 module_ref.vec_znx_big_from_small(&mut res_big_ref, j, &res, j);
696 module_test.vec_znx_big_from_small(&mut res_big_test, j, &res, j);
697 }
698
699 for i in 0..cols {
700 module_ref.vec_znx_big_negate_inplace(&mut res_big_ref, i);
701 module_test.vec_znx_big_negate_inplace(&mut res_big_test, i);
702 }
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
738pub fn test_vec_znx_big_normalize<BR: Backend, BT: Backend>(base2k: usize, module_ref: &Module<BR>, module_test: &Module<BT>)
739where
740 Module<BR>: VecZnxBigAlloc<BR>
741 + VecZnxBigFromSmall<BR>
742 + VecZnxBigAutomorphismInplaceTmpBytes
743 + VecZnxBigNormalize<BR>
744 + VecZnxBigNormalizeTmpBytes,
745 Module<BT>: VecZnxBigAlloc<BT>
746 + VecZnxBigFromSmall<BT>
747 + VecZnxBigAutomorphismInplaceTmpBytes
748 + VecZnxBigNormalize<BT>
749 + VecZnxBigNormalizeTmpBytes,
750 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
751 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
752{
753 assert_eq!(module_ref.n(), module_test.n());
754 let n: usize = module_ref.n();
755
756 let mut source: Source = Source::new([0u8; 32]);
757 let cols: usize = 2;
758
759 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(
760 module_ref.vec_znx_big_automorphism_inplace_tmp_bytes() | module_ref.vec_znx_big_normalize_tmp_bytes(),
761 );
762 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(
763 module_test.vec_znx_big_automorphism_inplace_tmp_bytes() | module_test.vec_znx_big_normalize_tmp_bytes(),
764 );
765
766 for a_size in [1, 2, 3, 4] {
767 let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
768 a.fill_uniform(63, &mut source);
769
770 let mut a_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, a_size);
771 let mut a_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, a_size);
772
773 for j in 0..cols {
774 module_ref.vec_znx_big_from_small(&mut a_ref, j, &a, j);
775 module_test.vec_znx_big_from_small(&mut a_test, j, &a, j);
776 }
777
778 let a_ref_digest: u64 = a_ref.digest_u64();
779 let a_test_digest: u64 = a_test.digest_u64();
780
781 for res_size in [1, 2, 3, 4] {
782 let mut res_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
783 let mut res_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
784
785 // Set d to garbage
786 source.fill_bytes(res_ref.data_mut());
787 source.fill_bytes(res_test.data_mut());
788
789 // Reference
790 for j in 0..cols {
791 module_ref.vec_znx_big_normalize(
792 base2k,
793 &mut res_ref,
794 j,
795 base2k,
796 &a_ref,
797 j,
798 scratch_ref.borrow(),
799 );
800 module_test.vec_znx_big_normalize(
801 base2k,
802 &mut res_test,
803 j,
804 base2k,
805 &a_test,
806 j,
807 scratch_test.borrow(),
808 );
809 }
810
811 assert_eq!(a_ref.digest_u64(), a_ref_digest);
812 assert_eq!(a_test.digest_u64(), a_test_digest);
813
814 assert_eq!(res_ref, res_test);
815 }
816 }
817}
818
819pub fn test_vec_znx_big_sub<BR: Backend, BT: Backend>(base2k: usize, module_ref: &Module<BR>, module_test: &Module<BT>)
820where
821 Module<BR>:
822 VecZnxBigSub<BR> + VecZnxBigAlloc<BR> + VecZnxBigFromSmall<BR> + VecZnxBigNormalize<BR> + VecZnxBigNormalizeTmpBytes,
823 Module<BT>:
824 VecZnxBigSub<BT> + VecZnxBigAlloc<BT> + VecZnxBigFromSmall<BT> + VecZnxBigNormalize<BT> + VecZnxBigNormalizeTmpBytes,
825 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
826 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
827{
828 assert_eq!(module_ref.n(), module_test.n());
829 let n: usize = module_ref.n();
830
831 let mut source: Source = Source::new([0u8; 32]);
832 let cols: usize = 2;
833
834 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(module_ref.vec_znx_big_normalize_tmp_bytes());
835 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(module_test.vec_znx_big_normalize_tmp_bytes());
836
837 for a_size in [1, 2, 3, 4] {
838 let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
839 a.fill_uniform(base2k, &mut source);
840
841 let mut a_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, a_size);
842 let mut a_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, a_size);
843
844 for j in 0..cols {
845 module_ref.vec_znx_big_from_small(&mut a_ref, j, &a, j);
846 module_test.vec_znx_big_from_small(&mut a_test, j, &a, j);
847 }
848
849 let a_ref_digest: u64 = a_ref.digest_u64();
850 let a_test_digest: u64 = a_test.digest_u64();
851
852 for b_size in [1, 2, 3, 4] {
853 let mut b: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, b_size);
854 b.fill_uniform(base2k, &mut source);
855
856 let mut b_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, b_size);
857 let mut b_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, b_size);
858
859 for j in 0..cols {
860 module_ref.vec_znx_big_from_small(&mut b_ref, j, &b, j);
861 module_test.vec_znx_big_from_small(&mut b_test, j, &b, j);
862 }
863
864 let b_ref_digest: u64 = b_ref.digest_u64();
865 let b_test_digest: u64 = b_test.digest_u64();
866
867 for res_size in [1, 2, 3, 4] {
868 let mut res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, res_size);
869 let mut res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, res_size);
870
871 // Set res to garbage
872 source.fill_bytes(res_big_ref.data_mut());
873 source.fill_bytes(res_big_test.data_mut());
874
875 // Reference
876 for i in 0..cols {
877 module_ref.vec_znx_big_sub(&mut res_big_ref, i, &a_ref, i, &b_ref, i);
878 module_test.vec_znx_big_sub(&mut res_big_test, i, &a_test, i, &b_test, i);
879 }
880
881 assert_eq!(a_ref.digest_u64(), a_ref_digest);
882 assert_eq!(a_test.digest_u64(), a_test_digest);
883 assert_eq!(b_ref.digest_u64(), b_ref_digest);
884 assert_eq!(b_test.digest_u64(), b_test_digest);
885
886 let mut res_small_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
887 let mut res_small_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
888
889 let res_ref_digest: u64 = res_big_ref.digest_u64();
890 let res_test_digest: u64 = res_big_test.digest_u64();
891
892 for j in 0..cols {
893 module_ref.vec_znx_big_normalize(
894 base2k,
895 &mut res_small_ref,
896 j,
897 base2k,
898 &res_big_ref,
899 j,
900 scratch_ref.borrow(),
901 );
902 module_test.vec_znx_big_normalize(
903 base2k,
904 &mut res_small_test,
905 j,
906 base2k,
907 &res_big_test,
908 j,
909 scratch_test.borrow(),
910 );
911 }
912
913 assert_eq!(res_big_ref.digest_u64(), res_ref_digest);
914 assert_eq!(res_big_test.digest_u64(), res_test_digest);
915
916 assert_eq!(res_small_ref, res_small_test);
917 }
918 }
919 }
920}
921
922pub fn test_vec_znx_big_sub_inplace<BR: Backend, BT: Backend>(base2k: usize, module_ref: &Module<BR>, module_test: &Module<BT>)
923where
924 Module<BR>: VecZnxBigSubInplace<BR>
925 + VecZnxBigAlloc<BR>
926 + VecZnxBigFromSmall<BR>
927 + VecZnxBigNormalize<BR>
928 + VecZnxBigNormalizeTmpBytes,
929 Module<BT>: VecZnxBigSubInplace<BT>
930 + VecZnxBigAlloc<BT>
931 + VecZnxBigFromSmall<BT>
932 + VecZnxBigNormalize<BT>
933 + VecZnxBigNormalizeTmpBytes,
934 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
935 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
936{
937 assert_eq!(module_ref.n(), module_test.n());
938 let n: usize = module_ref.n();
939
940 let mut source: Source = Source::new([0u8; 32]);
941 let cols: usize = 2;
942
943 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(module_ref.vec_znx_big_normalize_tmp_bytes());
944 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(module_test.vec_znx_big_normalize_tmp_bytes());
945
946 for a_size in [1, 2, 3, 4] {
947 let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
948 a.fill_uniform(base2k, &mut source);
949
950 let mut a_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, a_size);
951 let mut a_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, a_size);
952
953 for j in 0..cols {
954 module_ref.vec_znx_big_from_small(&mut a_ref, j, &a, j);
955 module_test.vec_znx_big_from_small(&mut a_test, j, &a, j);
956 }
957
958 let a_ref_digest: u64 = a_ref.digest_u64();
959 let a_test_digest: u64 = a_test.digest_u64();
960
961 for res_size in [1, 2, 3, 4] {
962 let mut res: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
963 res.fill_uniform(base2k, &mut source);
964
965 let mut res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, res_size);
966 let mut res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, res_size);
967
968 for j in 0..cols {
969 module_ref.vec_znx_big_from_small(&mut res_big_ref, j, &res, j);
970 module_test.vec_znx_big_from_small(&mut res_big_test, j, &res, j);
971 }
972
973 for i in 0..cols {
974 module_ref.vec_znx_big_sub_inplace(&mut res_big_ref, i, &a_ref, i);
975 module_test.vec_znx_big_sub_inplace(&mut res_big_test, i, &a_test, i);
976 }
977
978 assert_eq!(a_ref.digest_u64(), a_ref_digest);
979 assert_eq!(a_test.digest_u64(), a_test_digest);
980
981 let mut res_small_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
982 let mut res_small_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
983
984 let res_ref_digest: u64 = res_big_ref.digest_u64();
985 let res_test_digest: u64 = res_big_test.digest_u64();
986
987 for j in 0..cols {
988 module_ref.vec_znx_big_normalize(
989 base2k,
990 &mut res_small_ref,
991 j,
992 base2k,
993 &res_big_ref,
994 j,
995 scratch_ref.borrow(),
996 );
997 module_test.vec_znx_big_normalize(
998 base2k,
999 &mut res_small_test,
1000 j,
1001 base2k,
1002 &res_big_test,
1003 j,
1004 scratch_test.borrow(),
1005 );
1006 }
1007
1008 assert_eq!(res_big_ref.digest_u64(), res_ref_digest);
1009 assert_eq!(res_big_test.digest_u64(), res_test_digest);
1010
1011 assert_eq!(res_small_ref, res_small_test);
1012 }
1013 }
1014}
1015
1016pub fn test_vec_znx_big_sub_negate_inplace<BR: Backend, BT: Backend>(
1017 base2k: usize,
1018 module_ref: &Module<BR>,
1019 module_test: &Module<BT>,
1020) where
1021 Module<BR>: VecZnxBigSubNegateInplace<BR>
1022 + VecZnxBigAlloc<BR>
1023 + VecZnxBigFromSmall<BR>
1024 + VecZnxBigNormalize<BR>
1025 + VecZnxBigNormalizeTmpBytes,
1026 Module<BT>: VecZnxBigSubNegateInplace<BT>
1027 + VecZnxBigAlloc<BT>
1028 + VecZnxBigFromSmall<BT>
1029 + VecZnxBigNormalize<BT>
1030 + VecZnxBigNormalizeTmpBytes,
1031 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
1032 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
1033{
1034 assert_eq!(module_ref.n(), module_test.n());
1035 let n: usize = module_ref.n();
1036
1037 let mut source: Source = Source::new([0u8; 32]);
1038 let cols: usize = 2;
1039
1040 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(module_ref.vec_znx_big_normalize_tmp_bytes());
1041 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(module_test.vec_znx_big_normalize_tmp_bytes());
1042
1043 for a_size in [1, 2, 3, 4] {
1044 let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
1045 a.fill_uniform(base2k, &mut source);
1046
1047 let mut a_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, a_size);
1048 let mut a_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, a_size);
1049
1050 for j in 0..cols {
1051 module_ref.vec_znx_big_from_small(&mut a_ref, j, &a, j);
1052 module_test.vec_znx_big_from_small(&mut a_test, j, &a, j);
1053 }
1054
1055 let a_ref_digest: u64 = a_ref.digest_u64();
1056 let a_test_digest: u64 = a_test.digest_u64();
1057
1058 for res_size in [1, 2, 3, 4] {
1059 let mut res: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
1060 res.fill_uniform(base2k, &mut source);
1061
1062 let mut res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, res_size);
1063 let mut res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, res_size);
1064
1065 for j in 0..cols {
1066 module_ref.vec_znx_big_from_small(&mut res_big_ref, j, &res, j);
1067 module_test.vec_znx_big_from_small(&mut res_big_test, j, &res, j);
1068 }
1069
1070 for i in 0..cols {
1071 module_ref.vec_znx_big_sub_negate_inplace(&mut res_big_ref, i, &a_ref, i);
1072 module_test.vec_znx_big_sub_negate_inplace(&mut res_big_test, i, &a_test, i);
1073 }
1074
1075 assert_eq!(a_ref.digest_u64(), a_ref_digest);
1076 assert_eq!(a_test.digest_u64(), a_test_digest);
1077
1078 let mut res_small_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
1079 let mut res_small_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
1080
1081 let res_ref_digest: u64 = res_big_ref.digest_u64();
1082 let res_test_digest: u64 = res_big_test.digest_u64();
1083
1084 for j in 0..cols {
1085 module_ref.vec_znx_big_normalize(
1086 base2k,
1087 &mut res_small_ref,
1088 j,
1089 base2k,
1090 &res_big_ref,
1091 j,
1092 scratch_ref.borrow(),
1093 );
1094 module_test.vec_znx_big_normalize(
1095 base2k,
1096 &mut res_small_test,
1097 j,
1098 base2k,
1099 &res_big_test,
1100 j,
1101 scratch_test.borrow(),
1102 );
1103 }
1104
1105 assert_eq!(res_big_ref.digest_u64(), res_ref_digest);
1106 assert_eq!(res_big_test.digest_u64(), res_test_digest);
1107
1108 assert_eq!(res_small_ref, res_small_test);
1109 }
1110 }
1111}
1112
1113pub fn test_vec_znx_big_sub_small_a<BR: Backend, BT: Backend>(base2k: usize, module_ref: &Module<BR>, module_test: &Module<BT>)
1114where
1115 Module<BR>: VecZnxBigSubSmallA<BR>
1116 + VecZnxBigAlloc<BR>
1117 + VecZnxBigFromSmall<BR>
1118 + VecZnxBigNormalize<BR>
1119 + VecZnxBigNormalizeTmpBytes,
1120 Module<BT>: VecZnxBigSubSmallA<BT>
1121 + VecZnxBigAlloc<BT>
1122 + VecZnxBigFromSmall<BT>
1123 + VecZnxBigNormalize<BT>
1124 + VecZnxBigNormalizeTmpBytes,
1125 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
1126 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
1127{
1128 assert_eq!(module_ref.n(), module_test.n());
1129 let n: usize = module_ref.n();
1130
1131 let mut source: Source = Source::new([0u8; 32]);
1132 let cols: usize = 2;
1133
1134 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(module_ref.vec_znx_big_normalize_tmp_bytes());
1135 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(module_test.vec_znx_big_normalize_tmp_bytes());
1136
1137 for a_size in [1, 2, 3, 4] {
1138 let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
1139 a.fill_uniform(base2k, &mut source);
1140
1141 let mut a_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, a_size);
1142 let mut a_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, a_size);
1143
1144 for j in 0..cols {
1145 module_ref.vec_znx_big_from_small(&mut a_ref, j, &a, j);
1146 module_test.vec_znx_big_from_small(&mut a_test, j, &a, j);
1147 }
1148
1149 let a_ref_digest: u64 = a_ref.digest_u64();
1150 let a_test_digest: u64 = a_test.digest_u64();
1151
1152 for b_size in [1, 2, 3, 4] {
1153 let mut b: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, b_size);
1154 b.fill_uniform(base2k, &mut source);
1155 let b_digest: u64 = b.digest_u64();
1156
1157 for res_size in [1, 2, 3, 4] {
1158 let mut res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, res_size);
1159 let mut res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, res_size);
1160
1161 // Set res to garbage
1162 source.fill_bytes(res_big_ref.data_mut());
1163 source.fill_bytes(res_big_test.data_mut());
1164
1165 // Reference
1166 for i in 0..cols {
1167 module_ref.vec_znx_big_sub_small_a(&mut res_big_ref, i, &b, i, &a_ref, i);
1168 module_test.vec_znx_big_sub_small_a(&mut res_big_test, i, &b, i, &a_test, i);
1169 }
1170
1171 assert_eq!(a_ref.digest_u64(), a_ref_digest);
1172 assert_eq!(a_test.digest_u64(), a_test_digest);
1173 assert_eq!(b.digest_u64(), b_digest);
1174
1175 let mut res_small_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
1176 let mut res_small_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
1177
1178 let res_ref_digest: u64 = res_big_ref.digest_u64();
1179 let res_test_digest: u64 = res_big_test.digest_u64();
1180
1181 for j in 0..cols {
1182 module_ref.vec_znx_big_normalize(
1183 base2k,
1184 &mut res_small_ref,
1185 j,
1186 base2k,
1187 &res_big_ref,
1188 j,
1189 scratch_ref.borrow(),
1190 );
1191 module_test.vec_znx_big_normalize(
1192 base2k,
1193 &mut res_small_test,
1194 j,
1195 base2k,
1196 &res_big_test,
1197 j,
1198 scratch_test.borrow(),
1199 );
1200 }
1201
1202 assert_eq!(res_big_ref.digest_u64(), res_ref_digest);
1203 assert_eq!(res_big_test.digest_u64(), res_test_digest);
1204
1205 assert_eq!(res_small_ref, res_small_test);
1206 }
1207 }
1208 }
1209}
1210
1211pub fn test_vec_znx_big_sub_small_b<BR: Backend, BT: Backend>(base2k: usize, module_ref: &Module<BR>, module_test: &Module<BT>)
1212where
1213 Module<BR>: VecZnxBigSubSmallB<BR>
1214 + VecZnxBigAlloc<BR>
1215 + VecZnxBigFromSmall<BR>
1216 + VecZnxBigNormalize<BR>
1217 + VecZnxBigNormalizeTmpBytes,
1218 Module<BT>: VecZnxBigSubSmallB<BT>
1219 + VecZnxBigAlloc<BT>
1220 + VecZnxBigFromSmall<BT>
1221 + VecZnxBigNormalize<BT>
1222 + VecZnxBigNormalizeTmpBytes,
1223 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
1224 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
1225{
1226 assert_eq!(module_ref.n(), module_test.n());
1227 let n: usize = module_ref.n();
1228
1229 let mut source: Source = Source::new([0u8; 32]);
1230 let cols: usize = 2;
1231
1232 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(module_ref.vec_znx_big_normalize_tmp_bytes());
1233 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(module_test.vec_znx_big_normalize_tmp_bytes());
1234
1235 for a_size in [1, 2, 3, 4] {
1236 let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
1237 a.fill_uniform(base2k, &mut source);
1238
1239 let mut a_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, a_size);
1240 let mut a_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, a_size);
1241
1242 for j in 0..cols {
1243 module_ref.vec_znx_big_from_small(&mut a_ref, j, &a, j);
1244 module_test.vec_znx_big_from_small(&mut a_test, j, &a, j);
1245 }
1246
1247 let a_ref_digest: u64 = a_ref.digest_u64();
1248 let a_test_digest: u64 = a_test.digest_u64();
1249
1250 for b_size in [1, 2, 3, 4] {
1251 let mut b: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, b_size);
1252 b.fill_uniform(base2k, &mut source);
1253 let b_digest: u64 = b.digest_u64();
1254
1255 for res_size in [1, 2, 3, 4] {
1256 let mut res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, res_size);
1257 let mut res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, res_size);
1258
1259 // Set res to garbage
1260 source.fill_bytes(res_big_ref.data_mut());
1261 source.fill_bytes(res_big_test.data_mut());
1262
1263 // Reference
1264 for i in 0..cols {
1265 module_ref.vec_znx_big_sub_small_b(&mut res_big_ref, i, &a_ref, i, &b, i);
1266 module_test.vec_znx_big_sub_small_b(&mut res_big_test, i, &a_test, i, &b, i);
1267 }
1268
1269 assert_eq!(a_ref.digest_u64(), a_ref_digest);
1270 assert_eq!(a_test.digest_u64(), a_test_digest);
1271 assert_eq!(b.digest_u64(), b_digest);
1272
1273 let mut res_small_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
1274 let mut res_small_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
1275
1276 let res_ref_digest: u64 = res_big_ref.digest_u64();
1277 let res_test_digest: u64 = res_big_test.digest_u64();
1278
1279 for j in 0..cols {
1280 module_ref.vec_znx_big_normalize(
1281 base2k,
1282 &mut res_small_ref,
1283 j,
1284 base2k,
1285 &res_big_ref,
1286 j,
1287 scratch_ref.borrow(),
1288 );
1289 module_test.vec_znx_big_normalize(
1290 base2k,
1291 &mut res_small_test,
1292 j,
1293 base2k,
1294 &res_big_test,
1295 j,
1296 scratch_test.borrow(),
1297 );
1298 }
1299
1300 assert_eq!(res_big_ref.digest_u64(), res_ref_digest);
1301 assert_eq!(res_big_test.digest_u64(), res_test_digest);
1302
1303 assert_eq!(res_small_ref, res_small_test);
1304 }
1305 }
1306 }
1307}
1308
1309pub fn test_vec_znx_big_sub_small_a_inplace<BR: Backend, BT: Backend>(
1310 base2k: usize,
1311 module_ref: &Module<BR>,
1312 module_test: &Module<BT>,
1313) where
1314 Module<BR>: VecZnxBigSubSmallInplace<BR>
1315 + VecZnxBigAlloc<BR>
1316 + VecZnxBigFromSmall<BR>
1317 + VecZnxBigNormalize<BR>
1318 + VecZnxBigNormalizeTmpBytes,
1319 Module<BT>: VecZnxBigSubSmallInplace<BT>
1320 + VecZnxBigAlloc<BT>
1321 + VecZnxBigFromSmall<BT>
1322 + VecZnxBigNormalize<BT>
1323 + VecZnxBigNormalizeTmpBytes,
1324 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
1325 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
1326{
1327 assert_eq!(module_ref.n(), module_test.n());
1328 let n: usize = module_ref.n();
1329
1330 let mut source: Source = Source::new([0u8; 32]);
1331 let cols: usize = 2;
1332
1333 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(module_ref.vec_znx_big_normalize_tmp_bytes());
1334 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(module_test.vec_znx_big_normalize_tmp_bytes());
1335
1336 for a_size in [1, 2, 3, 4] {
1337 let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
1338 a.fill_uniform(base2k, &mut source);
1339
1340 let a_digest: u64 = a.digest_u64();
1341
1342 for res_size in [1, 2, 3, 4] {
1343 let mut res: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
1344 res.fill_uniform(base2k, &mut source);
1345
1346 let mut res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, res_size);
1347 let mut res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, res_size);
1348
1349 for j in 0..cols {
1350 module_ref.vec_znx_big_from_small(&mut res_big_ref, j, &res, j);
1351 module_test.vec_znx_big_from_small(&mut res_big_test, j, &res, j);
1352 }
1353
1354 for i in 0..cols {
1355 module_ref.vec_znx_big_sub_small_inplace(&mut res_big_ref, i, &a, i);
1356 module_test.vec_znx_big_sub_small_inplace(&mut res_big_test, i, &a, i);
1357 }
1358
1359 assert_eq!(a.digest_u64(), a_digest);
1360
1361 let mut res_small_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
1362 let mut res_small_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
1363
1364 let res_ref_digest: u64 = res_big_ref.digest_u64();
1365 let res_test_digest: u64 = res_big_test.digest_u64();
1366
1367 for j in 0..cols {
1368 module_ref.vec_znx_big_normalize(
1369 base2k,
1370 &mut res_small_ref,
1371 j,
1372 base2k,
1373 &res_big_ref,
1374 j,
1375 scratch_ref.borrow(),
1376 );
1377 module_test.vec_znx_big_normalize(
1378 base2k,
1379 &mut res_small_test,
1380 j,
1381 base2k,
1382 &res_big_test,
1383 j,
1384 scratch_test.borrow(),
1385 );
1386 }
1387
1388 assert_eq!(res_big_ref.digest_u64(), res_ref_digest);
1389 assert_eq!(res_big_test.digest_u64(), res_test_digest);
1390
1391 assert_eq!(res_small_ref, res_small_test);
1392 }
1393 }
1394}
1395
1396pub fn test_vec_znx_big_sub_small_b_inplace<BR: Backend, BT: Backend>(
1397 base2k: usize,
1398 module_ref: &Module<BR>,
1399 module_test: &Module<BT>,
1400) where
1401 Module<BR>: VecZnxBigSubSmallNegateInplace<BR>
1402 + VecZnxBigAlloc<BR>
1403 + VecZnxBigFromSmall<BR>
1404 + VecZnxBigNormalize<BR>
1405 + VecZnxBigNormalizeTmpBytes,
1406 Module<BT>: VecZnxBigSubSmallNegateInplace<BT>
1407 + VecZnxBigAlloc<BT>
1408 + VecZnxBigFromSmall<BT>
1409 + VecZnxBigNormalize<BT>
1410 + VecZnxBigNormalizeTmpBytes,
1411 ScratchOwned<BR>: ScratchOwnedAlloc<BR> + ScratchOwnedBorrow<BR>,
1412 ScratchOwned<BT>: ScratchOwnedAlloc<BT> + ScratchOwnedBorrow<BT>,
1413{
1414 assert_eq!(module_ref.n(), module_test.n());
1415 let n: usize = module_ref.n();
1416
1417 let mut source: Source = Source::new([0u8; 32]);
1418 let cols: usize = 2;
1419
1420 let mut scratch_ref: ScratchOwned<BR> = ScratchOwned::alloc(module_ref.vec_znx_big_normalize_tmp_bytes());
1421 let mut scratch_test: ScratchOwned<BT> = ScratchOwned::alloc(module_test.vec_znx_big_normalize_tmp_bytes());
1422
1423 for a_size in [1, 2, 3, 4] {
1424 let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, a_size);
1425 a.fill_uniform(base2k, &mut source);
1426
1427 let a_digest: u64 = a.digest_u64();
1428
1429 for res_size in [1, 2, 3, 4] {
1430 let mut res: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
1431 res.fill_uniform(base2k, &mut source);
1432
1433 let mut res_big_ref: VecZnxBig<Vec<u8>, BR> = module_ref.vec_znx_big_alloc(cols, res_size);
1434 let mut res_big_test: VecZnxBig<Vec<u8>, BT> = module_test.vec_znx_big_alloc(cols, res_size);
1435
1436 for j in 0..cols {
1437 module_ref.vec_znx_big_from_small(&mut res_big_ref, j, &res, j);
1438 module_test.vec_znx_big_from_small(&mut res_big_test, j, &res, j);
1439 }
1440
1441 for i in 0..cols {
1442 module_ref.vec_znx_big_sub_small_negate_inplace(&mut res_big_ref, i, &a, i);
1443 module_test.vec_znx_big_sub_small_negate_inplace(&mut res_big_test, i, &a, i);
1444 }
1445
1446 assert_eq!(a.digest_u64(), a_digest);
1447
1448 let mut res_small_ref: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
1449 let mut res_small_test: VecZnx<Vec<u8>> = VecZnx::alloc(n, cols, res_size);
1450
1451 let res_ref_digest: u64 = res_big_ref.digest_u64();
1452 let res_test_digest: u64 = res_big_test.digest_u64();
1453
1454 for j in 0..cols {
1455 module_ref.vec_znx_big_normalize(
1456 base2k,
1457 &mut res_small_ref,
1458 j,
1459 base2k,
1460 &res_big_ref,
1461 j,
1462 scratch_ref.borrow(),
1463 );
1464 module_test.vec_znx_big_normalize(
1465 base2k,
1466 &mut res_small_test,
1467 j,
1468 base2k,
1469 &res_big_test,
1470 j,
1471 scratch_test.borrow(),
1472 );
1473 }
1474
1475 assert_eq!(res_big_ref.digest_u64(), res_ref_digest);
1476 assert_eq!(res_big_test.digest_u64(), res_test_digest);
1477
1478 assert_eq!(res_small_ref, res_small_test);
1479 }
1480 }
1481}