poulpy/base2k/src/encoding.rs
base2k/src/encoding.rsRaw
1use crate::ffi::znx::znx_zero_i64_ref;
2use crate::{Infos, VecZnx};
3use itertools::izip;
4use std::cmp::min;
5
6pub trait Encoding {
7 /// encode a vector of i64 on the receiver.
8 ///
9 /// # Arguments
10 ///
11 /// * `log_base2k`: base two logarithm decomposition of the receiver.
12 /// * `log_k`: base two logarithm of the scaling of the data.
13 /// * `data`: data to encode on the receiver.
14 /// * `log_max`: base two logarithm of the infinity norm of the input data.
15 fn encode_i64_vec(&mut self, log_base2k: usize, log_k: usize, data: &[i64], log_max: usize);
16
17 /// decode a vector of i64 from the receiver.
18 ///
19 /// # Arguments
20 ///
21 /// * `log_base2k`: base two logarithm decomposition of the receiver.
22 /// * `log_k`: base two logarithm of the scaling of the data.
23 /// * `data`: data to decode from the receiver.
24 fn decode_i64_vec(&self, log_base2k: usize, log_k: usize, data: &mut [i64]);
25
26 /// encodes a single i64 on the receiver at the given index.
27 ///
28 /// # Arguments
29 ///
30 /// * `log_base2k`: base two logarithm decomposition of the receiver.
31 /// * `log_k`: base two logarithm of the scaling of the data.
32 /// * `i`: index of the coefficient on which to encode the data.
33 /// * `data`: data to encode on the receiver.
34 /// * `log_max`: base two logarithm of the infinity norm of the input data.
35 fn encode_i64_coeff(
36 &mut self,
37 log_base2k: usize,
38 log_k: usize,
39 i: usize,
40 data: i64,
41 log_max: usize,
42 );
43
44 /// decode a single of i64 from the receiver at the given index.
45 ///
46 /// # Arguments
47 ///
48 /// * `log_base2k`: base two logarithm decomposition of the receiver.
49 /// * `log_k`: base two logarithm of the scaling of the data.
50 /// * `i`: index of the coefficient to decode.
51 /// * `data`: data to decode from the receiver.
52 fn decode_i64_coeff(&self, log_base2k: usize, log_k: usize, i: usize) -> i64;
53}
54
55impl Encoding for VecZnx {
56 fn encode_i64_vec(&mut self, log_base2k: usize, log_k: usize, data: &[i64], log_max: usize) {
57 let limbs: usize = (log_k + log_base2k - 1) / log_base2k;
58
59 assert!(limbs <= self.limbs(), "invalid argument log_k: (log_k + self.log_base2k - 1)/self.log_base2k={} > self.limbs()={}", limbs, self.limbs());
60
61 let size: usize = min(data.len(), self.n());
62 let log_k_rem: usize = log_base2k - (log_k % log_base2k);
63
64 // If 2^{log_base2k} * 2^{k_rem} < 2^{63}-1, then we can simply copy
65 // values on the last limb.
66 // Else we decompose values base2k.
67 if log_max + log_k_rem < 63 || log_k_rem == log_base2k {
68 (0..limbs - 1).for_each(|i| unsafe {
69 znx_zero_i64_ref(size as u64, self.at_mut(i).as_mut_ptr());
70 });
71 self.at_mut(self.limbs() - 1)[..size].copy_from_slice(&data[..size]);
72 } else {
73 let mask: i64 = (1 << log_base2k) - 1;
74 let steps: usize = min(limbs, (log_max + log_base2k - 1) / log_base2k);
75
76 (0..steps).for_each(|i| unsafe {
77 znx_zero_i64_ref(size as u64, self.at_mut(i).as_mut_ptr());
78 });
79
80 (limbs - steps..limbs)
81 .rev()
82 .enumerate()
83 .for_each(|(i, i_rev)| {
84 let shift: usize = i * log_base2k;
85 izip!(self.at_mut(i_rev)[..size].iter_mut(), data[..size].iter())
86 .for_each(|(y, x)| *y = (x >> shift) & mask);
87 })
88 }
89
90 // Case where self.prec % self.k != 0.
91 if log_k_rem != log_base2k {
92 let limbs = self.limbs();
93 let steps: usize = min(limbs, (log_max + log_base2k - 1) / log_base2k);
94 (limbs - steps..limbs).rev().for_each(|i| {
95 self.at_mut(i)[..size]
96 .iter_mut()
97 .for_each(|x| *x <<= log_k_rem);
98 })
99 }
100 }
101
102 fn decode_i64_vec(&self, log_base2k: usize, log_k: usize, data: &mut [i64]) {
103 let limbs: usize = (log_k + log_base2k - 1) / log_base2k;
104 assert!(
105 data.len() >= self.n,
106 "invalid data: data.len()={} < self.n()={}",
107 data.len(),
108 self.n
109 );
110 data.copy_from_slice(self.at(0));
111 let rem: usize = log_base2k - (log_k % log_base2k);
112 (1..limbs).for_each(|i| {
113 if i == limbs - 1 && rem != log_base2k {
114 let k_rem: usize = log_base2k - rem;
115 izip!(self.at(i).iter(), data.iter_mut()).for_each(|(x, y)| {
116 *y = (*y << k_rem) + (x >> rem);
117 });
118 } else {
119 izip!(self.at(i).iter(), data.iter_mut()).for_each(|(x, y)| {
120 *y = (*y << log_base2k) + x;
121 });
122 }
123 })
124 }
125
126 fn encode_i64_coeff(
127 &mut self,
128 log_base2k: usize,
129 log_k: usize,
130 i: usize,
131 value: i64,
132 log_max: usize,
133 ) {
134 assert!(i < self.n());
135 let limbs: usize = (log_k + log_base2k - 1) / log_base2k;
136 assert!(limbs <= self.limbs(), "invalid argument log_k: (log_k + self.log_base2k - 1)/self.log_base2k={} > self.limbs()={}", limbs, self.limbs());
137 let log_k_rem: usize = log_base2k - (log_k % log_base2k);
138 let limbs = self.limbs();
139
140 // If 2^{log_base2k} * 2^{log_k_rem} < 2^{63}-1, then we can simply copy
141 // values on the last limb.
142 // Else we decompose values base2k.
143 if log_max + log_k_rem < 63 || log_k_rem == log_base2k {
144 (0..limbs - 1).for_each(|j| self.at_mut(j)[i] = 0);
145
146 self.at_mut(self.limbs() - 1)[i] = value;
147 } else {
148 let mask: i64 = (1 << log_base2k) - 1;
149 let steps: usize = min(limbs, (log_max + log_base2k - 1) / log_base2k);
150
151 (0..limbs - steps).for_each(|j| self.at_mut(j)[i] = 0);
152
153 (limbs - steps..limbs)
154 .rev()
155 .enumerate()
156 .for_each(|(j, j_rev)| {
157 self.at_mut(j_rev)[i] = (value >> (j * log_base2k)) & mask;
158 })
159 }
160
161 // Case where self.prec % self.k != 0.
162 if log_k_rem != log_base2k {
163 let limbs = self.limbs();
164 let steps: usize = min(limbs, (log_max + log_base2k - 1) / log_base2k);
165 (limbs - steps..limbs).rev().for_each(|j| {
166 self.at_mut(j)[i] <<= log_k_rem;
167 })
168 }
169 }
170
171 fn decode_i64_coeff(&self, log_base2k: usize, log_k: usize, i: usize) -> i64 {
172 let limbs: usize = (log_k + log_base2k - 1) / log_base2k;
173 assert!(i < self.n());
174 let mut res: i64 = self.data[i];
175 let rem: usize = log_base2k - (log_k % log_base2k);
176 (1..limbs).for_each(|i| {
177 let x = self.data[i * self.n];
178 if i == limbs - 1 && rem != log_base2k {
179 let k_rem: usize = log_base2k - rem;
180 res = (res << k_rem) + (x >> rem);
181 } else {
182 res = (res << log_base2k) + x;
183 }
184 });
185 res
186 }
187}
188
189#[cfg(test)]
190mod tests {
191 use crate::{Encoding, VecZnx};
192 use itertools::izip;
193 use sampling::source::Source;
194
195 #[test]
196 fn test_set_get_i64_lo_norm() {
197 let n: usize = 8;
198 let log_base2k: usize = 17;
199 let limbs: usize = 5;
200 let log_k: usize = limbs * log_base2k - 5;
201 let mut a: VecZnx = VecZnx::new(n, limbs);
202 let mut have: Vec<i64> = vec![i64::default(); n];
203 have.iter_mut()
204 .enumerate()
205 .for_each(|(i, x)| *x = (i as i64) - (n as i64) / 2);
206 a.encode_i64_vec(log_base2k, log_k, &have, 10);
207 let mut want = vec![i64::default(); n];
208 a.decode_i64_vec(log_base2k, log_k, &mut want);
209 izip!(want, have).for_each(|(a, b)| assert_eq!(a, b));
210 }
211
212 #[test]
213 fn test_set_get_i64_hi_norm() {
214 let n: usize = 8;
215 let log_base2k: usize = 17;
216 let limbs: usize = 5;
217 let log_k: usize = limbs * log_base2k - 5;
218 let mut a: VecZnx = VecZnx::new(n, limbs);
219 let mut have: Vec<i64> = vec![i64::default(); n];
220 let mut source = Source::new([1; 32]);
221 have.iter_mut().for_each(|x| {
222 *x = source
223 .next_u64n(u64::MAX, u64::MAX)
224 .wrapping_sub(u64::MAX / 2 + 1) as i64;
225 });
226 a.encode_i64_vec(log_base2k, log_k, &have, 63);
227 //(0..a.limbs()).for_each(|i| println!("i:{} -> {:?}", i, a.at(i)));
228 let mut want = vec![i64::default(); n];
229 //(0..a.limbs()).for_each(|i| println!("i:{} -> {:?}", i, a.at(i)));
230 a.decode_i64_vec(log_base2k, log_k, &mut want);
231 izip!(want, have).for_each(|(a, b)| assert_eq!(a, b, "{} != {}", a, b));
232 }
233
234 #[test]
235 fn test_normalize() {}
236}