Lines Matching refs:size
21 #define MPN_MUL_N_RECURSE(prodp, up, vp, size, tspace) \
23 if ((size) < KARATSUBA_THRESHOLD) \
24 mul_n_basecase(prodp, up, vp, size); \
26 mul_n(prodp, up, vp, size, tspace); \
29 #define MPN_SQR_N_RECURSE(prodp, up, size, tspace) \
31 if ((size) < KARATSUBA_THRESHOLD) \
32 mpih_sqr_n_basecase(prodp, up, size); \
34 mpih_sqr_n(prodp, up, size, tspace); \
55 mul_n_basecase(mpi_ptr_t prodp, mpi_ptr_t up, mpi_ptr_t vp, mpi_size_t size)
66 MPN_COPY(prodp, up, size);
68 MPN_ZERO(prodp, size);
71 cy = mpihelp_mul_1(prodp, up, size, v_limb);
73 prodp[size] = cy;
78 for (i = 1; i < size; i++) {
83 cy = mpihelp_add_n(prodp, prodp, up, size);
85 cy = mpihelp_addmul_1(prodp, up, size, v_limb);
87 prodp[size] = cy;
96 mpi_size_t size, mpi_ptr_t tspace)
98 if (size & 1) {
99 /* The size is odd, and the code below doesn't handle that.
100 * Multiply the least significant (size - 1) limbs with a recursive
104 * code below behave as if the size were even, and let it check for
105 * odd size in the end. I.e., in essence move this code to the end.
109 mpi_size_t esize = size - 1; /* even size */
115 cy_limb = mpihelp_addmul_1(prodp + esize, vp, size, up[esize]);
116 prodp[esize + size] = cy_limb;
133 mpi_size_t hsize = size >> 1;
142 MPN_MUL_N_RECURSE(prodp + size, up + hsize, vp + hsize, hsize,
167 tspace + size);
170 MPN_COPY(prodp + hsize, prodp + size, hsize);
171 cy = mpihelp_add_n(prodp + size, prodp + size,
172 prodp + size + hsize, hsize);
178 size);
182 size);
190 MPN_MUL_N_RECURSE(tspace, up, vp, hsize, tspace + size);
194 cy += mpihelp_add_n(prodp + hsize, prodp + hsize, tspace, size);
196 mpihelp_add_1(prodp + hsize + size,
197 prodp + hsize + size, hsize, cy);
203 mpihelp_add_1(prodp + size, prodp + size, size, 1);
207 void mpih_sqr_n_basecase(mpi_ptr_t prodp, mpi_ptr_t up, mpi_size_t size)
218 MPN_COPY(prodp, up, size);
220 MPN_ZERO(prodp, size);
223 cy_limb = mpihelp_mul_1(prodp, up, size, v_limb);
225 prodp[size] = cy_limb;
230 for (i = 1; i < size; i++) {
235 cy_limb = mpihelp_add_n(prodp, prodp, up, size);
237 cy_limb = mpihelp_addmul_1(prodp, up, size, v_limb);
239 prodp[size] = cy_limb;
245 mpih_sqr_n(mpi_ptr_t prodp, mpi_ptr_t up, mpi_size_t size, mpi_ptr_t tspace)
247 if (size & 1) {
248 /* The size is odd, and the code below doesn't handle that.
249 * Multiply the least significant (size - 1) limbs with a recursive
253 * code below behave as if the size were even, and let it check for
254 * odd size in the end. I.e., in essence move this code to the end.
258 mpi_size_t esize = size - 1; /* even size */
264 cy_limb = mpihelp_addmul_1(prodp + esize, up, size, up[esize]);
266 prodp[esize + size] = cy_limb;
268 mpi_size_t hsize = size >> 1;
276 MPN_SQR_N_RECURSE(prodp + size, up + hsize, hsize, tspace);
289 MPN_SQR_N_RECURSE(tspace, prodp, hsize, tspace + size);
292 MPN_COPY(prodp + hsize, prodp + size, hsize);
293 cy = mpihelp_add_n(prodp + size, prodp + size,
294 prodp + size + hsize, hsize);
297 cy -= mpihelp_sub_n(prodp + hsize, prodp + hsize, tspace, size);
304 MPN_SQR_N_RECURSE(tspace, up, hsize, tspace + size);
307 cy += mpihelp_add_n(prodp + hsize, prodp + hsize, tspace, size);
309 mpihelp_add_1(prodp + hsize + size,
310 prodp + hsize + size, hsize, cy);
316 mpihelp_add_1(prodp + size, prodp + size, size, 1);
322 mpi_ptr_t up, mpi_ptr_t vp, mpi_size_t size)
325 if (size < KARATSUBA_THRESHOLD)
326 mpih_sqr_n_basecase(prodp, up, size);
329 tspace = mpi_alloc_limb_space(2 * size);
330 mpih_sqr_n(prodp, up, size, tspace);
334 if (size < KARATSUBA_THRESHOLD)
335 mul_n_basecase(prodp, up, vp, size);
338 tspace = mpi_alloc_limb_space(2 * size);
339 mul_n(prodp, up, vp, size, tspace);