1 /* mpn_toom52_mul -- Multiply {ap,an} and {bp,bn} where an is nominally 4/3
2 times as large as bn. Or more accurately, bn < an < 2 bn.
3
4 Contributed to the GNU project by Marco Bodrato.
5
6 The idea of applying toom to unbalanced multiplication is due to Marco
7 Bodrato and Alberto Zanoni.
8
9 THE FUNCTION IN THIS FILE IS INTERNAL WITH A MUTABLE INTERFACE. IT IS ONLY
10 SAFE TO REACH IT THROUGH DOCUMENTED INTERFACES. IN FACT, IT IS ALMOST
11 GUARANTEED THAT IT WILL CHANGE OR DISAPPEAR IN A FUTURE GNU MP RELEASE.
12
13 Copyright 2009 Free Software Foundation, Inc.
14
15 This file is part of the GNU MP Library.
16
17 The GNU MP Library is free software; you can redistribute it and/or modify
18 it under the terms of the GNU Lesser General Public License as published by
19 the Free Software Foundation; either version 3 of the License, or (at your
20 option) any later version.
21
22 The GNU MP Library is distributed in the hope that it will be useful, but
23 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
24 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
25 License for more details.
26
27 You should have received a copy of the GNU Lesser General Public License
28 along with the GNU MP Library. If not, see http://www.gnu.org/licenses/. */
29
30
31 #include "gmp.h"
32 #include "gmp-impl.h"
33
34 /* Evaluate in: -2, -1, 0, +1, +2, +inf
35
36 <-s-><--n--><--n--><--n--><--n-->
37 ___ ______ ______ ______ ______
38 |a4_|___a3_|___a2_|___a1_|___a0_|
39 |b1|___b0_|
40 <t-><--n-->
41
42 v0 = a0 * b0 # A(0)*B(0)
43 v1 = (a0+ a1+ a2+ a3+ a4)*(b0+ b1) # A(1)*B(1) ah <= 4 bh <= 1
44 vm1 = (a0- a1+ a2- a3+ a4)*(b0- b1) # A(-1)*B(-1) |ah| <= 2 bh = 0
45 v2 = (a0+2a1+4a2+8a3+16a4)*(b0+2b1) # A(2)*B(2) ah <= 30 bh <= 2
46 vm2 = (a0-2a1+4a2-8a3+16a4)*(b0-2b1) # A(-2)*B(-2) |ah| <= 20 |bh|<= 1
47 vinf= a4 * b1 # A(inf)*B(inf)
48
49 Some slight optimization in evaluation are taken from the paper:
50 "Towards Optimal Toom-Cook Multiplication for Univariate and
51 Multivariate Polynomials in Characteristic 2 and 0."
52 */
53
54 void
mpn_toom52_mul(mp_ptr pp,mp_srcptr ap,mp_size_t an,mp_srcptr bp,mp_size_t bn,mp_ptr scratch)55 mpn_toom52_mul (mp_ptr pp,
56 mp_srcptr ap, mp_size_t an,
57 mp_srcptr bp, mp_size_t bn, mp_ptr scratch)
58 {
59 mp_size_t n, s, t;
60 enum toom6_flags flags;
61
62 #define a0 ap
63 #define a1 (ap + n)
64 #define a2 (ap + 2 * n)
65 #define a3 (ap + 3 * n)
66 #define a4 (ap + 4 * n)
67 #define b0 bp
68 #define b1 (bp + n)
69
70 n = 1 + (2 * an >= 5 * bn ? (an - 1) / (size_t) 5 : (bn - 1) >> 1);
71
72 s = an - 4 * n;
73 t = bn - n;
74
75 ASSERT (0 < s && s <= n);
76 ASSERT (0 < t && t <= n);
77
78 /* Ensures that 5 values of n+1 limbs each fits in the product area.
79 Borderline cases are an = 32, bn = 8, n = 7, and an = 36, bn = 9,
80 n = 8. */
81 ASSERT (s+t >= 5);
82
83 #define v0 pp /* 2n */
84 #define vm1 (scratch) /* 2n+1 */
85 #define v1 (pp + 2 * n) /* 2n+1 */
86 #define vm2 (scratch + 2 * n + 1) /* 2n+1 */
87 #define v2 (scratch + 4 * n + 2) /* 2n+1 */
88 #define vinf (pp + 5 * n) /* s+t */
89 #define bs1 pp /* n+1 */
90 #define bsm1 (scratch + 2 * n + 2) /* n */
91 #define asm1 (scratch + 3 * n + 3) /* n+1 */
92 #define asm2 (scratch + 4 * n + 4) /* n+1 */
93 #define bsm2 (pp + n + 1) /* n+1 */
94 #define bs2 (pp + 2 * n + 2) /* n+1 */
95 #define as2 (pp + 3 * n + 3) /* n+1 */
96 #define as1 (pp + 4 * n + 4) /* n+1 */
97
98 /* Scratch need is 6 * n + 3 + 1. We need one extra limb, because
99 products will overwrite 2n+2 limbs. */
100
101 #define a0a2 scratch
102 #define a1a3 asm1
103
104 /* Compute as2 and asm2. */
105 flags = toom6_vm2_neg & mpn_toom_eval_pm2 (as2, asm2, 4, ap, n, s, a1a3);
106
107 /* Compute bs1 and bsm1. */
108 if (t == n)
109 {
110 #if HAVE_NATIVE_mpn_add_n_sub_n
111 mp_limb_t cy;
112
113 if (mpn_cmp (b0, b1, n) < 0)
114 {
115 cy = mpn_add_n_sub_n (bs1, bsm1, b1, b0, n);
116 flags ^= toom6_vm1_neg;
117 }
118 else
119 {
120 cy = mpn_add_n_sub_n (bs1, bsm1, b0, b1, n);
121 }
122 bs1[n] = cy >> 1;
123 #else
124 bs1[n] = mpn_add_n (bs1, b0, b1, n);
125 if (mpn_cmp (b0, b1, n) < 0)
126 {
127 mpn_sub_n (bsm1, b1, b0, n);
128 flags ^= toom6_vm1_neg;
129 }
130 else
131 {
132 mpn_sub_n (bsm1, b0, b1, n);
133 }
134 #endif
135 }
136 else
137 {
138 bs1[n] = mpn_add (bs1, b0, n, b1, t);
139 if (mpn_zero_p (b0 + t, n - t) && mpn_cmp (b0, b1, t) < 0)
140 {
141 mpn_sub_n (bsm1, b1, b0, t);
142 MPN_ZERO (bsm1 + t, n - t);
143 flags ^= toom6_vm1_neg;
144 }
145 else
146 {
147 mpn_sub (bsm1, b0, n, b1, t);
148 }
149 }
150
151 /* Compute bs2 and bsm2, recycling bs1 and bsm1. bs2=bs1+b1; bsm2=bsm1-b1 */
152 mpn_add (bs2, bs1, n+1, b1, t);
153 if (flags & toom6_vm1_neg )
154 {
155 bsm2[n] = mpn_add (bsm2, bsm1, n, b1, t);
156 flags ^= toom6_vm2_neg;
157 }
158 else
159 {
160 bsm2[n] = 0;
161 if (t == n)
162 {
163 if (mpn_cmp (bsm1, b1, n) < 0)
164 {
165 mpn_sub_n (bsm2, b1, bsm1, n);
166 flags ^= toom6_vm2_neg;
167 }
168 else
169 {
170 mpn_sub_n (bsm2, bsm1, b1, n);
171 }
172 }
173 else
174 {
175 if (mpn_zero_p (bsm1 + t, n - t) && mpn_cmp (bsm1, b1, t) < 0)
176 {
177 mpn_sub_n (bsm2, b1, bsm1, t);
178 MPN_ZERO (bsm2 + t, n - t);
179 flags ^= toom6_vm2_neg;
180 }
181 else
182 {
183 mpn_sub (bsm2, bsm1, n, b1, t);
184 }
185 }
186 }
187
188 /* Compute as1 and asm1. */
189 flags ^= toom6_vm1_neg & mpn_toom_eval_pm1 (as1, asm1, 4, ap, n, s, a0a2);
190
191 ASSERT (as1[n] <= 4);
192 ASSERT (bs1[n] <= 1);
193 ASSERT (asm1[n] <= 2);
194 /* ASSERT (bsm1[n] <= 1); */
195 ASSERT (as2[n] <=30);
196 ASSERT (bs2[n] <= 2);
197 ASSERT (asm2[n] <= 20);
198 ASSERT (bsm2[n] <= 1);
199
200 /* vm1, 2n+1 limbs */
201 mpn_mul (vm1, asm1, n+1, bsm1, n); /* W4 */
202
203 /* vm2, 2n+1 limbs */
204 mpn_mul_n (vm2, asm2, bsm2, n+1); /* W2 */
205
206 /* v2, 2n+1 limbs */
207 mpn_mul_n (v2, as2, bs2, n+1); /* W1 */
208
209 /* v1, 2n+1 limbs */
210 mpn_mul_n (v1, as1, bs1, n+1); /* W3 */
211
212 /* vinf, s+t limbs */ /* W0 */
213 if (s > t) mpn_mul (vinf, a4, s, b1, t);
214 else mpn_mul (vinf, b1, t, a4, s);
215
216 /* v0, 2n limbs */
217 mpn_mul_n (v0, ap, bp, n); /* W5 */
218
219 mpn_toom_interpolate_6pts (pp, n, flags, vm1, vm2, v2, t + s);
220
221 #undef v0
222 #undef vm1
223 #undef v1
224 #undef vm2
225 #undef v2
226 #undef vinf
227 #undef bs1
228 #undef bs2
229 #undef bsm1
230 #undef bsm2
231 #undef asm1
232 #undef asm2
233 #undef as1
234 #undef as2
235 #undef a0a2
236 #undef b0b2
237 #undef a1a3
238 #undef a0
239 #undef a1
240 #undef a2
241 #undef a3
242 #undef b0
243 #undef b1
244 #undef b2
245
246 }
247