poulpy/poulpy-backend/src/cpu_spqlios/spqlios-arithmetic/spqlios/arithmetic/vec_znx_big.c
poulpy-backend/src/cpu_spqlios/spqlios-arithmetic/spqlios/arithmetic/vec_znx_big.cRaw
1#include "vec_znx_arithmetic_private.h"
2
3EXPORT uint64_t bytes_of_vec_znx_big(const MODULE* module, // N
4 uint64_t size) {
5 return module->func.bytes_of_vec_znx_big(module, size);
6}
7
8// public wrappers
9
10/** @brief sets res = a+b */
11EXPORT void vec_znx_big_add(const MODULE* module, // N
12 VEC_ZNX_BIG* res, uint64_t res_size, // res
13 const VEC_ZNX_BIG* a, uint64_t a_size, // a
14 const VEC_ZNX_BIG* b, uint64_t b_size // b
15) {
16 module->func.vec_znx_big_add(module, res, res_size, a, a_size, b, b_size);
17}
18
19/** @brief sets res = a+b */
20EXPORT void vec_znx_big_add_small(const MODULE* module, // N
21 VEC_ZNX_BIG* res, uint64_t res_size, // res
22 const VEC_ZNX_BIG* a, uint64_t a_size, // a
23 const int64_t* b, uint64_t b_size, uint64_t b_sl // b
24) {
25 module->func.vec_znx_big_add_small(module, res, res_size, a, a_size, b, b_size, b_sl);
26}
27
28EXPORT void vec_znx_big_add_small2(const MODULE* module, // N
29 VEC_ZNX_BIG* res, uint64_t res_size, // res
30 const int64_t* a, uint64_t a_size, uint64_t a_sl, // a
31 const int64_t* b, uint64_t b_size, uint64_t b_sl // b
32) {
33 module->func.vec_znx_big_add_small2(module, res, res_size, a, a_size, a_sl, b, b_size, b_sl);
34}
35
36/** @brief sets res = a-b */
37EXPORT void vec_znx_big_sub(const MODULE* module, // N
38 VEC_ZNX_BIG* res, uint64_t res_size, // res
39 const VEC_ZNX_BIG* a, uint64_t a_size, // a
40 const VEC_ZNX_BIG* b, uint64_t b_size // b
41) {
42 module->func.vec_znx_big_sub(module, res, res_size, a, a_size, b, b_size);
43}
44
45EXPORT void vec_znx_big_sub_small_b(const MODULE* module, // N
46 VEC_ZNX_BIG* res, uint64_t res_size, // res
47 const VEC_ZNX_BIG* a, uint64_t a_size, // a
48 const int64_t* b, uint64_t b_size, uint64_t b_sl // b
49) {
50 module->func.vec_znx_big_sub_small_b(module, res, res_size, a, a_size, b, b_size, b_sl);
51}
52
53EXPORT void vec_znx_big_sub_small_a(const MODULE* module, // N
54 VEC_ZNX_BIG* res, uint64_t res_size, // res
55 const int64_t* a, uint64_t a_size, uint64_t a_sl, // a
56 const VEC_ZNX_BIG* b, uint64_t b_size // b
57) {
58 module->func.vec_znx_big_sub_small_a(module, res, res_size, a, a_size, a_sl, b, b_size);
59}
60EXPORT void vec_znx_big_sub_small2(const MODULE* module, // N
61 VEC_ZNX_BIG* res, uint64_t res_size, // res
62 const int64_t* a, uint64_t a_size, uint64_t a_sl, // a
63 const int64_t* b, uint64_t b_size, uint64_t b_sl // b
64) {
65 module->func.vec_znx_big_sub_small2(module, res, res_size, a, a_size, a_sl, b, b_size, b_sl);
66}
67
68/** @brief sets res = a . X^p */
69EXPORT void vec_znx_big_rotate(const MODULE* module, // N
70 int64_t p, // rotation value
71 VEC_ZNX_BIG* res, uint64_t res_size, // res
72 const VEC_ZNX_BIG* a, uint64_t a_size // a
73) {
74 module->func.vec_znx_big_rotate(module, p, res, res_size, a, a_size);
75}
76
77/** @brief sets res = a(X^p) */
78EXPORT void vec_znx_big_automorphism(const MODULE* module, // N
79 int64_t p, // X-X^p
80 VEC_ZNX_BIG* res, uint64_t res_size, // res
81 const VEC_ZNX_BIG* a, uint64_t a_size // a
82) {
83 module->func.vec_znx_big_automorphism(module, p, res, res_size, a, a_size);
84}
85
86// private wrappers
87
88EXPORT uint64_t fft64_bytes_of_vec_znx_big(const MODULE* module, // N
89 uint64_t size) {
90 return module->nn * size * sizeof(double);
91}
92
93EXPORT VEC_ZNX_BIG* new_vec_znx_big(const MODULE* module, // N
94 uint64_t size) {
95 return spqlios_alloc(bytes_of_vec_znx_big(module, size));
96}
97
98EXPORT void delete_vec_znx_big(VEC_ZNX_BIG* res) { spqlios_free(res); }
99
100/** @brief sets res = a+b */
101EXPORT void fft64_vec_znx_big_add(const MODULE* module, // N
102 VEC_ZNX_BIG* res, uint64_t res_size, // res
103 const VEC_ZNX_BIG* a, uint64_t a_size, // a
104 const VEC_ZNX_BIG* b, uint64_t b_size // b
105) {
106 const uint64_t n = module->nn;
107 vec_znx_add(module, //
108 (int64_t*)res, res_size, n, //
109 (int64_t*)a, a_size, n, //
110 (int64_t*)b, b_size, n);
111}
112/** @brief sets res = a+b */
113EXPORT void fft64_vec_znx_big_add_small(const MODULE* module, // N
114 VEC_ZNX_BIG* res, uint64_t res_size, // res
115 const VEC_ZNX_BIG* a, uint64_t a_size, // a
116 const int64_t* b, uint64_t b_size, uint64_t b_sl // b
117) {
118 const uint64_t n = module->nn;
119 vec_znx_add(module, //
120 (int64_t*)res, res_size, n, //
121 (int64_t*)a, a_size, n, //
122 b, b_size, b_sl);
123}
124EXPORT void fft64_vec_znx_big_add_small2(const MODULE* module, // N
125 VEC_ZNX_BIG* res, uint64_t res_size, // res
126 const int64_t* a, uint64_t a_size, uint64_t a_sl, // a
127 const int64_t* b, uint64_t b_size, uint64_t b_sl // b
128) {
129 const uint64_t n = module->nn;
130 vec_znx_add(module, //
131 (int64_t*)res, res_size, n, //
132 a, a_size, a_sl, //
133 b, b_size, b_sl);
134}
135
136/** @brief sets res = a-b */
137EXPORT void fft64_vec_znx_big_sub(const MODULE* module, // N
138 VEC_ZNX_BIG* res, uint64_t res_size, // res
139 const VEC_ZNX_BIG* a, uint64_t a_size, // a
140 const VEC_ZNX_BIG* b, uint64_t b_size // b
141) {
142 const uint64_t n = module->nn;
143 vec_znx_sub(module, //
144 (int64_t*)res, res_size, n, //
145 (int64_t*)a, a_size, n, //
146 (int64_t*)b, b_size, n);
147}
148
149EXPORT void fft64_vec_znx_big_sub_small_b(const MODULE* module, // N
150 VEC_ZNX_BIG* res, uint64_t res_size, // res
151 const VEC_ZNX_BIG* a, uint64_t a_size, // a
152 const int64_t* b, uint64_t b_size, uint64_t b_sl // b
153) {
154 const uint64_t n = module->nn;
155 vec_znx_sub(module, //
156 (int64_t*)res, res_size, n, //
157 (int64_t*)a, a_size, //
158 n, b, b_size, b_sl);
159}
160EXPORT void fft64_vec_znx_big_sub_small_a(const MODULE* module, // N
161 VEC_ZNX_BIG* res, uint64_t res_size, // res
162 const int64_t* a, uint64_t a_size, uint64_t a_sl, // a
163 const VEC_ZNX_BIG* b, uint64_t b_size // b
164) {
165 const uint64_t n = module->nn;
166 vec_znx_sub(module, //
167 (int64_t*)res, res_size, n, //
168 a, a_size, a_sl, //
169 (int64_t*)b, b_size, n);
170}
171EXPORT void fft64_vec_znx_big_sub_small2(const MODULE* module, // N
172 VEC_ZNX_BIG* res, uint64_t res_size, // res
173 const int64_t* a, uint64_t a_size, uint64_t a_sl, // a
174 const int64_t* b, uint64_t b_size, uint64_t b_sl // b
175) {
176 const uint64_t n = module->nn;
177 vec_znx_sub(module, //
178 (int64_t*)res, res_size, //
179 n, a, a_size, //
180 a_sl, b, b_size, b_sl);
181}
182
183/** @brief sets res = a . X^p */
184EXPORT void fft64_vec_znx_big_rotate(const MODULE* module, // N
185 int64_t p, // rotation value
186 VEC_ZNX_BIG* res, uint64_t res_size, // res
187 const VEC_ZNX_BIG* a, uint64_t a_size // a
188) {
189 uint64_t nn = module->nn;
190 vec_znx_rotate(module, p, (int64_t*)res, res_size, nn, (int64_t*)a, a_size, nn);
191}
192
193/** @brief sets res = a(X^p) */
194EXPORT void fft64_vec_znx_big_automorphism(const MODULE* module, // N
195 int64_t p, // X-X^p
196 VEC_ZNX_BIG* res, uint64_t res_size, // res
197 const VEC_ZNX_BIG* a, uint64_t a_size // a
198) {
199 uint64_t nn = module->nn;
200 vec_znx_automorphism(module, p, (int64_t*)res, res_size, nn, (int64_t*)a, a_size, nn);
201}
202
203EXPORT void vec_znx_big_normalize_base2k(const MODULE* module, // MODULE
204 uint64_t nn, // N
205 uint64_t k, // base-2^k
206 int64_t* res, uint64_t res_size, uint64_t res_sl, // res
207 const VEC_ZNX_BIG* a, uint64_t a_size, // a
208 uint8_t* tmp_space // temp space
209) {
210 module->func.vec_znx_big_normalize_base2k(module, // MODULE
211 nn, // N
212 k, // base-2^k
213 res, res_size, res_sl, // res
214 a, a_size, // a
215 tmp_space);
216}
217
218EXPORT uint64_t vec_znx_big_normalize_base2k_tmp_bytes(const MODULE* module, uint64_t nn // N
219) {
220 return module->func.vec_znx_big_normalize_base2k_tmp_bytes(module, nn // N
221 );
222}
223
224/** @brief sets res = k-normalize(a.subrange) -- output in int64 coeffs space */
225EXPORT void vec_znx_big_range_normalize_base2k( //
226 const MODULE* module, // MODULE
227 uint64_t nn, // N
228 uint64_t log2_base2k, // base-2^k
229 int64_t* res, uint64_t res_size, uint64_t res_sl, // res
230 const VEC_ZNX_BIG* a, uint64_t a_range_begin, uint64_t a_range_xend, uint64_t a_range_step, // range
231 uint8_t* tmp_space // temp space
232) {
233 module->func.vec_znx_big_range_normalize_base2k(module, nn, log2_base2k, res, res_size, res_sl, a, a_range_begin,
234 a_range_xend, a_range_step, tmp_space);
235}
236
237/** @brief returns the minimal byte length of scratch space for vec_znx_big_range_normalize_base2k */
238EXPORT uint64_t vec_znx_big_range_normalize_base2k_tmp_bytes( //
239 const MODULE* module, // MODULE
240 uint64_t nn // N
241) {
242 return module->func.vec_znx_big_range_normalize_base2k_tmp_bytes(module, nn);
243}
244
245EXPORT void fft64_vec_znx_big_normalize_base2k(const MODULE* module, // MODULE
246 uint64_t nn, // N
247 uint64_t k, // base-2^k
248 int64_t* res, uint64_t res_size, uint64_t res_sl, // res
249 const VEC_ZNX_BIG* a, uint64_t a_size, // a
250 uint8_t* tmp_space) {
251 uint64_t a_sl = nn;
252 module->func.vec_znx_normalize_base2k(module, // N
253 nn,
254 k, // log2_base2k
255 res, res_size, res_sl, // res
256 (int64_t*)a, a_size, a_sl, // a
257 tmp_space);
258}
259
260EXPORT void fft64_vec_znx_big_range_normalize_base2k( //
261 const MODULE* module, // MODULE
262 uint64_t nn, // N
263 uint64_t k, // base-2^k
264 int64_t* res, uint64_t res_size, uint64_t res_sl, // res
265 const VEC_ZNX_BIG* a, uint64_t a_begin, uint64_t a_end, uint64_t a_step, // a
266 uint8_t* tmp_space) {
267 // convert the range indexes to int64[] slices
268 const int64_t* a_st = ((int64_t*)a) + nn * a_begin;
269 const uint64_t a_size = (a_end + a_step - 1 - a_begin) / a_step;
270 const uint64_t a_sl = nn * a_step;
271 // forward the call
272 module->func.vec_znx_normalize_base2k(module, // MODULE
273 nn, // N
274 k, // log2_base2k
275 res, res_size, res_sl, // res
276 a_st, a_size, a_sl, // a
277 tmp_space);
278}