Code coverage tests

This page documents the degree to which the PARI/GP source code is tested by our public test suite, distributed with the source distribution in directory src/test/. This is measured by the gcov utility; we then process gcov output using the lcov frond-end.

We test a few variants depending on Configure flags on the pari.math.u-bordeaux1.fr machine (x86_64 architecture), and agregate them in the final report:

The target is 90% coverage for all mathematical modules (given that branches depending on DEBUGLEVEL or DEBUGMEM are not covered). This script is run to produce the results below.

LCOV - code coverage report
Current view: top level - kernel/none - mp_indep.c (source / functions) Hit Total Coverage
Test: PARI/GP v2.8.0 lcov report (development 16624-25b9976) Lines: 501 555 90.3 %
Date: 2014-06-24 Functions: 49 52 94.2 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 474 623 76.1 %

           Branch data     Line data    Source code
       1                 :            : #line 2 "../src/kernel/none/mp_indep.c"
       2                 :            : /* Copyright (C) 2000  The PARI group.
       3                 :            : 
       4                 :            : This file is part of the PARI/GP package.
       5                 :            : 
       6                 :            : PARI/GP is free software; you can redistribute it and/or modify it under the
       7                 :            : terms of the GNU General Public License as published by the Free Software
       8                 :            : Foundation. It is distributed in the hope that it will be useful, but WITHOUT
       9                 :            : ANY WARRANTY WHATSOEVER.
      10                 :            : 
      11                 :            : Check the License for details. You should have received a copy of it, along
      12                 :            : with the package; see the file 'COPYING'. If not, write to the Free Software
      13                 :            : Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
      14                 :            : 
      15                 :            : /* Find c such that 1=c*b mod 2^BITS_IN_LONG, assuming b odd (unchecked) */
      16                 :            : ulong
      17                 :   14200289 : invmod2BIL(ulong b)
      18                 :            : {
      19                 :            :   static int tab[] = { 0, 0, 0, 8, 0, 8, 0, 0 };
      20                 :   14200289 :   ulong x = b + tab[b & 7]; /* b^(-1) mod 2^4 */
      21                 :            : 
      22                 :            :   /* Newton applied to 1/x - b = 0 */
      23                 :            : #ifdef LONG_IS_64BIT
      24                 :   14200289 :   x = x*(2-b*x); /* one more pass necessary */
      25                 :            : #endif
      26                 :   14200289 :   x = x*(2-b*x);
      27                 :   14200289 :   x = x*(2-b*x); return x*(2-b*x);
      28                 :            : }
      29                 :            : 
      30                 :            : void
      31                 :  617890407 : affrr(GEN x, GEN y)
      32                 :            : {
      33                 :            :   long lx,ly,i;
      34                 :            : 
      35         [ +  + ]:  617890407 :   y[1] = x[1]; if (!signe(x)) return;
      36                 :            : 
      37                 :  613255951 :   lx=lg(x); ly=lg(y);
      38         [ +  + ]:  613255951 :   if (lx <= ly)
      39                 :            :   {
      40         [ +  + ]: 1775913688 :     for (i=2; i<lx; i++) y[i]=x[i];
      41         [ +  + ]:  600676830 :     for (   ; i<ly; i++) y[i]=0;
      42                 :  579553560 :     return;
      43                 :            :   }
      44         [ +  + ]:  137809245 :   for (i=2; i<ly; i++) y[i]=x[i];
      45                 :            :   /* lx > ly: round properly */
      46         [ +  + ]:  617890407 :   if (x[ly] & HIGHBIT) roundr_up_ip(y, ly);
      47                 :            : }
      48                 :            : 
      49                 :            : GEN
      50                 :    3377129 : trunc2nr(GEN x, long n)
      51                 :            : {
      52                 :            :   long ex;
      53         [ +  + ]:    3377129 :   if (!signe(x)) return gen_0;
      54         [ +  + ]:    3356408 :   ex = expo(x) + n; if (ex < 0) return gen_0;
      55                 :    3377129 :   return mantissa2nr(x, ex - bit_prec(x) + 1);
      56                 :            : }
      57                 :            : 
      58                 :            : /* x a t_REAL, x = i/2^e, i a t_INT */
      59                 :            : GEN
      60                 :        170 : mantissa_real(GEN x, long *e)
      61                 :            : {
      62                 :        170 :   *e = bit_prec(x)-1-expo(x);
      63                 :        170 :   return mantissa2nr(x, 0);
      64                 :            : }
      65                 :            : 
      66                 :            : GEN
      67                 :  431806485 : mului(ulong x, GEN y)
      68                 :            : {
      69                 :  431806485 :   long s = signe(y);
      70                 :            :   GEN z;
      71                 :            : 
      72 [ +  + ][ +  + ]:  431806485 :   if (!s || !x) return gen_0;
      73                 :  427738019 :   z = muluispec(x, y+2, lgefint(y)-2);
      74                 :  431806485 :   setsigne(z,s); return z;
      75                 :            : }
      76                 :            : 
      77                 :            : GEN
      78                 :   83503425 : mulsi(long x, GEN y)
      79                 :            : {
      80                 :   83503425 :   long s = signe(y);
      81                 :            :   GEN z;
      82                 :            : 
      83 [ +  + ][ +  + ]:   83503425 :   if (!s || !x) return gen_0;
      84         [ +  + ]:   54141302 :   if (x<0) { s = -s; x = -x; }
      85                 :   54141302 :   z = muluispec((ulong)x, y+2, lgefint(y)-2);
      86                 :   83503425 :   setsigne(z,s); return z;
      87                 :            : }
      88                 :            : 
      89                 :            : GEN
      90                 :    7145057 : mulss(long x, long y)
      91                 :            : {
      92                 :            :   long p1;
      93                 :            :   LOCAL_HIREMAINDER;
      94                 :            : 
      95 [ +  + ][ +  + ]:    7145057 :   if (!x || !y) return gen_0;
      96         [ +  + ]:    6806490 :   if (x<0) {
      97                 :      10580 :     x = -x;
      98         [ +  + ]:      10580 :     if (y<0) { y = -y; p1 = mulll(x,y); return uutoi(hiremainder, p1); }
      99                 :      10560 :     p1 = mulll(x,y); return uutoineg(hiremainder, p1);
     100                 :            :   } else {
     101         [ +  + ]:    6795910 :     if (y<0) { y = -y; p1 = mulll(x,y); return uutoineg(hiremainder, p1); }
     102                 :    7145057 :     p1 = mulll(x,y); return uutoi(hiremainder, p1);
     103                 :            :   }
     104                 :            : }
     105                 :            : GEN
     106                 :       2979 : sqrs(long x)
     107                 :            : {
     108                 :            :   long p1;
     109                 :            :   LOCAL_HIREMAINDER;
     110                 :            : 
     111         [ -  + ]:       2979 :   if (!x) return gen_0;
     112         [ -  + ]:       2979 :   if (x<0) x = -x;
     113                 :       2979 :   p1 = mulll(x,x); return uutoi(hiremainder, p1);
     114                 :            : }
     115                 :            : GEN
     116                 :  514842636 : muluu(ulong x, ulong y)
     117                 :            : {
     118                 :            :   long p1;
     119                 :            :   LOCAL_HIREMAINDER;
     120                 :            : 
     121 [ +  + ][ +  + ]:  514842636 :   if (!x || !y) return gen_0;
     122                 :  514842636 :   p1 = mulll(x,y); return uutoi(hiremainder, p1);
     123                 :            : }
     124                 :            : GEN
     125                 :  139326223 : sqru(ulong x)
     126                 :            : {
     127                 :            :   long p1;
     128                 :            :   LOCAL_HIREMAINDER;
     129                 :            : 
     130         [ +  + ]:  139326223 :   if (!x) return gen_0;
     131                 :  139326223 :   p1 = mulll(x,x); return uutoi(hiremainder, p1);
     132                 :            : }
     133                 :            : 
     134                 :            : /* assume x > 1, y != 0. Return u * y with sign s */
     135                 :            : static GEN
     136                 :  132598802 : mulur_2(ulong x, GEN y, long s)
     137                 :            : {
     138                 :  132598802 :   long m, sh, i, lx = lg(y), e = expo(y);
     139                 :  132598802 :   GEN z = cgetr(lx);
     140                 :            :   ulong garde;
     141                 :            :   LOCAL_HIREMAINDER;
     142                 :            : 
     143                 :  132598802 :   y--; garde = mulll(x,y[lx]);
     144      [ +  +  + ]:  490626991 :   for (i=lx-1; i>=3; i--) z[i]=addmul(x,y[i]);
     145                 :  132598802 :   z[2]=hiremainder; /* != 0 since y normalized and |x| > 1 */
     146 [ +  + ][ +  + ]:  132598802 :   sh = bfffo(hiremainder); m = BITS_IN_LONG-sh;
         [ +  + ][ +  + ]
     147 [ +  + ][ +  + ]:  132598802 :   if (sh) shift_left(z,z, 2,lx-1, garde,sh);
     148                 :  132598802 :   z[1] = evalsigne(s) | evalexpo(m+e);
     149         [ +  + ]:  132598802 :   if ((garde << sh) & HIGHBIT) roundr_up_ip(z, lx);
     150                 :  132598802 :   return z;
     151                 :            : }
     152                 :            : 
     153                 :            : INLINE GEN
     154                 :    1503972 : mul0r(GEN x)
     155                 :            : {
     156                 :    1503972 :   long l = lg(x), e = expo(x);
     157 [ +  + ][ +  + ]:    1503972 :   e = (l > 2)? -bit_accuracy(l) + e: (e < 0? (e<<1): 0);
     158                 :    1503972 :   return real_0_bit(e);
     159                 :            : }
     160                 :            : /* lg(x) > 2 */
     161                 :            : INLINE GEN
     162                 :      49330 : div0r(GEN x) {
     163                 :      49330 :   long l = lg(x), e = expo(x);
     164                 :      49330 :   return real_0_bit(-bit_accuracy(l) - e);
     165                 :            : }
     166                 :            : 
     167                 :            : GEN
     168                 :   16548177 : mulsr(long x, GEN y)
     169                 :            : {
     170                 :            :   long s;
     171                 :            : 
     172         [ +  + ]:   16548177 :   if (!x) return mul0r(y);
     173                 :   15144259 :   s = signe(y);
     174         [ +  + ]:   15144259 :   if (!s)
     175                 :            :   {
     176         [ +  + ]:      27767 :     if (x < 0) x = -x;
     177                 :      27767 :     return real_0_bit( expo(y) + expu(x) );
     178                 :            :   }
     179         [ +  + ]:   15116492 :   if (x==1)  return rcopy(y);
     180         [ +  + ]:   14771268 :   if (x==-1) return negr(y);
     181         [ +  + ]:   14367542 :   if (x < 0)
     182                 :    9013883 :     return mulur_2((ulong)-x, y, -s);
     183                 :            :   else
     184                 :   16548177 :     return mulur_2((ulong)x, y, s);
     185                 :            : }
     186                 :            : 
     187                 :            : GEN
     188                 :  148964480 : mulur(ulong x, GEN y)
     189                 :            : {
     190                 :            :   long s;
     191                 :            : 
     192         [ -  + ]:  148964480 :   if (!x) return mul0r(y);
     193                 :  148964480 :   s = signe(y);
     194         [ +  + ]:  148964480 :   if (!s) return real_0_bit( expo(y) + expu(x) );
     195         [ +  + ]:  147968913 :   if (x==1) return rcopy(y);
     196                 :  148964480 :   return mulur_2(x, y, s);
     197                 :            : }
     198                 :            : 
     199                 :            : INLINE void
     200                 :  785409929 : mulrrz_end(GEN z, GEN hi, long lz, long sz, long ez, ulong garde)
     201                 :            : {
     202                 :            :   long i;
     203         [ +  + ]:  785409929 :   if (hi[2] < 0)
     204                 :            :   {
     205         [ +  + ]:  380968858 :     if (z != hi)
     206         [ +  + ]:  473161212 :       for (i=2; i<lz ; i++) z[i] = hi[i];
     207                 :  380968858 :     ez++;
     208                 :            :   }
     209                 :            :   else
     210                 :            :   {
     211                 :  404441071 :     shift_left(z,hi,2,lz-1, garde, 1);
     212                 :  404441071 :     garde <<= 1;
     213                 :            :   }
     214         [ +  + ]:  785409929 :   if (garde & HIGHBIT)
     215                 :            :   { /* round to nearest */
     216 [ +  + ][ +  + ]:  388845358 :     i = lz; do ((ulong*)z)[--i]++; while (i>1 && z[i]==0);
     217         [ +  + ]:  387875767 :     if (i == 1) { z[2] = (long)HIGHBIT; ez++; }
     218                 :            :   }
     219                 :  785409929 :   z[1] = evalsigne(sz)|evalexpo(ez);
     220                 :  785409929 : }
     221                 :            : /* mulrrz_end for lz = 3, minor simplifications. z[2]=hiremainder from mulll */
     222                 :            : INLINE void
     223                 :  877382770 : mulrrz_3end(GEN z, long sz, long ez, ulong garde)
     224                 :            : {
     225         [ +  + ]:  877382770 :   if (z[2] < 0)
     226                 :            :   { /* z2 < (2^BIL-1)^2 / 2^BIL, hence z2+1 != 0 */
     227         [ +  + ]:  487969376 :     if (garde & HIGHBIT) z[2]++; /* round properly */
     228                 :  487969376 :     ez++;
     229                 :            :   }
     230                 :            :   else
     231                 :            :   {
     232                 :  389413394 :     z[2] = (z[2]<<1) | (garde>>(BITS_IN_LONG-1));
     233         [ +  + ]:  389413394 :     if (garde & (HIGHBIT-1))
     234                 :            :     {
     235                 :  372124764 :       z[2]++; /* round properly, z2+1 can overflow */
     236         [ +  + ]:  372124764 :       if (!z[2]) { z[2] = (long)HIGHBIT; ez++; }
     237                 :            :     }
     238                 :            :   }
     239                 :  877382770 :   z[1] = evalsigne(sz)|evalexpo(ez);
     240                 :  877382770 : }
     241                 :            : 
     242                 :            : /* set z <-- x^2 != 0, floating point multiplication.
     243                 :            :  * lz = lg(z) = lg(x) */
     244                 :            : INLINE void
     245                 :   66980051 : sqrz_i(GEN z, GEN x, long lz)
     246                 :            : {
     247                 :   66980051 :   long ez = expo(x) << 1;
     248                 :            :   long i, j, lzz, p1;
     249                 :            :   ulong garde;
     250                 :            :   GEN x1;
     251                 :            :   LOCAL_HIREMAINDER;
     252                 :            :   LOCAL_OVERFLOW;
     253                 :            : 
     254         [ +  + ]:   66980051 :   if (lz > MULRR_MULII_LIMIT)
     255                 :            :   {
     256                 :    6809874 :     pari_sp av = avma;
     257                 :    6809874 :     GEN hi = sqrispec_mirror(x+2, lz-2);
     258                 :    6809874 :     mulrrz_end(z, hi, lz, 1, ez, hi[lz]);
     259                 :    6809874 :     avma = av; return;
     260                 :            :   }
     261         [ +  + ]:   60170177 :   if (lz == 3)
     262                 :            :   {
     263                 :    5533713 :     garde = mulll(x[2],x[2]);
     264                 :    5533713 :     z[2] = hiremainder;
     265                 :    5533713 :     mulrrz_3end(z, 1, ez, garde);
     266                 :    5533713 :     return;
     267                 :            :   }
     268                 :            : 
     269                 :   54636464 :   lzz = lz-1; p1 = x[lzz];
     270         [ +  + ]:   54636464 :   if (p1)
     271                 :            :   {
     272                 :   49153447 :     (void)mulll(p1,x[3]);
     273                 :   49153447 :     garde = addmul(p1,x[2]);
     274                 :   49153447 :     z[lzz] = hiremainder;
     275                 :            :   }
     276                 :            :   else
     277                 :            :   {
     278                 :    5483017 :     garde = 0;
     279                 :    5483017 :     z[lzz] = 0;
     280                 :            :   }
     281         [ +  + ]:  210797864 :   for (j=lz-2, x1=x-j; j>=3; j--)
     282                 :            :   {
     283                 :  156161400 :     p1 = x[j]; x1++;
     284         [ +  + ]:  156161400 :     if (p1)
     285                 :            :     {
     286                 :  154311179 :       (void)mulll(p1,x1[lz+1]);
     287                 :  154311179 :       garde = addll(addmul(p1,x1[lz]), garde);
     288 [ +  + ][ +  + ]:  632625738 :       for (i=lzz; i>j; i--)
     289                 :            :       {
     290                 :  478314559 :         hiremainder += overflow;
     291                 :  478314559 :         z[i] = addll(addmul(p1,x1[i]), z[i]);
     292                 :            :       }
     293                 :  154311179 :       z[j] = hiremainder+overflow;
     294                 :            :     }
     295                 :    1850221 :     else z[j]=0;
     296                 :            :   }
     297                 :   54636464 :   p1 = x[2]; x1++;
     298                 :   54636464 :   garde = addll(mulll(p1,x1[lz]), garde);
     299 [ +  + ][ +  + ]:  265434328 :   for (i=lzz; i>2; i--)
     300                 :            :   {
     301                 :  210797864 :     hiremainder += overflow;
     302                 :  210797864 :     z[i] = addll(addmul(p1,x1[i]), z[i]);
     303                 :            :   }
     304                 :   54636464 :   z[2] = hiremainder+overflow;
     305                 :   66980051 :   mulrrz_end(z, z, lz, 1, ez, garde);
     306                 :            : }
     307                 :            : 
     308                 :            : /* lz "large" = lg(y) = lg(z), lg(x) > lz if flag = 1 and >= if flag = 0 */
     309                 :            : INLINE void
     310                 :   69517693 : mulrrz_int(GEN z, GEN x, GEN y, long lz, long flag, long sz)
     311                 :            : {
     312                 :   69517693 :   pari_sp av = avma;
     313                 :   69517693 :   GEN hi = muliispec_mirror(y+2, x+2, lz+flag-2, lz-2);
     314                 :   69517693 :   mulrrz_end(z, hi, lz, sz, expo(x)+expo(y), hi[lz]);
     315                 :   69517693 :   avma = av;
     316                 :   69517693 : }
     317                 :            : 
     318                 :            : /* lz = 3 */
     319                 :            : INLINE void
     320                 :  871849057 : mulrrz_3(GEN z, GEN x, GEN y, long flag, long sz)
     321                 :            : {
     322                 :            :   ulong garde;
     323                 :            :   LOCAL_HIREMAINDER;
     324         [ +  + ]:  871849057 :   if (flag)
     325                 :            :   {
     326                 :    9231962 :     (void)mulll(x[2],y[3]);
     327                 :    9231962 :     garde = addmul(x[2],y[2]);
     328                 :            :   }
     329                 :            :   else
     330                 :  862617095 :     garde = mulll(x[2],y[2]);
     331                 :  871849057 :   z[2] = hiremainder;
     332                 :  871849057 :   mulrrz_3end(z, sz, expo(x)+expo(y), garde);
     333                 :  871849057 : }
     334                 :            : 
     335                 :            : /* set z <-- x*y, floating point multiplication. Trailing 0s for x are
     336                 :            :  * treated efficiently (important application: mulir).
     337                 :            :  * lz = lg(z) = lg(x) <= ly <= lg(y), sz = signe(z). flag = lg(x) < lg(y) */
     338                 :            : INLINE void
     339                 : 1595425888 : mulrrz_i(GEN z, GEN x, GEN y, long lz, long flag, long sz)
     340                 :            : {
     341                 :            :   long ez, i, j, lzz, p1;
     342                 :            :   ulong garde;
     343                 :            :   GEN y1;
     344                 :            :   LOCAL_HIREMAINDER;
     345                 :            :   LOCAL_OVERFLOW;
     346                 :            : 
     347         [ -  + ]: 1595425888 :   if (x == y) { sqrz_i(z,x,lz); return; }
     348         [ +  + ]: 1595425888 :   if (lz > MULRR_MULII_LIMIT) { mulrrz_int(z,x,y,lz,flag,sz); return; }
     349         [ +  + ]: 1525908195 :   if (lz == 3) { mulrrz_3(z,x,y,flag,sz); return; }
     350                 :  654059138 :   ez = expo(x) + expo(y);
     351         [ +  + ]:  654059138 :   if (flag) { (void)mulll(x[2],y[lz]); garde = hiremainder; } else garde = 0;
     352                 :  654059138 :   lzz=lz-1; p1=x[lzz];
     353         [ +  + ]:  654059138 :   if (p1)
     354                 :            :   {
     355                 :  640253985 :     (void)mulll(p1,y[3]);
     356                 :  640253985 :     garde = addll(addmul(p1,y[2]), garde);
     357                 :  640253985 :     z[lzz] = overflow+hiremainder;
     358                 :            :   }
     359                 :   13805153 :   else z[lzz]=0;
     360         [ +  + ]: 2941741575 :   for (j=lz-2, y1=y-j; j>=3; j--)
     361                 :            :   {
     362                 : 2287682437 :     p1 = x[j]; y1++;
     363         [ +  + ]: 2287682437 :     if (p1)
     364                 :            :     {
     365                 : 2269480276 :       (void)mulll(p1,y1[lz+1]);
     366                 : 2269480276 :       garde = addll(addmul(p1,y1[lz]), garde);
     367 [ +  + ][ +  + ]:10361388829 :       for (i=lzz; i>j; i--)
     368                 :            :       {
     369                 : 8091908553 :         hiremainder += overflow;
     370                 : 8091908553 :         z[i] = addll(addmul(p1,y1[i]), z[i]);
     371                 :            :       }
     372                 : 2269480276 :       z[j] = hiremainder+overflow;
     373                 :            :     }
     374                 :   18202161 :     else z[j]=0;
     375                 :            :   }
     376                 :  654059138 :   p1 = x[2]; y1++;
     377                 :  654059138 :   garde = addll(mulll(p1,y1[lz]), garde);
     378 [ +  + ][ +  + ]: 3595800713 :   for (i=lzz; i>2; i--)
     379                 :            :   {
     380                 : 2941741575 :     hiremainder += overflow;
     381                 : 2941741575 :     z[i] = addll(addmul(p1,y1[i]), z[i]);
     382                 :            :   }
     383                 :  654059138 :   z[2] = hiremainder+overflow;
     384                 : 1595425888 :   mulrrz_end(z, z, lz, sz, ez, garde);
     385                 :            : }
     386                 :            : 
     387                 :            : GEN
     388                 : 1611829832 : mulrr(GEN x, GEN y)
     389                 :            : {
     390                 :            :   long flag, ly, lz, sx, sy;
     391                 :            :   GEN z;
     392                 :            : 
     393         [ +  + ]: 1611829832 :   if (x == y) return sqrr(x);
     394         [ +  + ]: 1611771384 :   sx = signe(x); if (!sx) return real_0_bit(expo(x) + expo(y));
     395         [ +  + ]: 1595997238 :   sy = signe(y); if (!sy) return real_0_bit(expo(x) + expo(y));
     396         [ +  + ]: 1586511637 :   if (sy < 0) sx = -sx;
     397                 : 1586511637 :   lz = lg(x);
     398                 : 1586511637 :   ly = lg(y);
     399         [ +  + ]: 1586511637 :   if (lz > ly) { lz = ly; swap(x, y); flag = 1; } else flag = (lz != ly);
     400                 : 1586511637 :   z = cgetr(lz);
     401                 : 1586511637 :   mulrrz_i(z, x,y, lz,flag, sx);
     402                 : 1611829832 :   return z;
     403                 :            : }
     404                 :            : 
     405                 :            : GEN
     406                 :   67547069 : sqrr(GEN x)
     407                 :            : {
     408                 :   67547069 :   long lz, sx = signe(x);
     409                 :            :   GEN z;
     410                 :            : 
     411         [ +  + ]:   67547069 :   if (!sx) return real_0_bit(2*expo(x));
     412                 :   66980051 :   lz = lg(x); z = cgetr(lz);
     413                 :   66980051 :   sqrz_i(z, x, lz);
     414                 :   67547069 :   return z;
     415                 :            : }
     416                 :            : 
     417                 :            : GEN
     418                 :  125763672 : mulir(GEN x, GEN y)
     419                 :            : {
     420                 :  125763672 :   long sx = signe(x), sy;
     421         [ +  + ]:  125763672 :   if (!sx) return mul0r(y);
     422         [ +  + ]:  125663618 :   if (lgefint(x) == 3) {
     423                 :  115298018 :     GEN z = mulur(uel(x,2), y);
     424         [ +  + ]:  115298018 :     if (sx < 0) togglesign(z);
     425                 :  115298018 :     return z;
     426                 :            :   }
     427                 :   10365600 :   sy = signe(y);
     428         [ +  + ]:   10365600 :   if (!sy) return real_0_bit(expi(x) + expo(y));
     429         [ +  + ]:    9301011 :   if (sy < 0) sx = -sx;
     430                 :            :   {
     431                 :    9301011 :     long lz = lg(y), lx = lgefint(x);
     432                 :    9301011 :     GEN hi, z = cgetr(lz);
     433                 :    9301011 :     pari_sp av = avma;
     434 [ +  + ][ +  + ]:    9301011 :     if (lx < (lz>>1) || (lx < lz && lz > MULRR_MULII_LIMIT))
                 [ +  + ]
     435                 :            :     { /* size mantissa of x < half size of mantissa z, or lx < lz so large
     436                 :            :        * that mulrr will call mulii anyway: mulii */
     437                 :     386760 :       x = itor(x, lx);
     438                 :     386760 :       hi = muliispec_mirror(y+2, x+2, lz-2, lx-2);
     439                 :     386760 :       mulrrz_end(z, hi, lz, sx, expo(x)+expo(y), hi[lz]);
     440                 :            :     }
     441                 :            :     else /* dubious: complete x with 0s and call mulrr */
     442                 :    8914251 :       mulrrz_i(z, itor(x,lz), y, lz, 0, sx);
     443                 :  125763672 :     avma = av; return z;
     444                 :            :   }
     445                 :            : }
     446                 :            : 
     447                 :            : /* x + y*z, generic. If lgefint(z) <= 3, caller should use faster variants  */
     448                 :            : static GEN
     449                 :   14175134 : addmulii_gen(GEN x, GEN y, GEN z, long lz)
     450                 :            : {
     451                 :   14175134 :   long lx = lgefint(x), ly;
     452                 :            :   pari_sp av;
     453                 :            :   GEN t;
     454         [ +  + ]:   14175134 :   if (lx == 2) return mulii(z,y);
     455                 :   13779862 :   ly = lgefint(y);
     456         [ +  + ]:   13779862 :   if (ly == 2) return icopy(x); /* y = 0, wasteful copy */
     457                 :   13715041 :   av = avma; (void)new_chunk(lx+ly+lz); /*HACK*/
     458                 :   13715041 :   t = mulii(z, y);
     459                 :   14175134 :   avma = av; return addii(t,x);
     460                 :            : }
     461                 :            : /* x + y*z, lgefint(z) == 3 */
     462                 :            : static GEN
     463                 :  156854579 : addmulii_lg3(GEN x, GEN y, GEN z)
     464                 :            : {
     465                 :  156854579 :   long s = signe(z), lx, ly;
     466                 :  156854579 :   ulong w = z[2];
     467                 :            :   pari_sp av;
     468                 :            :   GEN t;
     469 [ +  + ][ +  + ]:  156854579 :   if (w == 1) return (s > 0)? addii(x,y): subii(x,y); /* z = +- 1 */
     470                 :  116353133 :   lx = lgefint(x);
     471                 :  116353133 :   ly = lgefint(y);
     472         [ +  + ]:  116353133 :   if (lx == 2)
     473                 :            :   { /* x = 0 */
     474         [ +  + ]:   21412909 :     if (ly == 2) return gen_0;
     475                 :   17705141 :     t = muluispec(w, y+2, ly-2);
     476         [ +  + ]:   17705141 :     if (signe(y) < 0) s = -s;
     477                 :   17705141 :     setsigne(t, s); return t;
     478                 :            :   }
     479         [ +  + ]:   94940224 :   if (ly == 2) return icopy(x); /* y = 0, wasteful copy */
     480                 :   91170334 :   av = avma; (void)new_chunk(1+lx+ly);/*HACK*/
     481                 :   91170334 :   t = muluispec(w, y+2, ly-2);
     482         [ +  + ]:   91170334 :   if (signe(y) < 0) s = -s;
     483                 :   91170334 :   setsigne(t, s);
     484                 :  156854579 :   avma = av; return addii(x,t);
     485                 :            : }
     486                 :            : /* x + y*z */
     487                 :            : GEN
     488                 :   18390041 : addmulii(GEN x, GEN y, GEN z)
     489                 :            : {
     490                 :   18390041 :   long lz = lgefint(z);
     491      [ +  +  + ]:   18390041 :   switch(lz)
     492                 :            :   {
     493                 :       3097 :     case 2: return icopy(x); /* z = 0, wasteful copy */
     494                 :   16682748 :     case 3: return addmulii_lg3(x, y, z);
     495                 :   18390041 :     default:return addmulii_gen(x, y, z, lz);
     496                 :            :   }
     497                 :            : }
     498                 :            : /* x + y*z, returns x itself and not a copy when y*z = 0 */
     499                 :            : GEN
     500                 :  572196302 : addmulii_inplace(GEN x, GEN y, GEN z)
     501                 :            : {
     502                 :            :   long lz;
     503         [ +  + ]:  572196302 :   if (lgefint(y) == 2) return x;
     504                 :  152642769 :   lz = lgefint(z);
     505      [ -  +  + ]:  152642769 :   switch(lz)
     506                 :            :   {
     507                 :          0 :     case 2: return x;
     508                 :  140171831 :     case 3: return addmulii_lg3(x, y, z);
     509                 :  572196302 :     default:return addmulii_gen(x, y, z, lz);
     510                 :            :   }
     511                 :            : }
     512                 :            : 
     513                 :            : /* written by Bruno Haible following an idea of Robert Harley */
     514                 :            : long
     515                 :  186629993 : vals(ulong z)
     516                 :            : {
     517                 :            :   static char tab[64]={-1,0,1,12,2,6,-1,13,3,-1,7,-1,-1,-1,-1,14,10,4,-1,-1,8,-1,-1,25,-1,-1,-1,-1,-1,21,27,15,31,11,5,-1,-1,-1,-1,-1,9,-1,-1,24,-1,-1,20,26,30,-1,-1,-1,-1,23,-1,19,29,-1,22,18,28,17,16,-1};
     518                 :            : #ifdef LONG_IS_64BIT
     519                 :            :   long s;
     520                 :            : #endif
     521                 :            : 
     522         [ -  + ]:  186629993 :   if (!z) return -1;
     523                 :            : #ifdef LONG_IS_64BIT
     524         [ +  + ]:  169999334 :   if (! (z&0xffffffff)) { s = 32; z >>=32; } else s = 0;
     525                 :            : #endif
     526                 :  186629993 :   z |= ~z + 1;
     527                 :  186629993 :   z += z << 4;
     528                 :  186629993 :   z += z << 6;
     529                 :  186629993 :   z ^= z << 16; /* or  z -= z<<16 */
     530                 :            : #ifdef LONG_IS_64BIT
     531                 :  169999334 :   return s + tab[(z&0xffffffff)>>26];
     532                 :            : #else
     533                 :   16630659 :   return tab[z>>26];
     534                 :            : #endif
     535                 :            : }
     536                 :            : 
     537                 :            : GEN
     538                 :          0 : divsi(long x, GEN y)
     539                 :            : {
     540                 :          0 :   long p1, s = signe(y);
     541                 :            :   LOCAL_HIREMAINDER;
     542                 :            : 
     543         [ #  # ]:          0 :   if (!s) pari_err_INV("divsi",gen_0);
     544 [ #  # ][ #  # ]:          0 :   if (!x || lgefint(y)>3 || ((long)y[2])<0) return gen_0;
                 [ #  # ]
     545 [ #  # ][ #  # ]:          0 :   hiremainder=0; p1=divll(labs(x),y[2]);
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
                 [ #  # ]
     546 [ #  # ][ #  # ]:          0 :   if (x<0) { hiremainder = -((long)hiremainder); p1 = -p1; }
     547         [ #  # ]:          0 :   if (s<0) p1 = -p1;
     548                 :          0 :   return stoi(p1);
     549                 :            : }
     550                 :            : 
     551                 :            : GEN
     552                 :    1959017 : divir(GEN x, GEN y)
     553                 :            : {
     554                 :            :   GEN z;
     555                 :    1959017 :   long ly = lg(y), lx = lgefint(x);
     556                 :            :   pari_sp av;
     557                 :            : 
     558         [ -  + ]:    1959017 :   if (ly == 2) pari_err_INV("divir",y);
     559         [ +  + ]:    1959017 :   if (lx == 2) return div0r(y);
     560         [ +  + ]:    1909687 :   if (lx == 3) {
     561                 :    1030039 :     z = divur(x[2], y);
     562         [ +  + ]:    1030039 :     if (signe(x) < 0) togglesign(z);
     563                 :    1030039 :     return z;
     564                 :            :   }
     565                 :     879648 :   z = cgetr(ly); av = avma;
     566                 :     879648 :   affrr(divrr(itor(x, ly+1), y), z);
     567                 :    1959017 :   avma = av; return z;
     568                 :            : }
     569                 :            : 
     570                 :            : GEN
     571                 :    1037923 : divur(ulong x, GEN y)
     572                 :            : {
     573                 :            :   pari_sp av;
     574                 :    1037923 :   long ly = lg(y);
     575                 :            :   GEN z;
     576                 :            : 
     577         [ -  + ]:    1037923 :   if (ly == 2) pari_err_INV("divur",y);
     578         [ -  + ]:    1037923 :   if (!x) return div0r(y);
     579         [ +  + ]:    1037923 :   if (ly > INVNEWTON_LIMIT) {
     580                 :          4 :     av = avma; z = invr(y);
     581         [ -  + ]:          4 :     if (x == 1) return z;
     582                 :          4 :     return gerepileuptoleaf(av, mulur(x, z));
     583                 :            :   }
     584                 :    1037919 :   z = cgetr(ly); av = avma;
     585                 :    1037919 :   affrr(divrr(utor(x,ly+1), y), z);
     586                 :    1037923 :   avma = av; return z;
     587                 :            : }
     588                 :            : 
     589                 :            : GEN
     590                 :       6855 : divsr(long x, GEN y)
     591                 :            : {
     592                 :            :   pari_sp av;
     593                 :       6855 :   long ly = lg(y);
     594                 :            :   GEN z;
     595                 :            : 
     596         [ -  + ]:       6855 :   if (ly == 2) pari_err_INV("divsr",y);
     597         [ -  + ]:       6855 :   if (!x) return div0r(y);
     598         [ -  + ]:       6855 :   if (ly > INVNEWTON_LIMIT) {
     599                 :          0 :     av = avma; z = invr(y);
     600         [ #  # ]:          0 :     if (x == 1) return z;
     601         [ #  # ]:          0 :     if (x ==-1) { togglesign(z); return z; }
     602                 :          0 :     return gerepileuptoleaf(av, mulsr(x, z));
     603                 :            :   }
     604                 :       6855 :   z = cgetr(ly); av = avma;
     605                 :       6855 :   affrr(divrr(stor(x,ly+1), y), z);
     606                 :       6855 :   avma = av; return z;
     607                 :            : }
     608                 :            : 
     609                 :            : /* returns 1/y, assume y != 0 */
     610                 :            : static GEN
     611                 :    5916229 : invr_basecase(GEN y)
     612                 :            : {
     613                 :    5916229 :   long ly = lg(y);
     614                 :    5916229 :   GEN z = cgetr(ly);
     615                 :    5916229 :   pari_sp av = avma;
     616                 :    5916229 :   affrr(divrr(real_1(ly+1), y), z);
     617                 :    5916229 :   avma = av; return z;
     618                 :            : }
     619                 :            : /* returns 1/b, Newton iteration */
     620                 :            : GEN
     621                 :    5916229 : invr(GEN b)
     622                 :            : {
     623                 :    5916229 :   const long s = 6;
     624                 :    5916229 :   long i, p, l = lg(b);
     625                 :            :   GEN x, a;
     626                 :            :   ulong mask;
     627                 :            : 
     628         [ +  + ]:    5916229 :   if (l <= maxss(INVNEWTON_LIMIT, (1L<<s) + 2)) {
     629         [ -  + ]:    5915809 :     if (l == 2) pari_err_INV("invr",b);
     630                 :    5915809 :     return invr_basecase(b);
     631                 :            :   }
     632                 :        420 :   mask = quadratic_prec_mask(l-2);
     633 [ +  + ][ +  + ]:       2940 :   for(i=0, p=1; i<s; i++) { p <<= 1; if (mask & 1) p--; mask >>= 1; }
     634                 :        420 :   x = cgetr(l);
     635                 :        420 :   a = rcopy(b); a[1] = _evalexpo(0) | evalsigne(1);
     636                 :        420 :   affrr(invr_basecase(rtor(a, p+2)), x);
     637         [ +  + ]:        873 :   while (mask > 1)
     638                 :            :   {
     639         [ +  + ]:        453 :     p <<= 1; if (mask & 1) p--;
     640                 :        453 :     mask >>= 1;
     641                 :        453 :     setlg(a, p + 2);
     642                 :        453 :     setlg(x, p + 2);
     643                 :            :     /* TODO: mulrr(a,x) should be a half product (the higher half is known).
     644                 :            :      * mulrr(x, ) already is */
     645                 :        453 :     affrr(addrr(x, mulrr(x, subsr(1, mulrr(a,x)))), x);
     646                 :        453 :     avma = (pari_sp)a;
     647                 :            :   }
     648                 :        420 :   x[1] = (b[1] & SIGNBITS) | evalexpo(expo(x)-expo(b));
     649                 :    5916229 :   avma = (pari_sp)x; return x;
     650                 :            : }
     651                 :            : 
     652                 :            : GEN
     653                 :  513505412 : modii(GEN x, GEN y)
     654                 :            : {
     655      [ +  +  + ]:  513505412 :   switch(signe(x))
     656                 :            :   {
     657                 :   41316696 :     case 0: return gen_0;
     658                 :  311669707 :     case 1: return remii(x,y);
     659                 :            :     default:
     660                 :            :     {
     661                 :  160519009 :       pari_sp av = avma;
     662                 :  160519009 :       (void)new_chunk(lgefint(y));
     663                 :  160519009 :       x = remii(x,y); avma=av;
     664         [ +  + ]:  160519009 :       if (x==gen_0) return x;
     665                 :  513505412 :       return subiispec(y+2,x+2,lgefint(y)-2,lgefint(x)-2);
     666                 :            :     }
     667                 :            :   }
     668                 :            : }
     669                 :            : 
     670                 :            : void
     671                 :     328718 : modiiz(GEN x, GEN y, GEN z)
     672                 :            : {
     673                 :     328718 :   const pari_sp av = avma;
     674                 :     328718 :   affii(modii(x,y),z); avma=av;
     675                 :     328718 : }
     676                 :            : 
     677                 :            : GEN
     678                 :    2162444 : divrs(GEN x, long y)
     679                 :            : {
     680                 :    2162444 :   long i, lx, garde, sh, s = signe(x);
     681                 :            :   GEN z;
     682                 :            :   LOCAL_HIREMAINDER;
     683                 :            : 
     684         [ -  + ]:    2162444 :   if (!y) pari_err_INV("divrs",gen_0);
     685         [ +  + ]:    2162444 :   if (y<0) { s = -s; y = -y; }
     686         [ +  + ]:    2162444 :   if (!s) return real_0_bit(expo(x) - expu(y));
     687         [ +  + ]:    2139928 :   if (y==1) { z = rcopy(x); setsigne(z,s); return z; }
     688         [ +  + ]:    2112552 :   if (y==2) { z = shiftr(x, -1); setsigne(z,s); return z; }
     689                 :            : 
     690                 :    2054896 :   z=cgetr(lx=lg(x)); hiremainder=0;
     691 [ +  + ][ +  + ]:   15151975 :   for (i=2; i<lx; i++) z[i] = divll(x[i],y);
         [ +  + ][ -  + ]
         [ +  - ][ +  + ]
         [ +  + ][ +  + ]
         [ +  + ][ +  + ]
         [ +  + ][ +  + ]
         [ +  + ][ +  + ]
            [ +  + ][ + ]
     692                 :            : 
     693                 :            :   /* we may have hiremainder != 0 ==> garde */
     694 [ +  + ][ +  + ]:    2054896 :   garde=divll(0,y); sh=bfffo(z[2]);
         [ -  + ][ +  - ]
         [ +  + ][ +  + ]
         [ +  + ][ +  + ]
         [ +  + ][ +  + ]
         [ +  + ][ +  + ]
         [ +  + ][ +  + ]
         [ +  + ][ +  + ]
                 [ +  + ]
     695 [ +  - ][ +  - ]:    2054896 :   if (sh) shift_left(z,z, 2,lx-1, garde,sh);
     696                 :    2054896 :   z[1] = evalsigne(s) | evalexpo(expo(x)-sh);
     697         [ +  + ]:    2054896 :   if ((garde << sh) & HIGHBIT) roundr_up_ip(z, lx);
     698                 :    2162444 :   return z;
     699                 :            : }
     700                 :            : 
     701                 :            : GEN
     702                 :  123117045 : divru(GEN x, ulong y)
     703                 :            : {
     704                 :  123117045 :   long i, lx, garde, sh, e, s = signe(x);
     705                 :            :   GEN z;
     706                 :            :   LOCAL_HIREMAINDER;
     707                 :            : 
     708         [ -  + ]:  123117045 :   if (!y) pari_err_INV("divru",gen_0);
     709         [ +  + ]:  123117045 :   if (!s) return real_0_bit(expo(x) - expu(y));
     710         [ +  + ]:  123111490 :   if (y==1) return rcopy(x);
     711         [ +  + ]:  122852133 :   if (y==2) return shiftr(x, -1);
     712                 :            : 
     713                 :  118176912 :   e = expo(x);
     714                 :  118176912 :   lx = lg(x);
     715                 :  118176912 :   z = cgetr(lx);
     716         [ +  + ]:  118176912 :   if (y <= uel(x,2))
     717                 :            :   {
     718                 :  118176862 :     hiremainder = 0;
     719 [ +  + ][ +  + ]:  642127391 :     for (i=2; i<lx; i++) z[i] = divll(x[i],y);
         [ +  + ][ -  + ]
         [ +  - ][ +  + ]
         [ +  + ][ +  + ]
         [ +  + ][ +  + ]
         [ +  + ][ +  + ]
         [ +  + ][ +  + ]
            [ +  + ][ + ]
     720                 :            :     /* we may have hiremainder != 0 ==> garde */
     721 [ +  + ][ +  + ]:  118176862 :     garde = divll(0,y);
         [ +  + ][ +  - ]
         [ +  + ][ +  + ]
         [ +  + ][ +  + ]
         [ +  + ][ +  + ]
         [ +  + ][ +  + ]
                 [ +  + ]
     722                 :            :   }
     723                 :            :   else
     724                 :            :   {
     725                 :         50 :     long l = lx-1;
     726                 :         50 :     hiremainder = x[2];
     727 [ +  + ][ #  # ]:         64 :     for (i=2; i<l; i++) z[i] = divll(x[i+1],y);
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
            [ -  + ][ + ]
     728 [ -  + ][ -  + ]:         50 :     z[i] = divll(0,y);
         [ +  - ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ +  + ]
         [ +  + ][ -  + ]
         [ +  + ][ +  - ]
                 [ -  + ]
     729                 :         50 :     garde = hiremainder;
     730                 :         50 :     e -= BITS_IN_LONG;
     731                 :            :   }
     732 [ +  + ][ +  + ]:  118176912 :   sh=bfffo(z[2]); /* z[2] != 0 */
         [ +  + ][ +  + ]
     733 [ +  + ][ +  + ]:  118176912 :   if (sh) shift_left(z,z, 2,lx-1, garde,sh);
     734                 :  118176912 :   z[1] = evalsigne(s) | evalexpo(e-sh);
     735         [ +  + ]:  118176912 :   if ((garde << sh) & HIGHBIT) roundr_up_ip(z, lx);
     736                 :  123117045 :   return z;
     737                 :            : }
     738                 :            : 
     739                 :            : GEN
     740                 :   46967908 : truedvmdii(GEN x, GEN y, GEN *z)
     741                 :            : {
     742                 :            :   pari_sp av;
     743                 :            :   GEN r, q, *gptr[2];
     744         [ +  + ]:   46967908 :   if (!is_bigint(y)) return truedvmdis(x, itos(y), z);
     745         [ -  + ]:     232693 :   if (z == ONLY_REM) return modii(x,y);
     746                 :            : 
     747                 :     232693 :   av = avma;
     748                 :     232693 :   q = dvmdii(x,y,&r); /* assume that r is last on stack */
     749   [ +  +  +  - ]:     232693 :   switch(signe(r))
     750                 :            :   {
     751                 :            :     case 0:
     752         [ +  + ]:      38323 :       if (z) *z = gen_0;
     753                 :      38323 :       return q;
     754                 :            :     case 1:
     755         [ +  + ]:     124670 :       if (z) *z = r; else cgiv(r);
     756                 :     124670 :       return q;
     757                 :      69700 :     case -1: break;
     758                 :            :   }
     759                 :      69700 :   q = addis(q, -signe(y));
     760         [ +  + ]:      69700 :   if (!z) return gerepileuptoint(av, q);
     761                 :            : 
     762                 :         67 :   *z = subiispec(y+2,r+2, lgefint(y)-2,lgefint(r)-2);
     763                 :         67 :   gptr[0]=&q; gptr[1]=z; gerepilemanysp(av,(pari_sp)r,gptr,2);
     764                 :   46967908 :   return q;
     765                 :            : }
     766                 :            : GEN
     767                 :   46735275 : truedvmdis(GEN x, long y, GEN *z)
     768                 :            : {
     769                 :   46735275 :   pari_sp av = avma;
     770                 :            :   long r;
     771                 :            :   GEN q;
     772                 :            : 
     773         [ -  + ]:   46735275 :   if (z == ONLY_REM) return modis(x, y);
     774                 :   46735275 :   q = divis_rem(x,y,&r);
     775                 :            : 
     776         [ +  + ]:   46735275 :   if (r >= 0)
     777                 :            :   {
     778         [ +  + ]:   43346107 :     if (z) *z = utoi(r);
     779                 :   43346107 :     return q;
     780                 :            :   }
     781         [ -  + ]:    3389168 :   q = gerepileuptoint(av, addis(q, (y < 0)? 1: -1));
     782         [ +  + ]:    3389168 :   if (z) *z = utoi(r + labs(y));
     783                 :   46735275 :   return q;
     784                 :            : }
     785                 :            : GEN
     786                 :    3925410 : truedvmdsi(long x, GEN y, GEN *z)
     787                 :            : {
     788                 :            :   long q, r;
     789         [ -  + ]:    3925410 :   if (z == ONLY_REM) return modsi(x, y);
     790                 :    3925410 :   q = sdivsi_rem(x,y,&r);
     791         [ +  - ]:    3925410 :   if (r >= 0) {
     792         [ -  + ]:    3925410 :     if (z) *z = utoi(r);
     793                 :    3925410 :     return stoi(q);
     794                 :            :   }
     795                 :          0 :   q = q - signe(y);
     796         [ #  # ]:          0 :   if (!z) return stoi(q);
     797                 :            : 
     798                 :          0 :   *z = subiuspec(y+2,(ulong)-r, lgefint(y)-2);
     799                 :    3925410 :   return stoi(q);
     800                 :            : }
     801                 :            : 
     802                 :            : /* 2^n = shifti(gen_1, n) */
     803                 :            : GEN
     804                 :   39868107 : int2n(long n) {
     805                 :            :   long i, m, l;
     806                 :            :   GEN z;
     807         [ +  + ]:   39868107 :   if (n < 0) return gen_0;
     808         [ +  + ]:   39867977 :   if (n == 0) return gen_1;
     809                 :            : 
     810                 :   39828751 :   l = dvmdsBIL(n, &m) + 3;
     811                 :   39828751 :   z = cgetipos(l);
     812         [ +  + ]:  188852375 :   for (i = 2; i < l; i++) z[i] = 0;
     813                 :   39868107 :   *int_MSW(z) = 1L << m; return z;
     814                 :            : }
     815                 :            : /* To avoid problems when 2^(BIL-1) < n. Overflow cleanly, where int2n
     816                 :            :  * returns gen_0 */
     817                 :            : GEN
     818                 :     964553 : int2u(ulong n) {
     819                 :            :   ulong i, m, l;
     820                 :            :   GEN z;
     821         [ -  + ]:     964553 :   if (n == 0) return gen_1;
     822                 :            : 
     823                 :     964553 :   l = dvmduBIL(n, &m) + 3;
     824                 :     964553 :   z = cgetipos(l);
     825         [ +  + ]:    2077321 :   for (i = 2; i < l; i++) z[i] = 0;
     826                 :     964553 :   *int_MSW(z) = 1L << m; return z;
     827                 :            : }
     828                 :            : 
     829                 :            : GEN
     830                 :  340833712 : shifti(GEN x, long n)
     831                 :            : {
     832                 :  340833712 :   long s = signe(x);
     833                 :            :   GEN y;
     834                 :            : 
     835         [ +  + ]:  340833712 :   if(s == 0) return gen_0;
     836                 :  304563278 :   y = shiftispec(x + 2, lgefint(x) - 2, n);
     837         [ +  + ]:  304563278 :   if (signe(y)) setsigne(y, s);
     838                 :  340833712 :   return y;
     839                 :            : }
     840                 :            : 
     841                 :            : /* actual operations will take place on a+2 and b+2: we strip the codewords */
     842                 :            : GEN
     843                 : 3384350935 : mulii(GEN a,GEN b)
     844                 :            : {
     845                 :            :   long sa,sb;
     846                 :            :   GEN z;
     847                 :            : 
     848         [ +  + ]: 3384350935 :   sa=signe(a); if (!sa) return gen_0;
     849         [ +  + ]: 2581325403 :   sb=signe(b); if (!sb) return gen_0;
     850         [ +  + ]: 1585696817 :   if (sb<0) sa = -sa;
     851                 : 1585696817 :   z = muliispec(a+2,b+2, lgefint(a)-2,lgefint(b)-2);
     852                 : 3384350935 :   setsigne(z,sa); return z;
     853                 :            : }
     854                 :            : 
     855                 :            : GEN
     856                 :  733315080 : sqri(GEN a) { return sqrispec(a+2, lgefint(a)-2); }
     857                 :            : 
     858                 :            : /* sqrt()'s result may be off by 1 when a is not representable exactly as a
     859                 :            :  * double [64bit machine] */
     860                 :            : ulong
     861                 :    4794045 : usqrt(ulong a)
     862                 :            : {
     863                 :    4794045 :   ulong x = (ulong)sqrt((double)a);
     864                 :            : #ifdef LONG_IS_64BIT
     865 [ +  - ][ -  + ]:    3838580 :   if (x > LOWMASK || x*x > a) x--;
     866                 :            : #endif
     867                 :    4794045 :   return x;
     868                 :            : }
     869                 :            : 
     870                 :            : /********************************************************************/
     871                 :            : /**                                                                **/
     872                 :            : /**              EXPONENT / CONVERSION t_REAL --> double           **/
     873                 :            : /**                                                                **/
     874                 :            : /********************************************************************/
     875                 :            : 
     876                 :            : #ifdef LONG_IS_64BIT
     877                 :            : long
     878                 :          0 : dblexpo(double x)
     879                 :            : {
     880                 :            :   union { double f; ulong i; } fi;
     881                 :          0 :   const int mant_len = 52;  /* mantissa bits (excl. hidden bit) */
     882                 :          0 :   const int exp_mid = 0x3ff;/* exponent bias */
     883                 :            : 
     884         [ #  # ]:          0 :   if (x==0.) return -exp_mid;
     885                 :          0 :   fi.f = x;
     886                 :          0 :   return ((fi.i & (HIGHBIT-1)) >> mant_len) - exp_mid;
     887                 :            : }
     888                 :            : 
     889                 :            : ulong
     890                 :          0 : dblmantissa(double x)
     891                 :            : {
     892                 :            :   union { double f; ulong i; } fi;
     893                 :          0 :   const int expo_len = 11; /* number of bits of exponent */
     894                 :            : 
     895         [ #  # ]:          0 :   if (x==0.) return 0;
     896                 :          0 :   fi.f = x;
     897                 :          0 :   return (fi.i << expo_len) | HIGHBIT;
     898                 :            : }
     899                 :            : 
     900                 :            : GEN
     901                 :    2642984 : dbltor(double x)
     902                 :            : {
     903                 :            :   GEN z;
     904                 :            :   long e;
     905                 :            :   union { double f; ulong i; } fi;
     906                 :    2642984 :   const int mant_len = 52;  /* mantissa bits (excl. hidden bit) */
     907                 :    2642984 :   const int exp_mid = 0x3ff;/* exponent bias */
     908                 :    2642984 :   const int expo_len = 11; /* number of bits of exponent */
     909                 :            : 
     910         [ +  + ]:    2642984 :   if (x==0.) return real_0_bit(-exp_mid);
     911                 :    2642852 :   fi.f = x; z = cgetr(DEFAULTPREC);
     912                 :            :   {
     913                 :    2642852 :     const ulong a = fi.i;
     914                 :            :     ulong A;
     915                 :    2642852 :     e = ((a & (HIGHBIT-1)) >> mant_len) - exp_mid;
     916         [ -  + ]:    2642852 :     if (e == exp_mid+1) pari_err_OVERFLOW("dbltor [NaN or Infinity]");
     917                 :    2642852 :     A = a << expo_len;
     918         [ -  + ]:    2642852 :     if (e == -exp_mid)
     919                 :            :     { /* unnormalized values */
     920 [ #  # ][ #  # ]:          0 :       int sh = bfffo(A);
         [ #  # ][ #  # ]
     921                 :          0 :       e -= sh-1;
     922                 :          0 :       z[2] = A << sh;
     923                 :            :     }
     924                 :            :     else
     925                 :    2642852 :       z[2] = HIGHBIT | A;
     926         [ +  + ]:    2642852 :     z[1] = _evalexpo(e) | evalsigne(x<0? -1: 1);
     927                 :            :   }
     928                 :    2642984 :   return z;
     929                 :            : }
     930                 :            : 
     931                 :            : double
     932                 :   10651978 : rtodbl(GEN x)
     933                 :            : {
     934                 :   10651978 :   long ex,s=signe(x);
     935                 :            :   ulong a;
     936                 :            :   union { double f; ulong i; } fi;
     937                 :   10651978 :   const int mant_len = 52;  /* mantissa bits (excl. hidden bit) */
     938                 :   10651978 :   const int exp_mid = 0x3ff;/* exponent bias */
     939                 :   10651978 :   const int expo_len = 11; /* number of bits of exponent */
     940                 :            : 
     941 [ +  + ][ -  + ]:   10651978 :   if (!s || (ex=expo(x)) < - exp_mid) return 0.0;
     942                 :            : 
     943                 :            :   /* start by rounding to closest */
     944                 :   10634082 :   a = (x[2] & (HIGHBIT-1)) + 0x400;
     945         [ +  + ]:   10634082 :   if (a & HIGHBIT) { ex++; a=0; }
     946         [ -  + ]:   10634082 :   if (ex >= exp_mid) pari_err_OVERFLOW("t_REAL->double conversion");
     947                 :   10634082 :   fi.i = ((ex + exp_mid) << mant_len) | (a >> expo_len);
     948         [ +  + ]:   10634082 :   if (s<0) fi.i |= HIGHBIT;
     949                 :   10651978 :   return fi.f;
     950                 :            : }
     951                 :            : 
     952                 :            : #else /* LONG_IS_64BIT */
     953                 :            : 
     954                 :            : #if   PARI_DOUBLE_FORMAT == 1
     955                 :            : #  define INDEX0 1
     956                 :            : #  define INDEX1 0
     957                 :            : #elif PARI_DOUBLE_FORMAT == 0
     958                 :            : #  define INDEX0 0
     959                 :            : #  define INDEX1 1
     960                 :            : #endif
     961                 :            : 
     962                 :            : long
     963                 :          0 : dblexpo(double x)
     964                 :            : {
     965                 :            :   union { double f; ulong i[2]; } fi;
     966                 :          0 :   const int mant_len = 52;  /* mantissa bits (excl. hidden bit) */
     967                 :          0 :   const int exp_mid = 0x3ff;/* exponent bias */
     968                 :          0 :   const int shift = mant_len-32;
     969                 :            : 
     970         [ #  # ]:          0 :   if (x==0.) return -exp_mid;
     971                 :          0 :   fi.f = x;
     972                 :            :   {
     973                 :          0 :     const ulong a = fi.i[INDEX0];
     974                 :          0 :     return ((a & (HIGHBIT-1)) >> shift) - exp_mid;
     975                 :            :   }
     976                 :            : }
     977                 :            : 
     978                 :            : ulong
     979                 :          0 : dblmantissa(double x)
     980                 :            : {
     981                 :            :   union { double f; ulong i[2]; } fi;
     982                 :          0 :   const int expo_len = 11; /* number of bits of exponent */
     983                 :            : 
     984         [ #  # ]:          0 :   if (x==0.) return 0;
     985                 :          0 :   fi.f = x;
     986                 :            :   {
     987                 :          0 :     const ulong a = fi.i[INDEX0];
     988                 :          0 :     const ulong b = fi.i[INDEX1];
     989                 :          0 :     return HIGHBIT | b >> (BITS_IN_LONG-expo_len) | (a << expo_len);
     990                 :            :   }
     991                 :            : }
     992                 :            : 
     993                 :            : GEN
     994                 :     615525 : dbltor(double x)
     995                 :            : {
     996                 :            :   GEN z;
     997                 :            :   long e;
     998                 :            :   union { double f; ulong i[2]; } fi;
     999                 :     615525 :   const int mant_len = 52;  /* mantissa bits (excl. hidden bit) */
    1000                 :     615525 :   const int exp_mid = 0x3ff;/* exponent bias */
    1001                 :     615525 :   const int expo_len = 11; /* number of bits of exponent */
    1002                 :     615525 :   const int shift = mant_len-32;
    1003                 :            : 
    1004         [ -  + ]:     615525 :   if (x==0.) return real_0_bit(-exp_mid);
    1005                 :     615525 :   fi.f = x; z = cgetr(DEFAULTPREC);
    1006                 :            :   {
    1007                 :     615525 :     const ulong a = fi.i[INDEX0];
    1008                 :     615525 :     const ulong b = fi.i[INDEX1];
    1009                 :            :     ulong A, B;
    1010                 :     615525 :     e = ((a & (HIGHBIT-1)) >> shift) - exp_mid;
    1011         [ -  + ]:     615525 :     if (e == exp_mid+1) pari_err_OVERFLOW("dbltor [NaN or Infinity]");
    1012                 :     615525 :     A = b >> (BITS_IN_LONG-expo_len) | (a << expo_len);
    1013                 :     615525 :     B = b << expo_len;
    1014         [ -  + ]:     615525 :     if (e == -exp_mid)
    1015                 :            :     { /* unnormalized values */
    1016                 :            :       int sh;
    1017         [ #  # ]:          0 :       if (A)
    1018                 :            :       {
    1019                 :          0 :         sh = bfffo(A);
    1020                 :          0 :         e -= sh-1;
    1021                 :          0 :         z[2] = (A << sh) | (B >> (32-sh));
    1022                 :          0 :         z[3] = B << sh;
    1023                 :            :       }
    1024                 :            :       else
    1025                 :            :       {
    1026                 :          0 :         sh = bfffo(B); /* B != 0 */
    1027                 :          0 :         e -= sh-1 + 32;
    1028                 :          0 :         z[2] = B << sh;
    1029                 :          0 :         z[3] = 0;
    1030                 :            :       }
    1031                 :            :     }
    1032                 :            :     else
    1033                 :            :     {
    1034                 :     615525 :       z[3] = B;
    1035                 :     615525 :       z[2] = HIGHBIT | A;
    1036                 :            :     }
    1037         [ +  + ]:     615525 :     z[1] = _evalexpo(e) | evalsigne(x<0? -1: 1);
    1038                 :            :   }
    1039                 :     615525 :   return z;
    1040                 :            : }
    1041                 :            : 
    1042                 :            : double
    1043                 :    2456562 : rtodbl(GEN x)
    1044                 :            : {
    1045                 :    2456562 :   long ex,s=signe(x),lx=lg(x);
    1046                 :            :   ulong a,b,k;
    1047                 :            :   union { double f; ulong i[2]; } fi;
    1048                 :    2456562 :   const int mant_len = 52;  /* mantissa bits (excl. hidden bit) */
    1049                 :    2456562 :   const int exp_mid = 0x3ff;/* exponent bias */
    1050                 :    2456562 :   const int expo_len = 11; /* number of bits of exponent */
    1051                 :    2456562 :   const int shift = mant_len-32;
    1052                 :            : 
    1053 [ +  + ][ -  + ]:    2456562 :   if (!s || (ex=expo(x)) < - exp_mid) return 0.0;
    1054                 :            : 
    1055                 :            :   /* start by rounding to closest */
    1056                 :    2452289 :   a = x[2] & (HIGHBIT-1);
    1057         [ +  + ]:    2452289 :   if (lx > 3)
    1058                 :            :   {
    1059         [ +  + ]:    2349963 :     b = x[3] + 0x400UL; if (b < 0x400UL) a++;
    1060         [ +  + ]:    2349963 :     if (a & HIGHBIT) { ex++; a=0; }
    1061                 :            :   }
    1062                 :     102326 :   else b = 0;
    1063         [ -  + ]:    2452289 :   if (ex >= exp_mid) pari_err_OVERFLOW("t_REAL->double conversion");
    1064                 :    2452289 :   ex += exp_mid;
    1065                 :    2452289 :   k = (a >> expo_len) | (ex << shift);
    1066         [ +  + ]:    2452289 :   if (s<0) k |= HIGHBIT;
    1067                 :    2452289 :   fi.i[INDEX0] = k;
    1068                 :    2452289 :   fi.i[INDEX1] = (a << (BITS_IN_LONG-expo_len)) | (b >> expo_len);
    1069                 :    2456562 :   return fi.f;
    1070                 :            : }
    1071                 :            : #endif /* LONG_IS_64BIT */
    1072                 :            : 

Generated by: LCOV version 1.9