toom52_mul.c
上传用户:qaz666999
上传日期:2022-08-06
资源大小:2570k
文件大小:6k
源码类别:

数学计算

开发平台:

Unix_Linux

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