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

wip

Browse Source
This commit is contained in:
Jean-Philippe Bossuat
2025-01-14 13:49:24 +01:00
parent 47a0894414
commit 2e446c6b76
2 changed files with 18 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
math/src/ring/impl_u64/packing.rs
View File

@@ -4,12 +4,11 @@ use crate::modulus::ONCE;
use crate::poly::Poly; use crate::poly::Poly;
use crate::ring::Ring; use crate::ring::Ring;
use std::cmp::min; use std::cmp::min;
use std::rc::Rc;
impl Ring<u64> { impl Ring<u64> {
pub fn pack<const ZEROGARBAGE: bool, const NTT: bool>( pub fn pack<const ZEROGARBAGE: bool, const NTT: bool>(
&self, &self,
polys: &mut Vec<Option<Poly<u64>>>, polys: &mut Vec<Option<&mut Poly<u64>>>,
log_gap: usize, log_gap: usize,
) { ) {
let log_n: usize = self.log_n(); let log_n: usize = self.log_n();
@@ -46,7 +45,7 @@ impl Ring<u64> {
.prepare(self.modulus.inv(1 << (log_end - log_start))); .prepare(self.modulus.inv(1 << (log_end - log_start)));
indices.iter().for_each(|i| { indices.iter().for_each(|i| {
if let Some(poly) = polys[*i].as_mut() { if let Some(poly) = polys[*i].as_deref_mut() {
if !NTT { if !NTT {
self.ntt_inplace::<true>(poly); self.ntt_inplace::<true>(poly);
} }
@@ -126,6 +125,7 @@ fn max_gap(vec: &[usize]) -> usize {
gap gap
} }
pub struct StreamRepacker { pub struct StreamRepacker {
accumulators: Vec<Accumulator>, accumulators: Vec<Accumulator>,
tmp_a: Poly<u64>, tmp_a: Poly<u64>,

58
math/tests/automorphism.rs
View File

@@ -62,74 +62,46 @@ fn packing_u64() {
let ring: Ring<u64> = Ring::new(n, q_base, q_power); let ring: Ring<u64> = Ring::new(n, q_base, q_power);
sub_test("test_packing_u64::<NTT:false>", || { sub_test("test_packing_u64::<NTT:false>", || {
test_packing_full_u64::<false>(&ring) test_packing_sparse_u64::<false>(&ring, 1)
}); });
sub_test("test_packing_u64::<NTT:true>", || { sub_test("test_packing_u64::<NTT:true>", || {
test_packing_full_u64::<true>(&ring) test_packing_sparse_u64::<true>(&ring, 1)
}); });
sub_test("test_packing_sparse_u64::<NTT:false>", || { sub_test("test_packing_sparse_u64::<NTT:false>", || {
test_packing_sparse_u64::<false>(&ring) test_packing_sparse_u64::<false>(&ring, 3)
}); });
sub_test("test_packing_sparse_u64::<NTT:true>", || { sub_test("test_packing_sparse_u64::<NTT:true>", || {
test_packing_sparse_u64::<true>(&ring) test_packing_sparse_u64::<true>(&ring, 3)
}); });
} }
fn test_packing_full_u64<const NTT: bool>(ring: &Ring<u64>) { fn test_packing_sparse_u64<const NTT: bool>(ring: &Ring<u64>, gap: usize) {
let n: usize = ring.n(); let n: usize = ring.n();
let mut result: Vec<Option<Poly<u64>>> = vec![None; n]; let mut result: Vec<Option<&mut Poly<u64>>> = Vec::with_capacity(n);
result.resize_with(n, || None);
for i in 0..n { let mut polys: Vec<Poly<u64>> = vec![ring.new_poly(); (n+gap-1)/gap];
let mut poly: Poly<u64> = ring.new_poly();
poly.fill(&(1 + i as u64)); polys.iter_mut().enumerate().for_each(|(i , poly)|{
poly.fill(&((1 + i*gap) as u64));
if NTT { if NTT {
ring.ntt_inplace::<false>(&mut poly); ring.ntt_inplace::<false>(poly);
} }
result[i*gap] = Some(poly);
result[i] = Some(poly); });
}
ring.pack::<true, NTT>(&mut result, ring.log_n()); ring.pack::<true, NTT>(&mut result, ring.log_n());
if let Some(poly) = result[0].as_mut() { if let Some(poly) = result[0].as_mut() {
if NTT {
ring.intt_inplace::<false>(poly);
}
poly.0
.iter()
.enumerate()
.for_each(|(i, x)| assert_eq!(*x, 1 + i as u64));
}
}
fn test_packing_sparse_u64<const NTT: bool>(ring: &Ring<u64>) {
let n: usize = ring.n();
let mut result: Vec<Option<Poly<u64>>> = vec![None; n];
let gap: usize = 3;
for i in (0..n).step_by(gap) {
let mut poly: Poly<u64> = ring.new_poly();
poly.fill(&(1 + i as u64));
if NTT {
ring.ntt_inplace::<false>(&mut poly);
}
result[i] = Some(poly);
}
ring.pack::<true, NTT>(&mut result, ring.log_n());
if let Some(poly) = result[0].as_mut() {
if NTT { if NTT {
ring.intt_inplace::<false>(poly); ring.intt_inplace::<false>(poly);
} }
poly.0.iter().enumerate().for_each(|(i, x)| { poly.0.iter().enumerate().for_each(|(i, x)| {
if i % gap == 0 { if i % gap == 0 {
assert_eq!(*x, 1 + i as u64) assert_eq!(*x, (1+i) as u64)
} else { } else {
assert_eq!(*x, 0u64) assert_eq!(*x, 0u64)
} }