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

数学计算

开发平台:

Unix_Linux

  1. /* mpz_n_pow_ui -- mpn raised to ulong.
  2.    THE FUNCTIONS IN THIS FILE ARE FOR INTERNAL USE ONLY.  THEY'RE ALMOST
  3.    CERTAIN TO BE SUBJECT TO INCOMPATIBLE CHANGES OR DISAPPEAR COMPLETELY IN
  4.    FUTURE GNU MP RELEASES.
  5. Copyright 2001, 2002, 2005 Free Software Foundation, Inc.
  6. This file is part of the GNU MP Library.
  7. The GNU MP Library is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU Lesser General Public License as published by
  9. the Free Software Foundation; either version 3 of the License, or (at your
  10. option) any later version.
  11. The GNU MP Library is distributed in the hope that it will be useful, but
  12. WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13. or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  14. License for more details.
  15. You should have received a copy of the GNU Lesser General Public License
  16. along with the GNU MP Library.  If not, see http://www.gnu.org/licenses/.  */
  17. #include "gmp.h"
  18. #include "gmp-impl.h"
  19. #include "longlong.h"
  20. /* Change this to "#define TRACE(x) x" for some traces. */
  21. #define TRACE(x)
  22. /* Use this to test the mul_2 code on a CPU without a native version of that
  23.    routine.  */
  24. #if 0
  25. #define mpn_mul_2  refmpn_mul_2
  26. #define HAVE_NATIVE_mpn_mul_2  1
  27. #endif
  28. /* mpz_pow_ui and mpz_ui_pow_ui want to share almost all of this code.
  29.    ui_pow_ui doesn't need the mpn_mul based powering loop or the tests on
  30.    bsize==2 or >2, but separating that isn't easy because there's shared
  31.    code both before and after (the size calculations and the powers of 2
  32.    handling).
  33.    Alternatives:
  34.    It would work to just use the mpn_mul powering loop for 1 and 2 limb
  35.    bases, but the current separate loop allows mul_1 and mul_2 to be done
  36.    in-place, which might help cache locality a bit.  If mpn_mul was relaxed
  37.    to allow source==dest when vn==1 or 2 then some pointer twiddling might
  38.    let us get the same effect in one loop.
  39.    The initial powering for bsize==1 into blimb or blimb:blimb_low doesn't
  40.    form the biggest possible power of b that fits, only the biggest power of
  41.    2 power, ie. b^(2^n).  It'd be possible to choose a bigger power, perhaps
  42.    using mp_bases[b].big_base for small b, and thereby get better value
  43.    from mpn_mul_1 or mpn_mul_2 in the bignum powering.  It's felt that doing
  44.    so would be more complicated than it's worth, and could well end up being
  45.    a slowdown for small e.  For big e on the other hand the algorithm is
  46.    dominated by mpn_sqr so there wouldn't much of a saving.  The current
  47.    code can be viewed as simply doing the first few steps of the powering in
  48.    a single or double limb where possible.
  49.    If r==b, and blow_twos==0, and r must be realloc'ed, then the temporary
  50.    copy made of b is unnecessary.  We could just use the old alloc'ed block
  51.    and free it at the end.  But arranging this seems like a lot more trouble
  52.    than it's worth.  */
  53. /* floor(sqrt(GMP_NUMB_MAX)), ie. the biggest value that can be squared in
  54.    a limb without overflowing.
  55.    FIXME: This formula is an underestimate when GMP_NUMB_BITS is odd. */
  56. #define GMP_NUMB_HALFMAX  (((mp_limb_t) 1 << GMP_NUMB_BITS/2) - 1)
  57. /* The following are for convenience, they update the size and check the
  58.    alloc.  */
  59. #define MPN_SQR(dst, alloc, src, size)          
  60.   do {                                          
  61.     ASSERT (2*(size) <= (alloc));               
  62.     mpn_sqr (dst, src, size);                   
  63.     (size) *= 2;                                
  64.     (size) -= ((dst)[(size)-1] == 0);           
  65.   } while (0)
  66. #define MPN_MUL(dst, alloc, src, size, src2, size2)     
  67.   do {                                                  
  68.     mp_limb_t  cy;                                      
  69.     ASSERT ((size) + (size2) <= (alloc));               
  70.     cy = mpn_mul (dst, src, size, src2, size2);         
  71.     (size) += (size2) - (cy == 0);                      
  72.   } while (0)
  73. #define MPN_MUL_2(ptr, size, alloc, mult)       
  74.   do {                                          
  75.     mp_limb_t  cy;                              
  76.     ASSERT ((size)+2 <= (alloc));               
  77.     cy = mpn_mul_2 (ptr, ptr, size, mult);      
  78.     (size)++;                                   
  79.     (ptr)[(size)] = cy;                         
  80.     (size) += (cy != 0);                        
  81.   } while (0)
  82. #define MPN_MUL_1(ptr, size, alloc, limb)       
  83.   do {                                          
  84.     mp_limb_t  cy;                              
  85.     ASSERT ((size)+1 <= (alloc));               
  86.     cy = mpn_mul_1 (ptr, ptr, size, limb);      
  87.     (ptr)[size] = cy;                           
  88.     (size) += (cy != 0);                        
  89.   } while (0)
  90. #define MPN_LSHIFT(ptr, size, alloc, shift)     
  91.   do {                                          
  92.     mp_limb_t  cy;                              
  93.     ASSERT ((size)+1 <= (alloc));               
  94.     cy = mpn_lshift (ptr, ptr, size, shift);    
  95.     (ptr)[size] = cy;                           
  96.     (size) += (cy != 0);                        
  97.   } while (0)
  98. #define MPN_RSHIFT_OR_COPY(dst, src, size, shift)       
  99.   do {                                                  
  100.     if ((shift) == 0)                                   
  101.       MPN_COPY (dst, src, size);                        
  102.     else                                                
  103.       {                                                 
  104.         mpn_rshift (dst, src, size, shift);             
  105.         (size) -= ((dst)[(size)-1] == 0);               
  106.       }                                                 
  107.   } while (0)
  108. /* ralloc and talloc are only wanted for ASSERTs, after the initial space
  109.    allocations.  Avoid writing values to them in a normal build, to ensure
  110.    the compiler lets them go dead.  gcc already figures this out itself
  111.    actually.  */
  112. #define SWAP_RP_TP                                      
  113.   do {                                                  
  114.     MP_PTR_SWAP (rp, tp);                               
  115.     ASSERT_CODE (MP_SIZE_T_SWAP (ralloc, talloc));      
  116.   } while (0)
  117. void
  118. mpz_n_pow_ui (mpz_ptr r, mp_srcptr bp, mp_size_t bsize, unsigned long int e)
  119. {
  120.   mp_ptr         rp;
  121.   mp_size_t      rtwos_limbs, ralloc, rsize;
  122.   int            rneg, i, cnt, btwos, r_bp_overlap;
  123.   mp_limb_t      blimb, rl;
  124.   mp_bitcnt_t    rtwos_bits;
  125. #if HAVE_NATIVE_mpn_mul_2
  126.   mp_limb_t      blimb_low, rl_high;
  127. #else
  128.   mp_limb_t      b_twolimbs[2];
  129. #endif
  130.   TMP_DECL;
  131.   TRACE (printf ("mpz_n_pow_ui rp=0x%lX bp=0x%lX bsize=%ld e=%lu (0x%lX)n",
  132.                  PTR(r), bp, bsize, e, e);
  133.          mpn_trace ("b", bp, bsize));
  134.   ASSERT (bsize == 0 || bp[ABS(bsize)-1] != 0);
  135.   ASSERT (MPN_SAME_OR_SEPARATE2_P (PTR(r), ABSIZ(r), bp, bsize));
  136.   /* b^0 == 1, including 0^0 == 1 */
  137.   if (e == 0)
  138.     {
  139.       PTR(r)[0] = 1;
  140.       SIZ(r) = 1;
  141.       return;
  142.     }
  143.   /* 0^e == 0 apart from 0^0 above */
  144.   if (bsize == 0)
  145.     {
  146.       SIZ(r) = 0;
  147.       return;
  148.     }
  149.   /* Sign of the final result. */
  150.   rneg = (bsize < 0 && (e & 1) != 0);
  151.   bsize = ABS (bsize);
  152.   TRACE (printf ("rneg %dn", rneg));
  153.   r_bp_overlap = (PTR(r) == bp);
  154.   /* Strip low zero limbs from b. */
  155.   rtwos_limbs = 0;
  156.   for (blimb = *bp; blimb == 0; blimb = *++bp)
  157.     {
  158.       rtwos_limbs += e;
  159.       bsize--; ASSERT (bsize >= 1);
  160.     }
  161.   TRACE (printf ("trailing zero rtwos_limbs=%ldn", rtwos_limbs));
  162.   /* Strip low zero bits from b. */
  163.   count_trailing_zeros (btwos, blimb);
  164.   blimb >>= btwos;
  165.   rtwos_bits = e * btwos;
  166.   rtwos_limbs += rtwos_bits / GMP_NUMB_BITS;
  167.   rtwos_bits %= GMP_NUMB_BITS;
  168.   TRACE (printf ("trailing zero btwos=%d rtwos_limbs=%ld rtwos_bits=%lun",
  169.                  btwos, rtwos_limbs, rtwos_bits));
  170.   TMP_MARK;
  171.   rl = 1;
  172. #if HAVE_NATIVE_mpn_mul_2
  173.   rl_high = 0;
  174. #endif
  175.   if (bsize == 1)
  176.     {
  177.     bsize_1:
  178.       /* Power up as far as possible within blimb.  We start here with e!=0,
  179.          but if e is small then we might reach e==0 and the whole b^e in rl.
  180.          Notice this code works when blimb==1 too, reaching e==0.  */
  181.       while (blimb <= GMP_NUMB_HALFMAX)
  182.         {
  183.           TRACE (printf ("small e=0x%lX blimb=0x%lX rl=0x%lXn",
  184.                          e, blimb, rl));
  185.           ASSERT (e != 0);
  186.           if ((e & 1) != 0)
  187.             rl *= blimb;
  188.           e >>= 1;
  189.           if (e == 0)
  190.             goto got_rl;
  191.           blimb *= blimb;
  192.         }
  193. #if HAVE_NATIVE_mpn_mul_2
  194.       TRACE (printf ("single power, e=0x%lX b=0x%lX rl=0x%lXn",
  195.                      e, blimb, rl));
  196.       /* Can power b once more into blimb:blimb_low */
  197.       bsize = 2;
  198.       ASSERT (e != 0);
  199.       if ((e & 1) != 0)
  200. {
  201.   umul_ppmm (rl_high, rl, rl, blimb << GMP_NAIL_BITS);
  202.   rl >>= GMP_NAIL_BITS;
  203. }
  204.       e >>= 1;
  205.       umul_ppmm (blimb, blimb_low, blimb, blimb << GMP_NAIL_BITS);
  206.       blimb_low >>= GMP_NAIL_BITS;
  207.     got_rl:
  208.       TRACE (printf ("double power e=0x%lX blimb=0x%lX:0x%lX rl=0x%lX:%lXn",
  209.                      e, blimb, blimb_low, rl_high, rl));
  210.       /* Combine left-over rtwos_bits into rl_high:rl to be handled by the
  211.          final mul_1 or mul_2 rather than a separate lshift.
  212.          - rl_high:rl mustn't be 1 (since then there's no final mul)
  213.          - rl_high mustn't overflow
  214.          - rl_high mustn't change to non-zero, since mul_1+lshift is
  215.          probably faster than mul_2 (FIXME: is this true?)  */
  216.       if (rtwos_bits != 0
  217.           && ! (rl_high == 0 && rl == 1)
  218.           && (rl_high >> (GMP_NUMB_BITS-rtwos_bits)) == 0)
  219.         {
  220.           mp_limb_t  new_rl_high = (rl_high << rtwos_bits)
  221.             | (rl >> (GMP_NUMB_BITS-rtwos_bits));
  222.           if (! (rl_high == 0 && new_rl_high != 0))
  223.             {
  224.               rl_high = new_rl_high;
  225.               rl <<= rtwos_bits;
  226.               rtwos_bits = 0;
  227.               TRACE (printf ("merged rtwos_bits, rl=0x%lX:%lXn",
  228.                              rl_high, rl));
  229.             }
  230.         }
  231. #else
  232.     got_rl:
  233.       TRACE (printf ("small power e=0x%lX blimb=0x%lX rl=0x%lXn",
  234.                      e, blimb, rl));
  235.       /* Combine left-over rtwos_bits into rl to be handled by the final
  236.          mul_1 rather than a separate lshift.
  237.          - rl mustn't be 1 (since then there's no final mul)
  238.          - rl mustn't overflow  */
  239.       if (rtwos_bits != 0
  240.           && rl != 1
  241.           && (rl >> (GMP_NUMB_BITS-rtwos_bits)) == 0)
  242.         {
  243.           rl <<= rtwos_bits;
  244.           rtwos_bits = 0;
  245.           TRACE (printf ("merged rtwos_bits, rl=0x%lXn", rl));
  246.         }
  247. #endif
  248.     }
  249.   else if (bsize == 2)
  250.     {
  251.       mp_limb_t  bsecond = bp[1];
  252.       if (btwos != 0)
  253.         blimb |= (bsecond << (GMP_NUMB_BITS - btwos)) & GMP_NUMB_MASK;
  254.       bsecond >>= btwos;
  255.       if (bsecond == 0)
  256.         {
  257.           /* Two limbs became one after rshift. */
  258.           bsize = 1;
  259.           goto bsize_1;
  260.         }
  261.       TRACE (printf ("bsize==2 using b=0x%lX:%lX", bsecond, blimb));
  262. #if HAVE_NATIVE_mpn_mul_2
  263.       blimb_low = blimb;
  264. #else
  265.       bp = b_twolimbs;
  266.       b_twolimbs[0] = blimb;
  267.       b_twolimbs[1] = bsecond;
  268. #endif
  269.       blimb = bsecond;
  270.     }
  271.   else
  272.     {
  273.       if (r_bp_overlap || btwos != 0)
  274.         {
  275.           mp_ptr tp = TMP_ALLOC_LIMBS (bsize);
  276.           MPN_RSHIFT_OR_COPY (tp, bp, bsize, btwos);
  277.           bp = tp;
  278.           TRACE (printf ("rshift or copy bp,bsize, new bsize=%ldn", bsize));
  279.         }
  280. #if HAVE_NATIVE_mpn_mul_2
  281.       /* in case 3 limbs rshift to 2 and hence use the mul_2 loop below */
  282.       blimb_low = bp[0];
  283. #endif
  284.       blimb = bp[bsize-1];
  285.       TRACE (printf ("big bsize=%ld  ", bsize);
  286.              mpn_trace ("b", bp, bsize));
  287.     }
  288.   /* At this point blimb is the most significant limb of the base to use.
  289.      Each factor of b takes (bsize*BPML-cnt) bits and there's e of them; +1
  290.      limb to round up the division; +1 for multiplies all using an extra
  291.      limb over the true size; +2 for rl at the end; +1 for lshift at the
  292.      end.
  293.      The size calculation here is reasonably accurate.  The base is at least
  294.      half a limb, so in 32 bits the worst case is 2^16+1 treated as 17 bits
  295.      when it will power up as just over 16, an overestimate of 17/16 =
  296.      6.25%.  For a 64-bit limb it's half that.
  297.      If e==0 then blimb won't be anything useful (though it will be
  298.      non-zero), but that doesn't matter since we just end up with ralloc==5,
  299.      and that's fine for 2 limbs of rl and 1 of lshift.  */
  300.   ASSERT (blimb != 0);
  301.   count_leading_zeros (cnt, blimb);
  302.   ralloc = (bsize*GMP_NUMB_BITS - cnt + GMP_NAIL_BITS) * e / GMP_NUMB_BITS + 5;
  303.   TRACE (printf ("ralloc %ld, from bsize=%ld blimb=0x%lX cnt=%dn",
  304.                  ralloc, bsize, blimb, cnt));
  305.   MPZ_REALLOC (r, ralloc + rtwos_limbs);
  306.   rp = PTR(r);
  307.   /* Low zero limbs resulting from powers of 2. */
  308.   MPN_ZERO (rp, rtwos_limbs);
  309.   rp += rtwos_limbs;
  310.   if (e == 0)
  311.     {
  312.       /* Any e==0 other than via bsize==1 or bsize==2 is covered at the
  313.          start. */
  314.       rp[0] = rl;
  315.       rsize = 1;
  316. #if HAVE_NATIVE_mpn_mul_2
  317.       rp[1] = rl_high;
  318.       rsize += (rl_high != 0);
  319. #endif
  320.       ASSERT (rp[rsize-1] != 0);
  321.     }
  322.   else
  323.     {
  324.       mp_ptr     tp;
  325.       mp_size_t  talloc;
  326.       /* In the mpn_mul_1 or mpn_mul_2 loops or in the mpn_mul loop when the
  327.          low bit of e is zero, tp only has to hold the second last power
  328.          step, which is half the size of the final result.  There's no need
  329.          to round up the divide by 2, since ralloc includes a +2 for rl
  330.          which not needed by tp.  In the mpn_mul loop when the low bit of e
  331.          is 1, tp must hold nearly the full result, so just size it the same
  332.          as rp.  */
  333.       talloc = ralloc;
  334. #if HAVE_NATIVE_mpn_mul_2
  335.       if (bsize <= 2 || (e & 1) == 0)
  336.         talloc /= 2;
  337. #else
  338.       if (bsize <= 1 || (e & 1) == 0)
  339.         talloc /= 2;
  340. #endif
  341.       TRACE (printf ("talloc %ldn", talloc));
  342.       tp = TMP_ALLOC_LIMBS (talloc);
  343.       /* Go from high to low over the bits of e, starting with i pointing at
  344.          the bit below the highest 1 (which will mean i==-1 if e==1).  */
  345.       count_leading_zeros (cnt, e);
  346.       i = GMP_LIMB_BITS - cnt - 2;
  347. #if HAVE_NATIVE_mpn_mul_2
  348.       if (bsize <= 2)
  349.         {
  350.           mp_limb_t  mult[2];
  351.           /* Any bsize==1 will have been powered above to be two limbs. */
  352.           ASSERT (bsize == 2);
  353.           ASSERT (blimb != 0);
  354.           /* Arrange the final result ends up in r, not in the temp space */
  355.           if ((i & 1) == 0)
  356.             SWAP_RP_TP;
  357.           rp[0] = blimb_low;
  358.           rp[1] = blimb;
  359.           rsize = 2;
  360.           mult[0] = blimb_low;
  361.           mult[1] = blimb;
  362.           for ( ; i >= 0; i--)
  363.             {
  364.               TRACE (printf ("mul_2 loop i=%d e=0x%lX, rsize=%ld ralloc=%ld talloc=%ldn",
  365.                              i, e, rsize, ralloc, talloc);
  366.                      mpn_trace ("r", rp, rsize));
  367.               MPN_SQR (tp, talloc, rp, rsize);
  368.               SWAP_RP_TP;
  369.               if ((e & (1L << i)) != 0)
  370.                 MPN_MUL_2 (rp, rsize, ralloc, mult);
  371.             }
  372.           TRACE (mpn_trace ("mul_2 before rl, r", rp, rsize));
  373.           if (rl_high != 0)
  374.             {
  375.               mult[0] = rl;
  376.               mult[1] = rl_high;
  377.               MPN_MUL_2 (rp, rsize, ralloc, mult);
  378.             }
  379.           else if (rl != 1)
  380.             MPN_MUL_1 (rp, rsize, ralloc, rl);
  381.         }
  382. #else
  383.       if (bsize == 1)
  384.         {
  385.           /* Arrange the final result ends up in r, not in the temp space */
  386.           if ((i & 1) == 0)
  387.             SWAP_RP_TP;
  388.           rp[0] = blimb;
  389.           rsize = 1;
  390.           for ( ; i >= 0; i--)
  391.             {
  392.               TRACE (printf ("mul_1 loop i=%d e=0x%lX, rsize=%ld ralloc=%ld talloc=%ldn",
  393.                              i, e, rsize, ralloc, talloc);
  394.                      mpn_trace ("r", rp, rsize));
  395.               MPN_SQR (tp, talloc, rp, rsize);
  396.               SWAP_RP_TP;
  397.               if ((e & (1L << i)) != 0)
  398.                 MPN_MUL_1 (rp, rsize, ralloc, blimb);
  399.             }
  400.           TRACE (mpn_trace ("mul_1 before rl, r", rp, rsize));
  401.           if (rl != 1)
  402.             MPN_MUL_1 (rp, rsize, ralloc, rl);
  403.         }
  404. #endif
  405.       else
  406.         {
  407.           int  parity;
  408.           /* Arrange the final result ends up in r, not in the temp space */
  409.           ULONG_PARITY (parity, e);
  410.           if (((parity ^ i) & 1) != 0)
  411.             SWAP_RP_TP;
  412.           MPN_COPY (rp, bp, bsize);
  413.           rsize = bsize;
  414.           for ( ; i >= 0; i--)
  415.             {
  416.               TRACE (printf ("mul loop i=%d e=0x%lX, rsize=%ld ralloc=%ld talloc=%ldn",
  417.                              i, e, rsize, ralloc, talloc);
  418.                      mpn_trace ("r", rp, rsize));
  419.               MPN_SQR (tp, talloc, rp, rsize);
  420.               SWAP_RP_TP;
  421.               if ((e & (1L << i)) != 0)
  422.                 {
  423.                   MPN_MUL (tp, talloc, rp, rsize, bp, bsize);
  424.                   SWAP_RP_TP;
  425.                 }
  426.             }
  427.         }
  428.     }
  429.   ASSERT (rp == PTR(r) + rtwos_limbs);
  430.   TRACE (mpn_trace ("end loop r", rp, rsize));
  431.   TMP_FREE;
  432.   /* Apply any partial limb factors of 2. */
  433.   if (rtwos_bits != 0)
  434.     {
  435.       MPN_LSHIFT (rp, rsize, ralloc, (unsigned) rtwos_bits);
  436.       TRACE (mpn_trace ("lshift r", rp, rsize));
  437.     }
  438.   rsize += rtwos_limbs;
  439.   SIZ(r) = (rneg ? -rsize : rsize);
  440. }