void mpn_toom6h_mul (mp_ptr pp, mp_srcptr ap, mp_size_t an, mp_srcptr bp, mp_size_t bn, mp_ptr scratch) { mp_size_t n, s, t; int p, q, half; int sign; /***************************** decomposition *******************************/ ASSERT (an >= bn); /* Can not handle too much unbalancement */ ASSERT (bn >= 42); /* Can not handle too much unbalancement */ ASSERT ((an*3 < bn * 8) || (bn >= 46 && an * 6 < bn * 17)); /* Limit num/den is a rational number between (12/11)^(log(4)/log(2*4-1)) and (12/11)^(log(6)/log(2*6-1)) */ #define LIMIT_numerator (18) #define LIMIT_denominat (17) if (LIKELY (an * LIMIT_denominat < LIMIT_numerator * bn)) /* is 6*... < 6*... */ { n = 1 + (an - 1) / (size_t) 6; p = q = 5; half = 0; s = an - 5 * n; t = bn - 5 * n; } else { if (an * 5 * LIMIT_numerator < LIMIT_denominat * 7 * bn) { p = 7; q = 6; } else if (an * 5 * LIMIT_denominat < LIMIT_numerator * 7 * bn) { p = 7; q = 5; } else if (an * LIMIT_numerator < LIMIT_denominat * 2 * bn) /* is 4*... < 8*... */ { p = 8; q = 5; } else if (an * LIMIT_denominat < LIMIT_numerator * 2 * bn) /* is 4*... < 8*... */ { p = 8; q = 4; } else { p = 9; q = 4; } half = (p ^ q) & 1; n = 1 + (q * an >= p * bn ? (an - 1) / (size_t) p : (bn - 1) / (size_t) q); p--; q--; s = an - p * n; t = bn - q * n; /* With LIMIT = 16/15, the following recover is needed only if bn<=73*/ if (half) { /* Recover from badly chosen splitting */ if (UNLIKELY (s<1)) {p--; s+=n; half=0;} else if (UNLIKELY (t<1)) {q--; t+=n; half=0;} } } #undef LIMIT_numerator #undef LIMIT_denominat ASSERT (0 < s && s <= n); ASSERT (0 < t && t <= n); ASSERT (half || s + t > 3); ASSERT (n > 2); #define r4 (pp + 3 * n) /* 3n+1 */ #define r2 (pp + 7 * n) /* 3n+1 */ #define r0 (pp +11 * n) /* s+t <= 2*n */ #define r5 (scratch) /* 3n+1 */ #define r3 (scratch + 3 * n + 1) /* 3n+1 */ #define r1 (scratch + 6 * n + 2) /* 3n+1 */ #define v0 (pp + 7 * n) /* n+1 */ #define v1 (pp + 8 * n+1) /* n+1 */ #define v2 (pp + 9 * n+2) /* n+1 */ #define v3 (scratch + 9 * n + 3) /* n+1 */ #define wsi (scratch + 9 * n + 3) /* 3n+1 */ #define wse (scratch +10 * n + 4) /* 2n+1 */ /* Alloc also 3n+1 limbs for wsi... toom_interpolate_12pts may need all of them */ /* if (scratch == NULL) */ /* scratch = TMP_SALLOC_LIMBS(mpn_toom6_sqr_itch(n * 6)); */ ASSERT (12 * n + 6 <= mpn_toom6h_mul_itch(an,bn)); ASSERT (12 * n + 6 <= mpn_toom6_sqr_itch(n * 6)); /********************** evaluation and recursive calls *********************/ /* $\pm1/2$ */ sign = mpn_toom_eval_pm2rexp (v2, v0, p, ap, n, s, 1, pp) ^ mpn_toom_eval_pm2rexp (v3, v1, q, bp, n, t, 1, pp); /* A(-1/2)*B(-1/2)*2^. */ /* A(+1/2)*B(+1/2)*2^. */ TOOM6H_MUL_N_REC(pp, v0, v1, 2, r5, v2, v3, n + 1, wse); mpn_toom_couple_handling (r5, 2 * n + 1, pp, sign, n, 1+half , half); /* $\pm1$ */ sign = mpn_toom_eval_pm1 (v2, v0, p, ap, n, s, pp); if (UNLIKELY (q == 3)) sign ^= mpn_toom_eval_dgr3_pm1 (v3, v1, bp, n, t, pp); else sign ^= mpn_toom_eval_pm1 (v3, v1, q, bp, n, t, pp); /* A(-1)*B(-1) */ /* A(1)*B(1) */ TOOM6H_MUL_N_REC(pp, v0, v1, 2, r3, v2, v3, n + 1, wse); mpn_toom_couple_handling (r3, 2 * n + 1, pp, sign, n, 0, 0); /* $\pm4$ */ sign = mpn_toom_eval_pm2exp (v2, v0, p, ap, n, s, 2, pp) ^ mpn_toom_eval_pm2exp (v3, v1, q, bp, n, t, 2, pp); /* A(-4)*B(-4) */ TOOM6H_MUL_N_REC(pp, v0, v1, 2, r1, v2, v3, n + 1, wse); /* A(+4)*B(+4) */ mpn_toom_couple_handling (r1, 2 * n + 1, pp, sign, n, 2, 4); /* $\pm1/4$ */ sign = mpn_toom_eval_pm2rexp (v2, v0, p, ap, n, s, 2, pp) ^ mpn_toom_eval_pm2rexp (v3, v1, q, bp, n, t, 2, pp); /* A(-1/4)*B(-1/4)*4^. */ /* A(+1/4)*B(+1/4)*4^. */ TOOM6H_MUL_N_REC(pp, v0, v1, 2, r4, v2, v3, n + 1, wse); mpn_toom_couple_handling (r4, 2 * n + 1, pp, sign, n, 2*(1+half), 2*(half)); /* $\pm2$ */ sign = mpn_toom_eval_pm2 (v2, v0, p, ap, n, s, pp) ^ mpn_toom_eval_pm2 (v3, v1, q, bp, n, t, pp); /* A(-2)*B(-2) */ /* A(+2)*B(+2) */ TOOM6H_MUL_N_REC(pp, v0, v1, 2, r2, v2, v3, n + 1, wse); mpn_toom_couple_handling (r2, 2 * n + 1, pp, sign, n, 1, 2); #undef v0 #undef v1 #undef v2 #undef v3 #undef wse /* A(0)*B(0) */ TOOM6H_MUL_N_REC(pp, ap, bp, 0, pp, ap, bp, n, wsi); /* Infinity */ if (UNLIKELY (half != 0)) { if (s > t) { TOOM6H_MUL_REC(r0, ap + p * n, s, bp + q * n, t, wsi); } else { TOOM6H_MUL_REC(r0, bp + q * n, t, ap + p * n, s, wsi); }; }; mpn_toom_interpolate_12pts (pp, r1, r3, r5, n, s+t, half, wsi); #undef r0 #undef r1 #undef r2 #undef r3 #undef r4 #undef r5 #undef wsi }
void mpn_sqr (mp_ptr p, mp_srcptr a, mp_size_t n) { ASSERT (n >= 1); ASSERT (! MPN_OVERLAP_P (p, 2 * n, a, n)); if (BELOW_THRESHOLD (n, SQR_BASECASE_THRESHOLD)) { /* mul_basecase is faster than sqr_basecase on small sizes sometimes */ mpn_mul_basecase (p, a, n, a, n); } else if (BELOW_THRESHOLD (n, SQR_TOOM2_THRESHOLD)) { mpn_sqr_basecase (p, a, n); } else if (BELOW_THRESHOLD (n, SQR_TOOM3_THRESHOLD)) { /* Allocate workspace of fixed size on stack: fast! */ mp_limb_t ws[mpn_toom2_sqr_itch (SQR_TOOM3_THRESHOLD_LIMIT-1)]; ASSERT (SQR_TOOM3_THRESHOLD <= SQR_TOOM3_THRESHOLD_LIMIT); mpn_toom2_sqr (p, a, n, ws); } else if (BELOW_THRESHOLD (n, SQR_TOOM4_THRESHOLD)) { mp_ptr ws; TMP_SDECL; TMP_SMARK; ws = TMP_SALLOC_LIMBS (mpn_toom3_sqr_itch (n)); mpn_toom3_sqr (p, a, n, ws); TMP_SFREE; } else if (BELOW_THRESHOLD (n, SQR_TOOM6_THRESHOLD)) { mp_ptr ws; TMP_SDECL; TMP_SMARK; ws = TMP_SALLOC_LIMBS (mpn_toom4_sqr_itch (n)); mpn_toom4_sqr (p, a, n, ws); TMP_SFREE; } else if (BELOW_THRESHOLD (n, SQR_TOOM8_THRESHOLD)) { mp_ptr ws; TMP_SDECL; TMP_SMARK; ws = TMP_SALLOC_LIMBS (mpn_toom6_sqr_itch (n)); mpn_toom6_sqr (p, a, n, ws); TMP_SFREE; } else if (BELOW_THRESHOLD (n, SQR_FFT_THRESHOLD)) { mp_ptr ws; TMP_DECL; TMP_MARK; ws = TMP_ALLOC_LIMBS (mpn_toom8_sqr_itch (n)); mpn_toom8_sqr (p, a, n, ws); TMP_FREE; } else { /* The current FFT code allocates its own space. That should probably change. */ mpn_fft_mul (p, a, n, a, n); } }