arnaucube/poulpy
1
0
Fork 0
mirror of https://github.com/arnaucube/poulpy.git synced 2026-02-10 13:16:44 +01:00
Code Issues Packages Projects Releases Wiki Activity

Applied discussed changes, everything working, but still to discuss

Browse Source
This commit is contained in:
Jean-Philippe Bossuat
2025-05-01 10:33:19 +02:00
parent 4e6fce3458
commit ca5e6d46c9
14 changed files with 710 additions and 508 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
base2k/examples/rlwe_encrypt.rs
View File

@@ -13,7 +13,8 @@ fn main() {
let log_scale: usize = msg_size * log_base2k - 5;
let module: Module<FFT64> = Module::<FFT64>::new(n);
let mut carry: Vec<u8> = alloc_aligned(module.vec_znx_big_normalize_tmp_bytes());
let mut tmp_bytes_norm: Vec<u8> = alloc_aligned(module.vec_znx_big_normalize_tmp_bytes());
let mut tmp_bytes_dft = alloc_aligned(module.bytes_of_vec_znx_dft(1, ct_size));
let seed: [u8; 32] = [0; 32];
let mut source: Source = Source::new(seed);
@@ -38,9 +39,10 @@ fn main() {
module.fill_uniform(log_base2k, &mut ct, 1, ct_size, &mut source);
// Scratch space for DFT values
let mut buf_dft: VecZnxDft<FFT64> = module.new_vec_znx_dft(
let mut buf_dft: VecZnxDft<FFT64> = module.new_vec_znx_dft_from_bytes_borrow(
1, // Number of columns
ct.size(), // Number of polynomials per column
&mut tmp_bytes_dft,
);
// Applies DFT(ct[1]) * DFT(s)
@@ -68,7 +70,7 @@ fn main() {
want.iter_mut()
.for_each(|x| *x = source.next_u64n(16, 15) as i64);
m.encode_vec_i64(0, log_base2k, log_scale, &want, 4);
m.normalize(log_base2k, &mut carry);
m.normalize(log_base2k, 0, &mut tmp_bytes_norm);
// m - BIG(ct[1] * s)
module.vec_znx_big_sub_small_a_inplace(
@@ -81,9 +83,12 @@ fn main() {
// Normalizes back to VecZnx
// ct[0] <- m - BIG(c1 * s)
module.vec_znx_big_normalize(
log_base2k, &mut ct, 0, // Selects the first column of ct (ct[0])
&buf_big, 0, // Selects the first column of buf_big
&mut carry,
log_base2k,
&mut ct,
0, // Selects the first column of ct (ct[0])
&buf_big,
0, // Selects the first column of buf_big
&mut tmp_bytes_norm,
);
// Add noise to ct[0]
@@ -120,7 +125,7 @@ fn main() {
// m + e <- BIG(ct[1] * s + ct[0])
let mut res: VecZnx = module.new_vec_znx(1, ct_size);
module.vec_znx_big_normalize(log_base2k, &mut res, 0, &buf_big, 0, &mut carry);
module.vec_znx_big_normalize(log_base2k, &mut res, 0, &buf_big, 0, &mut tmp_bytes_norm);
// have = m * 2^{log_scale} + e
let mut have: Vec<i64> = vec![i64::default(); n];

59
base2k/examples/vector_matrix_product.rs
View File

@@ -1,59 +0,0 @@
use base2k::{
Encoding, FFT64, MatZnxDft, MatZnxDftOps, Module, VecZnx, VecZnxBig, VecZnxBigOps, VecZnxDft, VecZnxDftOps, VecZnxOps,
ZnxInfos, ZnxLayout, alloc_aligned,
};
fn main() {
let log_n: i32 = 5;
let n: usize = 1 << log_n;
let module: Module<FFT64> = Module::<FFT64>::new(n);
let log_base2k: usize = 15;
let limbs_vec: usize = 5;
let log_k: usize = log_base2k * limbs_vec - 5;
let rows_mat: usize = limbs_vec;
let limbs_mat: usize = limbs_vec + 1;
// Maximum size of the byte scratch needed
let tmp_bytes: usize = module.vmp_prepare_tmp_bytes(rows_mat, 1, limbs_mat)
| module.vmp_apply_dft_tmp_bytes(limbs_vec, limbs_vec, rows_mat, limbs_mat);
let mut buf: Vec<u8> = alloc_aligned(tmp_bytes);
let mut a_values: Vec<i64> = vec![i64::default(); n];
a_values[1] = (1 << log_base2k) + 1;
let mut a: VecZnx = module.new_vec_znx(1, limbs_vec);
a.encode_vec_i64(0, log_base2k, log_k, &a_values, 32);
a.normalize(log_base2k, &mut buf);
a.print(n);
println!();
let mut mat_znx_dft: MatZnxDft<FFT64> = module.new_mat_znx_dft(rows_mat, 1, limbs_mat);
(0..a.size()).for_each(|row_i| {
let mut tmp: VecZnx = module.new_vec_znx(1, limbs_mat);
tmp.at_limb_mut(row_i)[1] = 1 as i64;
module.vmp_prepare_row(&mut mat_znx_dft, tmp.raw(), row_i, &mut buf);
});
let mut c_dft: VecZnxDft<FFT64> = module.new_vec_znx_dft(1, limbs_mat);
module.vmp_apply_dft(&mut c_dft, &a, &mat_znx_dft, &mut buf);
let mut c_big: VecZnxBig<FFT64> = c_dft.alias_as_vec_znx_big();
module.vec_znx_idft_tmp_a(&mut c_big, 0, &mut c_dft, 0);
let mut res: VecZnx = module.new_vec_znx(1, limbs_vec);
module.vec_znx_big_normalize(log_base2k, &mut res, 0, &c_big, 0, &mut buf);
let mut values_res: Vec<i64> = vec![i64::default(); n];
res.decode_vec_i64(0, log_base2k, log_k, &mut values_res);
res.print(n);
module.free();
println!("{:?}", values_res)
}

78
base2k/examples/vmp.rs Normal file
View File

@@ -0,0 +1,78 @@
use base2k::{
Encoding, FFT64, MatZnxDft, MatZnxDftOps, Module, VecZnx, VecZnxBig, VecZnxBigOps, VecZnxDft, VecZnxDftOps, VecZnxOps,
ZnxInfos, ZnxLayout, alloc_aligned,
};
fn main() {
let log_n: i32 = 5;
let n: usize = 1 << log_n;
let module: Module<FFT64> = Module::<FFT64>::new(n);
let log_base2k: usize = 15;
let a_cols: usize = 2;
let a_size: usize = 5;
let log_k: usize = log_base2k * a_size - 5;
let mat_rows: usize = a_size;
let mat_cols_in: usize = a_cols;
let mat_cols_out: usize = 2;
let mat_size: usize = a_size + 1;
let mut tmp_bytes_vmp: Vec<u8> = alloc_aligned(
module.vmp_prepare_row_tmp_bytes(mat_cols_out, mat_size)
| module.vmp_apply_dft_tmp_bytes(
a_size,
a_size,
mat_rows,
mat_cols_in,
mat_cols_out,
mat_size,
),
);
let mut tmp_bytes_dft: Vec<u8> = alloc_aligned(module.bytes_of_vec_znx_dft(mat_cols_out, mat_size));
let mut a: VecZnx = module.new_vec_znx(a_cols, a_size);
(0..a_cols).for_each(|i| {
let mut values: Vec<i64> = vec![i64::default(); n];
values[1 + i] = (1 << log_base2k) + 1;
a.encode_vec_i64(i, log_base2k, log_k, &values, 32);
a.normalize(log_base2k, i, &mut tmp_bytes_vmp);
a.print(n, i);
println!();
});
let mut mat_znx_dft: MatZnxDft<FFT64> = module.new_mat_znx_dft(mat_rows, mat_cols_in, mat_cols_out, mat_size);
(0..a.size()).for_each(|row_i| {
let mut tmp: VecZnx = module.new_vec_znx(mat_cols_out, mat_size);
(0..mat_cols_out).for_each(|j| {
tmp.at_mut(j, row_i)[1 + j] = 1 as i64;
});
(0..mat_cols_in).for_each(|j| {
module.vmp_prepare_row(&mut mat_znx_dft, row_i, j, &tmp, &mut tmp_bytes_vmp);
})
});
let mut c_dft: VecZnxDft<FFT64> = module.new_vec_znx_dft_from_bytes_borrow(mat_cols_out, mat_size, &mut tmp_bytes_dft);
module.vmp_apply_dft(&mut c_dft, &a, &mat_znx_dft, &mut tmp_bytes_vmp);
let mut res: VecZnx = module.new_vec_znx(mat_cols_out, a_size);
let mut c_big: VecZnxBig<FFT64> = c_dft.alias_as_vec_znx_big();
(0..mat_cols_out).for_each(|i| {
module.vec_znx_idft_tmp_a(&mut c_big, i, &mut c_dft, i);
module.vec_znx_big_normalize(log_base2k, &mut res, i, &c_big, i, &mut tmp_bytes_vmp);
let mut values_res: Vec<i64> = vec![i64::default(); n];
res.decode_vec_i64(i, log_base2k, log_k, &mut values_res);
res.print(n, i);
println!();
println!("{:?}", values_res);
println!();
});
module.free();
}