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