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