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

数学计算

开发平台:

Unix_Linux

  1. /* mpn_powm -- Compute R = U^E mod M.
  2.    Contributed to the GNU project by Torbjorn Granlund.
  3.    THE FUNCTIONS IN THIS FILE ARE INTERNAL WITH MUTABLE INTERFACES.  IT IS ONLY
  4.    SAFE TO REACH THEM THROUGH DOCUMENTED INTERFACES.  IN FACT, IT IS ALMOST
  5.    GUARANTEED THAT THEY WILL CHANGE OR DISAPPEAR IN A FUTURE GNU MP RELEASE.
  6. Copyright 2007, 2008, 2009 Free Software Foundation, Inc.
  7. This file is part of the GNU MP Library.
  8. The GNU MP Library is free software; you can redistribute it and/or modify
  9. it under the terms of the GNU Lesser General Public License as published by
  10. the Free Software Foundation; either version 3 of the License, or (at your
  11. option) any later version.
  12. The GNU MP Library is distributed in the hope that it will be useful, but
  13. WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14. or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  15. License for more details.
  16. You should have received a copy of the GNU Lesser General Public License
  17. along with the GNU MP Library.  If not, see http://www.gnu.org/licenses/.  */
  18. /*
  19.   BASIC ALGORITHM, Compute U^E mod M, where M < B^n is odd.
  20.   1. W <- U
  21.   2. T <- (B^n * U) mod M                Convert to REDC form
  22.   3. Compute table U^1, U^3, U^5... of E-dependent size
  23.   4. While there are more bits in E
  24.        W <- power left-to-right base-k
  25.   TODO:
  26.    * Make getbits a macro, thereby allowing it to update the index operand.
  27.      That will simplify the code using getbits.  (Perhaps make getbits' sibling
  28.      getbit then have similar form, for symmetry.)
  29.    * Write an itch function.  Or perhaps get rid of tp parameter since the huge
  30.      pp area is allocated locally anyway?
  31.    * Choose window size without looping.  (Superoptimize or think(tm).)
  32.    * Handle small bases with initial, reduction-free exponentiation.
  33.    * Call new division functions, not mpn_tdiv_qr.
  34.    * Consider special code for one-limb M.
  35.    * How should we handle the redc1/redc2/redc_n choice?
  36.      - redc1:  T(binvert_1limb)  + e * (n)   * (T(mullo-1x1) + n*T(addmul_1))
  37.      - redc2:  T(binvert_2limbs) + e * (n/2) * (T(mullo-2x2) + n*T(addmul_2))
  38.      - redc_n: T(binvert_nlimbs) + e * (T(mullo-nxn) + T(M(n)))
  39.      This disregards the addmul_N constant term, but we could think of
  40.      that as part of the respective mullo.
  41.    * When U (the base) is small, we should start the exponentiation with plain
  42.      operations, then convert that partial result to REDC form.
  43.    * When U is just one limb, should it be handled without the k-ary tricks?
  44.      We could keep a factor of B^n in W, but use U' = BU as base.  After
  45.      multiplying by this (pseudo two-limb) number, we need to multiply by 1/B
  46.      mod M.
  47. */
  48. #include "gmp.h"
  49. #include "gmp-impl.h"
  50. #include "longlong.h"
  51. #if HAVE_NATIVE_mpn_addmul_2 || HAVE_NATIVE_mpn_redc_2
  52. #define WANT_REDC_2 1
  53. #endif
  54. #define getbit(p,bi) 
  55.   ((p[(bi - 1) / GMP_LIMB_BITS] >> (bi - 1) % GMP_LIMB_BITS) & 1)
  56. static inline mp_limb_t
  57. getbits (const mp_limb_t *p, mp_bitcnt_t bi, int nbits)
  58. {
  59.   int nbits_in_r;
  60.   mp_limb_t r;
  61.   mp_size_t i;
  62.   if (bi < nbits)
  63.     {
  64.       return p[0] & (((mp_limb_t) 1 << bi) - 1);
  65.     }
  66.   else
  67.     {
  68.       bi -= nbits; /* bit index of low bit to extract */
  69.       i = bi / GMP_NUMB_BITS; /* word index of low bit to extract */
  70.       bi %= GMP_NUMB_BITS; /* bit index in low word */
  71.       r = p[i] >> bi; /* extract (low) bits */
  72.       nbits_in_r = GMP_NUMB_BITS - bi; /* number of bits now in r */
  73.       if (nbits_in_r < nbits) /* did we get enough bits? */
  74. r += p[i + 1] << nbits_in_r; /* prepend bits from higher word */
  75.       return r & (((mp_limb_t ) 1 << nbits) - 1);
  76.     }
  77. }
  78. static inline int
  79. win_size (mp_bitcnt_t eb)
  80. {
  81.   int k;
  82.   static mp_bitcnt_t x[] = {0,7,25,81,241,673,1793,4609,11521,28161,~(mp_bitcnt_t)0};
  83.   for (k = 1; eb > x[k]; k++)
  84.     ;
  85.   return k;
  86. }
  87. /* Convert U to REDC form, U_r = B^n * U mod M */
  88. static void
  89. redcify (mp_ptr rp, mp_srcptr up, mp_size_t un, mp_srcptr mp, mp_size_t n)
  90. {
  91.   mp_ptr tp, qp;
  92.   TMP_DECL;
  93.   TMP_MARK;
  94.   tp = TMP_ALLOC_LIMBS (un + n);
  95.   qp = TMP_ALLOC_LIMBS (un + 1); /* FIXME: Put at tp+? */
  96.   MPN_ZERO (tp, n);
  97.   MPN_COPY (tp + n, up, un);
  98.   mpn_tdiv_qr (qp, rp, 0L, tp, un + n, mp, n);
  99.   TMP_FREE;
  100. }
  101. /* rp[n-1..0] = bp[bn-1..0] ^ ep[en-1..0] mod mp[n-1..0]
  102.    Requires that mp[n-1..0] is odd.
  103.    Requires that ep[en-1..0] is > 1.
  104.    Uses scratch space at tp of MAX(mpn_binvert_itch(n),2n) limbs.  */
  105. void
  106. mpn_powm (mp_ptr rp, mp_srcptr bp, mp_size_t bn,
  107.   mp_srcptr ep, mp_size_t en,
  108.   mp_srcptr mp, mp_size_t n, mp_ptr tp)
  109. {
  110.   mp_limb_t ip[2], *mip;
  111.   int cnt;
  112.   mp_bitcnt_t ebi;
  113.   int windowsize, this_windowsize;
  114.   mp_limb_t expbits;
  115.   mp_ptr pp, this_pp;
  116.   long i;
  117.   TMP_DECL;
  118.   ASSERT (en > 1 || (en == 1 && ep[0] > 1));
  119.   ASSERT (n >= 1 && ((mp[0] & 1) != 0));
  120.   TMP_MARK;
  121.   count_leading_zeros (cnt, ep[en - 1]);
  122.   ebi = (mp_bitcnt_t) en * GMP_LIMB_BITS - cnt;
  123. #if 0
  124.   if (bn < n)
  125.     {
  126.       /* Do the first few exponent bits without mod reductions,
  127.  until the result is greater than the mod argument.  */
  128.       for (;;)
  129. {
  130.   mpn_sqr (tp, this_pp, tn);
  131.   tn = tn * 2 - 1,  tn += tp[tn] != 0;
  132.   if (getbit (ep, ebi) != 0)
  133.     mpn_mul (..., tp, tn, bp, bn);
  134.   ebi--;
  135. }
  136.     }
  137. #endif
  138.   windowsize = win_size (ebi);
  139. #if WANT_REDC_2
  140.   if (BELOW_THRESHOLD (n, REDC_1_TO_REDC_2_THRESHOLD))
  141.     {
  142.       mip = ip;
  143.       binvert_limb (mip[0], mp[0]);
  144.       mip[0] = -mip[0];
  145.     }
  146.   else if (BELOW_THRESHOLD (n, REDC_2_TO_REDC_N_THRESHOLD))
  147.     {
  148.       mip = ip;
  149.       mpn_binvert (mip, mp, 2, tp);
  150.       mip[0] = -mip[0]; mip[1] = ~mip[1];
  151.     }
  152. #else
  153.   if (BELOW_THRESHOLD (n, REDC_1_TO_REDC_N_THRESHOLD))
  154.     {
  155.       mip = ip;
  156.       binvert_limb (mip[0], mp[0]);
  157.       mip[0] = -mip[0];
  158.     }
  159. #endif
  160.   else
  161.     {
  162.       mip = TMP_ALLOC_LIMBS (n);
  163.       mpn_binvert (mip, mp, n, tp);
  164.     }
  165.   pp = TMP_ALLOC_LIMBS (n << (windowsize - 1));
  166.   this_pp = pp;
  167.   redcify (this_pp, bp, bn, mp, n);
  168.   /* Store b^2 at rp.  */
  169.   mpn_sqr (tp, this_pp, n);
  170. #if WANT_REDC_2
  171.   if (BELOW_THRESHOLD (n, REDC_1_TO_REDC_2_THRESHOLD))
  172.     mpn_redc_1 (rp, tp, mp, n, mip[0]);
  173.   else if (BELOW_THRESHOLD (n, REDC_2_TO_REDC_N_THRESHOLD))
  174.     mpn_redc_2 (rp, tp, mp, n, mip);
  175. #else
  176.   if (BELOW_THRESHOLD (n, REDC_1_TO_REDC_N_THRESHOLD))
  177.     mpn_redc_1 (rp, tp, mp, n, mip[0]);
  178. #endif
  179.   else
  180.     mpn_redc_n (rp, tp, mp, n, mip);
  181.   /* Precompute odd powers of b and put them in the temporary area at pp.  */
  182.   for (i = (1 << (windowsize - 1)) - 1; i > 0; i--)
  183.     {
  184.       mpn_mul_n (tp, this_pp, rp, n);
  185.       this_pp += n;
  186. #if WANT_REDC_2
  187.       if (BELOW_THRESHOLD (n, REDC_1_TO_REDC_2_THRESHOLD))
  188. mpn_redc_1 (this_pp, tp, mp, n, mip[0]);
  189.       else if (BELOW_THRESHOLD (n, REDC_2_TO_REDC_N_THRESHOLD))
  190. mpn_redc_2 (this_pp, tp, mp, n, mip);
  191. #else
  192.       if (BELOW_THRESHOLD (n, REDC_1_TO_REDC_N_THRESHOLD))
  193. mpn_redc_1 (this_pp, tp, mp, n, mip[0]);
  194. #endif
  195.       else
  196. mpn_redc_n (this_pp, tp, mp, n, mip);
  197.     }
  198.   expbits = getbits (ep, ebi, windowsize);
  199.   if (ebi < windowsize)
  200.     ebi = 0;
  201.   else
  202.     ebi -= windowsize;
  203.   count_trailing_zeros (cnt, expbits);
  204.   ebi += cnt;
  205.   expbits >>= cnt;
  206.   MPN_COPY (rp, pp + n * (expbits >> 1), n);
  207. #define INNERLOOP
  208.   while (ebi != 0)
  209.     {
  210.       while (getbit (ep, ebi) == 0)
  211. {
  212.   MPN_SQR (tp, rp, n);
  213.   MPN_REDUCE (rp, tp, mp, n, mip);
  214.   ebi--;
  215.   if (ebi == 0)
  216.     goto done;
  217. }
  218.       /* The next bit of the exponent is 1.  Now extract the largest
  219.  block of bits <= windowsize, and such that the least
  220.  significant bit is 1.  */
  221.       expbits = getbits (ep, ebi, windowsize);
  222.       this_windowsize = windowsize;
  223.       if (ebi < windowsize)
  224. {
  225.   this_windowsize -= windowsize - ebi;
  226.   ebi = 0;
  227. }
  228.       else
  229.         ebi -= windowsize;
  230.       count_trailing_zeros (cnt, expbits);
  231.       this_windowsize -= cnt;
  232.       ebi += cnt;
  233.       expbits >>= cnt;
  234.       do
  235. {
  236.   MPN_SQR (tp, rp, n);
  237.   MPN_REDUCE (rp, tp, mp, n, mip);
  238.   this_windowsize--;
  239. }
  240.       while (this_windowsize != 0);
  241.       MPN_MUL_N (tp, rp, pp + n * (expbits >> 1), n);
  242.       MPN_REDUCE (rp, tp, mp, n, mip);
  243.     }
  244. #if WANT_REDC_2
  245.   if (REDC_1_TO_REDC_2_THRESHOLD < MUL_TOOM22_THRESHOLD)
  246.     {
  247.       if (BELOW_THRESHOLD (n, REDC_1_TO_REDC_2_THRESHOLD))
  248. {
  249. #undef MPN_MUL_N
  250. #undef MPN_SQR
  251. #undef MPN_REDUCE
  252. #define MPN_MUL_N(r,a,b,n) mpn_mul_basecase (r,a,n,b,n)
  253. #define MPN_SQR(r,a,n) mpn_sqr_basecase (r,a,n)
  254. #define MPN_REDUCE(rp,tp,mp,n,mip) mpn_redc_1 (rp, tp, mp, n, mip[0])
  255.   INNERLOOP;
  256. }
  257.       else if (BELOW_THRESHOLD (n, MUL_TOOM22_THRESHOLD))
  258. {
  259. #undef MPN_MUL_N
  260. #undef MPN_SQR
  261. #undef MPN_REDUCE
  262. #define MPN_MUL_N(r,a,b,n) mpn_mul_basecase (r,a,n,b,n)
  263. #define MPN_SQR(r,a,n) mpn_sqr_basecase (r,a,n)
  264. #define MPN_REDUCE(rp,tp,mp,n,mip) mpn_redc_2 (rp, tp, mp, n, mip)
  265.   INNERLOOP;
  266. }
  267.       else if (BELOW_THRESHOLD (n, REDC_2_TO_REDC_N_THRESHOLD))
  268. {
  269. #undef MPN_MUL_N
  270. #undef MPN_SQR
  271. #undef MPN_REDUCE
  272. #define MPN_MUL_N(r,a,b,n) mpn_mul_n (r,a,b,n)
  273. #define MPN_SQR(r,a,n) mpn_sqr (r,a,n)
  274. #define MPN_REDUCE(rp,tp,mp,n,mip) mpn_redc_2 (rp, tp, mp, n, mip)
  275.   INNERLOOP;
  276. }
  277.       else
  278. {
  279. #undef MPN_MUL_N
  280. #undef MPN_SQR
  281. #undef MPN_REDUCE
  282. #define MPN_MUL_N(r,a,b,n) mpn_mul_n (r,a,b,n)
  283. #define MPN_SQR(r,a,n) mpn_sqr (r,a,n)
  284. #define MPN_REDUCE(rp,tp,mp,n,mip) mpn_redc_n (rp, tp, mp, n, mip)
  285.   INNERLOOP;
  286. }
  287.     }
  288.   else
  289.     {
  290.       if (BELOW_THRESHOLD (n, MUL_TOOM22_THRESHOLD))
  291. {
  292. #undef MPN_MUL_N
  293. #undef MPN_SQR
  294. #undef MPN_REDUCE
  295. #define MPN_MUL_N(r,a,b,n) mpn_mul_basecase (r,a,n,b,n)
  296. #define MPN_SQR(r,a,n) mpn_sqr_basecase (r,a,n)
  297. #define MPN_REDUCE(rp,tp,mp,n,mip) mpn_redc_1 (rp, tp, mp, n, mip[0])
  298.   INNERLOOP;
  299. }
  300.       else if (BELOW_THRESHOLD (n, REDC_1_TO_REDC_2_THRESHOLD))
  301. {
  302. #undef MPN_MUL_N
  303. #undef MPN_SQR
  304. #undef MPN_REDUCE
  305. #define MPN_MUL_N(r,a,b,n) mpn_mul_n (r,a,b,n)
  306. #define MPN_SQR(r,a,n) mpn_sqr (r,a,n)
  307. #define MPN_REDUCE(rp,tp,mp,n,mip) mpn_redc_1 (rp, tp, mp, n, mip[0])
  308.   INNERLOOP;
  309. }
  310.       else if (BELOW_THRESHOLD (n, REDC_2_TO_REDC_N_THRESHOLD))
  311. {
  312. #undef MPN_MUL_N
  313. #undef MPN_SQR
  314. #undef MPN_REDUCE
  315. #define MPN_MUL_N(r,a,b,n) mpn_mul_n (r,a,b,n)
  316. #define MPN_SQR(r,a,n) mpn_sqr (r,a,n)
  317. #define MPN_REDUCE(rp,tp,mp,n,mip) mpn_redc_2 (rp, tp, mp, n, mip)
  318.   INNERLOOP;
  319. }
  320.       else
  321. {
  322. #undef MPN_MUL_N
  323. #undef MPN_SQR
  324. #undef MPN_REDUCE
  325. #define MPN_MUL_N(r,a,b,n) mpn_mul_n (r,a,b,n)
  326. #define MPN_SQR(r,a,n) mpn_sqr (r,a,n)
  327. #define MPN_REDUCE(rp,tp,mp,n,mip) mpn_redc_n (rp, tp, mp, n, mip)
  328.   INNERLOOP;
  329. }
  330.     }
  331. #else  /* WANT_REDC_2 */
  332.   if (REDC_1_TO_REDC_N_THRESHOLD < MUL_TOOM22_THRESHOLD)
  333.     {
  334.       if (BELOW_THRESHOLD (n, REDC_1_TO_REDC_N_THRESHOLD))
  335. {
  336. #undef MPN_MUL_N
  337. #undef MPN_SQR
  338. #undef MPN_REDUCE
  339. #define MPN_MUL_N(r,a,b,n) mpn_mul_basecase (r,a,n,b,n)
  340. #define MPN_SQR(r,a,n) mpn_sqr_basecase (r,a,n)
  341. #define MPN_REDUCE(rp,tp,mp,n,mip) mpn_redc_1 (rp, tp, mp, n, mip[0])
  342.   INNERLOOP;
  343. }
  344.       else if (BELOW_THRESHOLD (n, MUL_TOOM22_THRESHOLD))
  345. {
  346. #undef MPN_MUL_N
  347. #undef MPN_SQR
  348. #undef MPN_REDUCE
  349. #define MPN_MUL_N(r,a,b,n) mpn_mul_basecase (r,a,n,b,n)
  350. #define MPN_SQR(r,a,n) mpn_sqr_basecase (r,a,n)
  351. #define MPN_REDUCE(rp,tp,mp,n,mip) mpn_redc_n (rp, tp, mp, n, mip)
  352.   INNERLOOP;
  353. }
  354.       else
  355. {
  356. #undef MPN_MUL_N
  357. #undef MPN_SQR
  358. #undef MPN_REDUCE
  359. #define MPN_MUL_N(r,a,b,n) mpn_mul_n (r,a,b,n)
  360. #define MPN_SQR(r,a,n) mpn_sqr (r,a,n)
  361. #define MPN_REDUCE(rp,tp,mp,n,mip) mpn_redc_n (rp, tp, mp, n, mip)
  362.   INNERLOOP;
  363. }
  364.     }
  365.   else
  366.     {
  367.       if (BELOW_THRESHOLD (n, MUL_TOOM22_THRESHOLD))
  368. {
  369. #undef MPN_MUL_N
  370. #undef MPN_SQR
  371. #undef MPN_REDUCE
  372. #define MPN_MUL_N(r,a,b,n) mpn_mul_basecase (r,a,n,b,n)
  373. #define MPN_SQR(r,a,n) mpn_sqr_basecase (r,a,n)
  374. #define MPN_REDUCE(rp,tp,mp,n,mip) mpn_redc_1 (rp, tp, mp, n, mip[0])
  375.   INNERLOOP;
  376. }
  377.       else if (BELOW_THRESHOLD (n, REDC_1_TO_REDC_N_THRESHOLD))
  378. {
  379. #undef MPN_MUL_N
  380. #undef MPN_SQR
  381. #undef MPN_REDUCE
  382. #define MPN_MUL_N(r,a,b,n) mpn_mul_n (r,a,b,n)
  383. #define MPN_SQR(r,a,n) mpn_sqr (r,a,n)
  384. #define MPN_REDUCE(rp,tp,mp,n,mip) mpn_redc_1 (rp, tp, mp, n, mip[0])
  385.   INNERLOOP;
  386. }
  387.       else
  388. {
  389. #undef MPN_MUL_N
  390. #undef MPN_SQR
  391. #undef MPN_REDUCE
  392. #define MPN_MUL_N(r,a,b,n) mpn_mul_n (r,a,b,n)
  393. #define MPN_SQR(r,a,n) mpn_sqr (r,a,n)
  394. #define MPN_REDUCE(rp,tp,mp,n,mip) mpn_redc_n (rp, tp, mp, n, mip)
  395.   INNERLOOP;
  396. }
  397.     }
  398. #endif  /* WANT_REDC_2 */
  399.  done:
  400.   MPN_COPY (tp, rp, n);
  401.   MPN_ZERO (tp + n, n);
  402. #if WANT_REDC_2
  403.   if (BELOW_THRESHOLD (n, REDC_1_TO_REDC_2_THRESHOLD))
  404.     mpn_redc_1 (rp, tp, mp, n, mip[0]);
  405.   else if (BELOW_THRESHOLD (n, REDC_2_TO_REDC_N_THRESHOLD))
  406.     mpn_redc_2 (rp, tp, mp, n, mip);
  407. #else
  408.   if (BELOW_THRESHOLD (n, REDC_1_TO_REDC_N_THRESHOLD))
  409.     mpn_redc_1 (rp, tp, mp, n, mip[0]);
  410. #endif
  411.   else
  412.     mpn_redc_n (rp, tp, mp, n, mip);
  413.   if (mpn_cmp (rp, mp, n) >= 0)
  414.     mpn_sub_n (rp, rp, mp, n);
  415.   TMP_FREE;
  416. }