poulpy/base2k/src/vec_znx_big.rs
base2k/src/vec_znx_big.rsRaw
1use crate::ffi::vec_znx_big;
2use crate::ffi::vec_znx_dft;
3use crate::{Infos, Module, VecZnx, VecZnxDft};
4
5pub struct VecZnxBig(pub *mut vec_znx_big::vec_znx_bigcoeff_t, pub usize);
6
7impl VecZnxBig {
8 /// Returns a new [VecZnxBig] with the provided data as backing array.
9 /// User must ensure that data is properly alligned and that
10 /// the size of data is at least equal to [Module::bytes_of_vec_znx_big].
11 pub fn from_bytes(limbs: usize, data: &mut [u8]) -> VecZnxBig {
12 VecZnxBig(
13 data.as_mut_ptr() as *mut vec_znx_big::vec_znx_bigcoeff_t,
14 limbs,
15 )
16 }
17
18 pub fn as_vec_znx_dft(&mut self) -> VecZnxDft {
19 VecZnxDft(self.0 as *mut vec_znx_dft::vec_znx_dft_t, self.1)
20 }
21 pub fn limbs(&self) -> usize {
22 self.1
23 }
24}
25
26impl Module {
27 // Allocates a vector Z[X]/(X^N+1) that stores not normalized values.
28 pub fn new_vec_znx_big(&self, limbs: usize) -> VecZnxBig {
29 unsafe { VecZnxBig(vec_znx_big::new_vec_znx_big(self.0, limbs as u64), limbs) }
30 }
31
32 /// Returns a new [VecZnxBig] with the provided bytes array as backing array.
33 ///
34 /// # Arguments
35 ///
36 /// * `limbs`: the number of limbs of the [VecZnxBig].
37 /// * `bytes`: a byte array of size at least [Module::bytes_of_vec_znx_big].
38 ///
39 /// # Panics
40 /// If `bytes.len()` < [Module::bytes_of_vec_znx_big].
41 pub fn new_vec_znx_big_from_bytes(&self, limbs: usize, bytes: &mut [u8]) -> VecZnxBig {
42 assert!(
43 bytes.len() >= self.bytes_of_vec_znx_big(limbs),
44 "invalid bytes: bytes.len()={} < bytes_of_vec_znx_dft={}",
45 bytes.len(),
46 self.bytes_of_vec_znx_big(limbs)
47 );
48 VecZnxBig::from_bytes(limbs, bytes)
49 }
50
51 /// Returns the minimum number of bytes necessary to allocate
52 /// a new [VecZnxBig] through [VecZnxBig::from_bytes].
53 pub fn bytes_of_vec_znx_big(&self, limbs: usize) -> usize {
54 unsafe { vec_znx_big::bytes_of_vec_znx_big(self.0, limbs as u64) as usize }
55 }
56
57 // b <- b - a
58 pub fn vec_znx_big_sub_small_a_inplace(&self, b: &mut VecZnxBig, a: &VecZnx) {
59 unsafe {
60 vec_znx_big::vec_znx_big_sub_small_a(
61 self.0,
62 b.0,
63 b.limbs() as u64,
64 a.as_ptr(),
65 a.limbs() as u64,
66 a.n() as u64,
67 b.0,
68 b.limbs() as u64,
69 )
70 }
71 }
72
73 // c <- b - a
74 pub fn vec_znx_big_sub_small_a(&self, c: &mut VecZnxBig, a: &VecZnx, b: &VecZnxBig) {
75 unsafe {
76 vec_znx_big::vec_znx_big_sub_small_a(
77 self.0,
78 c.0,
79 c.limbs() as u64,
80 a.as_ptr(),
81 a.limbs() as u64,
82 a.n() as u64,
83 b.0,
84 b.limbs() as u64,
85 )
86 }
87 }
88
89 // c <- b + a
90 pub fn vec_znx_big_add_small(&self, c: &mut VecZnxBig, a: &VecZnx, b: &VecZnxBig) {
91 unsafe {
92 vec_znx_big::vec_znx_big_add_small(
93 self.0,
94 c.0,
95 c.limbs() as u64,
96 b.0,
97 b.limbs() as u64,
98 a.as_ptr(),
99 a.limbs() as u64,
100 a.n() as u64,
101 )
102 }
103 }
104
105 // b <- b + a
106 pub fn vec_znx_big_add_small_inplace(&self, b: &mut VecZnxBig, a: &VecZnx) {
107 unsafe {
108 vec_znx_big::vec_znx_big_add_small(
109 self.0,
110 b.0,
111 b.limbs() as u64,
112 b.0,
113 b.limbs() as u64,
114 a.as_ptr(),
115 a.limbs() as u64,
116 a.n() as u64,
117 )
118 }
119 }
120
121 pub fn vec_znx_big_normalize_tmp_bytes(&self) -> usize {
122 unsafe { vec_znx_big::vec_znx_big_normalize_base2k_tmp_bytes(self.0) as usize }
123 }
124
125 // b <- normalize(a)
126 pub fn vec_znx_big_normalize(
127 &self,
128 log_base2k: usize,
129 b: &mut VecZnx,
130 a: &VecZnxBig,
131 tmp_bytes: &mut [u8],
132 ) {
133 assert!(
134 tmp_bytes.len() >= self.vec_znx_big_normalize_tmp_bytes(),
135 "invalid tmp_bytes: tmp_bytes.len()={} <= self.vec_znx_big_normalize_tmp_bytes()={}",
136 tmp_bytes.len(),
137 self.vec_znx_big_normalize_tmp_bytes()
138 );
139 unsafe {
140 vec_znx_big::vec_znx_big_normalize_base2k(
141 self.0,
142 log_base2k as u64,
143 b.as_mut_ptr(),
144 b.limbs() as u64,
145 b.n() as u64,
146 a.0,
147 a.limbs() as u64,
148 tmp_bytes.as_mut_ptr(),
149 )
150 }
151 }
152
153 pub fn vec_znx_big_range_normalize_base2k_tmp_bytes(&self) -> usize {
154 unsafe { vec_znx_big::vec_znx_big_range_normalize_base2k_tmp_bytes(self.0) as usize }
155 }
156
157 pub fn vec_znx_big_range_normalize_base2k(
158 &self,
159 log_base2k: usize,
160 res: &mut VecZnx,
161 a: &VecZnxBig,
162 a_range_begin: usize,
163 a_range_xend: usize,
164 a_range_step: usize,
165 tmp_bytes: &mut [u8],
166 ) {
167 assert!(
168 tmp_bytes.len() >= self.vec_znx_big_range_normalize_base2k_tmp_bytes(),
169 "invalid tmp_bytes: tmp_bytes.len()={} <= self.vec_znx_big_range_normalize_base2k_tmp_bytes()={}",
170 tmp_bytes.len(),
171 self.vec_znx_big_range_normalize_base2k_tmp_bytes()
172 );
173 unsafe {
174 vec_znx_big::vec_znx_big_range_normalize_base2k(
175 self.0,
176 log_base2k as u64,
177 res.as_mut_ptr(),
178 res.limbs() as u64,
179 res.n() as u64,
180 a.0,
181 a_range_begin as u64,
182 a_range_xend as u64,
183 a_range_step as u64,
184 tmp_bytes.as_mut_ptr(),
185 );
186 }
187 }
188
189 pub fn vec_znx_big_automorphism(&self, gal_el: i64, b: &mut VecZnxBig, a: &VecZnxBig) {
190 unsafe {
191 vec_znx_big::vec_znx_big_automorphism(
192 self.0,
193 gal_el,
194 b.0,
195 b.limbs() as u64,
196 a.0,
197 a.limbs() as u64,
198 );
199 }
200 }
201
202 pub fn vec_znx_big_automorphism_inplace(&self, gal_el: i64, a: &mut VecZnxBig) {
203 unsafe {
204 vec_znx_big::vec_znx_big_automorphism(
205 self.0,
206 gal_el,
207 a.0,
208 a.limbs() as u64,
209 a.0,
210 a.limbs() as u64,
211 );
212 }
213 }
214}