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-bordeaux.fr machine (x86_64 architecture), and agregate them in the final report:

The target is to exceed 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 - add.c (source / functions) Hit Total Coverage
Test: PARI/GP v2.16.2 lcov report (development 29115-f22e516b23) Lines: 187 187 100.0 %
Date: 2024-04-22 08:08:03 Functions: 10 10 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : #line 2 "../src/kernel/none/add.c"
       2             : /* Copyright (C) 2002-2003  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; either version 2 of the License, or (at your option) any later
       9             : version. It is distributed in the hope that it will be useful, but WITHOUT
      10             : ANY WARRANTY WHATSOEVER.
      11             : 
      12             : Check the License for details. You should have received a copy of it, along
      13             : with the package; see the file 'COPYING'. If not, write to the Free Software
      14             : Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
      15             : 
      16             : INLINE GEN
      17  2952379771 : icopy_sign(GEN x, long sx)
      18             : {
      19  2952379771 :   GEN y=icopy(x);
      20  2961522798 :   setsigne(y,sx);
      21  2961522798 :   return y;
      22             : }
      23             : 
      24             : GEN
      25   302428409 : addsi_sign(long x, GEN y, long sy)
      26             : {
      27             :   long sx,ly;
      28             :   GEN z;
      29             : 
      30   302428409 :   if (!x) return icopy_sign(y, sy);
      31   286755127 :   if (!sy) return stoi(x);
      32   158099737 :   if (x<0) { sx=-1; x=-x; } else sx=1;
      33   158099737 :   if (sx==sy)
      34             :   {
      35    50414315 :     z = adduispec(x,y+2, lgefint(y)-2);
      36    50407499 :     setsigne(z,sy); return z;
      37             :   }
      38   107685422 :   ly=lgefint(y);
      39   107685422 :   if (ly==3)
      40             :   {
      41    19061396 :     const long d = (long)(uel(y,2) - (ulong)x);
      42    19061396 :     if (!d) return gen_0;
      43    17882032 :     z=cgeti(3);
      44    17879260 :     if (y[2] < 0 || d > 0) {
      45    14895910 :       z[1] = evalsigne(sy) | evallgefint(3);
      46    14895910 :       z[2] = d;
      47             :     }
      48             :     else {
      49     2983350 :       z[1] = evalsigne(-sy) | evallgefint(3);
      50     2983350 :       z[2] =-d;
      51             :     }
      52    17879260 :     return z;
      53             :   }
      54    88624026 :   z = subiuspec(y+2,x, ly-2);
      55    88741016 :   setsigne(z,sy); return z;
      56             : }
      57             : GEN
      58   226736589 : addui_sign(ulong x, GEN y, long sy)
      59             : {
      60             :   long ly;
      61             :   GEN z;
      62             : 
      63   226736589 :   if (!x) return icopy_sign(y, sy);
      64   225192632 :   if (!sy) return utoipos(x);
      65   219771981 :   if (sy == 1) return adduispec(x,y+2, lgefint(y)-2);
      66   111197967 :   ly=lgefint(y);
      67   111197967 :   if (ly==3)
      68             :   {
      69    25236540 :     const ulong t = y[2];
      70    25236540 :     if (x == t) return gen_0;
      71    23372575 :     z=cgeti(3);
      72    23372223 :     if (x < t) {
      73    23139230 :       z[1] = evalsigne(-1) | evallgefint(3);
      74    23139230 :       z[2] = t - x;
      75             :     }
      76             :     else {
      77      232993 :       z[1] = evalsigne(1) | evallgefint(3);
      78      232993 :       z[2] = x - t;
      79             :     }
      80    23372223 :     return z;
      81             :   }
      82    85961427 :   z = subiuspec(y+2,x, ly-2);
      83    85963476 :   setsigne(z,-1); return z;
      84             : }
      85             : 
      86             : /* return gen_0 when the sign is 0 */
      87             : GEN
      88 16443750979 : addii_sign(GEN x, long sx, GEN y, long sy)
      89             : {
      90             :   long lx,ly;
      91             :   GEN z;
      92             : 
      93 16443750979 :   if (!sx) return sy? icopy_sign(y, sy): gen_0;
      94 13005702211 :   if (!sy) return icopy_sign(x, sx);
      95 11188375328 :   lx = lgefint(x);
      96 11188375328 :   ly = lgefint(y);
      97 11188375328 :   if (sx==sy)
      98  6062517196 :     z = addiispec(x+2,y+2,lx-2,ly-2);
      99             :   else
     100             :   { /* sx != sy */
     101  5125858132 :     long i = cmpiispec(x+2,y+2,lx-2,ly-2);
     102  5201261015 :     if (!i) return gen_0;
     103             :     /* we must ensure |x| > |y| for subiispec */
     104  4938820884 :     if (i < 0) {
     105  2001365285 :       sx = sy;
     106  2001365285 :       z = subiispec(y+2,x+2,ly-2,lx-2);
     107             :     }
     108             :     else
     109  2937455599 :       z = subiispec(x+2,y+2,lx-2,ly-2);
     110             :   }
     111 10976268288 :   setsigne(z,sx); return z;
     112             : }
     113             : 
     114             : INLINE GEN
     115   391494533 : rcopy_sign(GEN x, long sx) { GEN y = rcopy(x); setsigne(y,sx); return y; }
     116             : 
     117             : GEN
     118   481724869 : addir_sign(GEN x, long sx, GEN y, long sy)
     119             : {
     120             :   long e, l, ly;
     121             :   GEN z;
     122             : 
     123   481724869 :   if (!sx) return rcopy_sign(y, sy);
     124   145019928 :   e = expo(y) - expi(x);
     125   145077448 :   if (!sy)
     126             :   {
     127     1306163 :     if (e >= 0) return rcopy_sign(y, sy);
     128     1306129 :     z = itor(x, nbits2prec(-e));
     129     1305671 :     setsigne(z, sx); return z;
     130             :   }
     131             : 
     132   143771285 :   ly = lg(y);
     133   143771285 :   if (e > 0)
     134             :   {
     135    40032692 :     l = lg2prec(ly - divsBIL(e));
     136    40031995 :     if (l < LOWDEFAULTPREC) return rcopy_sign(y, sy);
     137             :   }
     138   103738593 :   else l = lg2prec(ly) + nbits2extraprec(-e);
     139   143290452 :   z = (GEN)avma;
     140   143290452 :   y = addrr_sign(itor(x,l), sx, y, sy);
     141  1108520107 :   ly = lg(y); while (ly--) *--z = y[ly];
     142   143257402 :   set_avma((pari_sp)z); return z;
     143             : }
     144             : 
     145             : static GEN
     146   486180913 : addsr_sign(long x, GEN y, long sy)
     147             : {
     148             :   long e, l, ly, sx;
     149             :   GEN z;
     150             : 
     151   486180913 :   if (!x) return rcopy_sign(y, sy);
     152   486173304 :   if (x < 0) { sx = -1; x = -x; } else sx = 1;
     153   486173304 :   e = expo(y) - expu(x);
     154   486117513 :   if (!sy)
     155             :   {
     156      540309 :     if (e >= 0) return rcopy_sign(y, sy);
     157      540281 :     if (sx == -1) x = -x;
     158      540281 :     return stor(x, nbits2prec(-e));
     159             :   }
     160             : 
     161   485577204 :   ly = lg(y);
     162   485577204 :   if (e > 0)
     163             :   {
     164     6038190 :     l = lg2prec(ly - divsBIL(e));
     165     6038167 :     if (l < LOWDEFAULTPREC) return rcopy_sign(y, sy);
     166             :   }
     167   479539014 :   else l = lg2prec(ly) + nbits2extraprec(-e);
     168   484557381 :   z = (GEN)avma;
     169   484557381 :   y = addrr_sign(stor(x,l), sx, y, sy);
     170  6224074921 :   ly = lg(y); while (ly--) *--z = y[ly];
     171   484767318 :   set_avma((pari_sp)z); return z;
     172             : }
     173             : 
     174             : GEN
     175   473762270 : addsr(long x, GEN y) { return addsr_sign(x, y, signe(y)); }
     176             : 
     177             : GEN
     178    12434494 : subsr(long x, GEN y) { return addsr_sign(x, y, -signe(y)); }
     179             : 
     180             : GEN
     181  4942337375 : addrr_sign(GEN x, long sx, GEN y, long sy)
     182             : {
     183  4942337375 :   long lx, ex = expo(x);
     184  4942337375 :   long ly, ey = expo(y), e = ey - ex;
     185             :   long i, j, lz, ez, m;
     186             :   int extend, f2;
     187             :   GEN z;
     188             :   LOCAL_OVERFLOW;
     189             : 
     190  4942337375 :   if (!sy)
     191             :   {
     192   334696406 :     if (!sx)
     193             :     {
     194    95807436 :       if (e > 0) ex = ey;
     195    95807436 :       return real_0_bit(ex);
     196             :     }
     197   238888970 :     if (e >= 0) return real_0_bit(ey);
     198   237797620 :     lz = nbits2lg(-e);
     199   237996836 :     lx = lg(x); if (lz > lx) lz = lx;
     200  2029236843 :     z = cgetg(lz, t_REAL); while(--lz) z[lz] = x[lz];
     201   238027307 :     setsigne(z,sx); return z;
     202             :   }
     203  4607640969 :   if (!sx)
     204             :   {
     205    28646390 :     if (e <= 0) return real_0_bit(ex);
     206    27060237 :     lz = nbits2lg(e);
     207    27060008 :     ly = lg(y); if (lz > ly) lz = ly;
     208   139928255 :     z = cgetg(lz, t_REAL); while (--lz) z[lz] = y[lz];
     209    27057102 :     setsigne(z,sy); return z;
     210             :   }
     211             : 
     212  4578994579 :   if (e < 0) { swap(x,y); lswap(sx,sy); ey=ex; e=-e; }
     213             :   /* now ey >= ex */
     214  4578994579 :   lx = lg(x);
     215  4578994579 :   ly = lg(y);
     216             :   /* If exponents differ, need to shift one argument, here x. If
     217             :    * extend = 1: extension of x,z by m < BIL bits (round to 1 word) */
     218             :   /* in this case, lz = lx + d + 1, otherwise lx + d */
     219  4578994579 :   extend = 0;
     220  4578994579 :   if (e)
     221             :   {
     222  3959854088 :     long d = dvmdsBIL(e, &m), l = ly-d;
     223  3957583127 :     if (l <= 2) return rcopy_sign(y, sy);
     224  3909352766 :     if (l > lx) { lz = lx + d + 1; extend = 1; }
     225  3124436185 :     else        { lz = ly; lx = l; }
     226  3909352766 :     if (m)
     227             :     { /* shift x right m bits */
     228  3896648353 :       const pari_sp av = avma;
     229  3896648353 :       const ulong sh = BITS_IN_LONG-m;
     230  3896648353 :       GEN p1 = x; x = new_chunk(lx + lz + 1);
     231  3891836574 :       shift_right(x,p1,2,lx, 0,m);
     232  3894411292 :       if (extend) uel(x,lx) = uel(p1,lx-1) << sh;
     233  3894411292 :       set_avma(av); /* HACK: cgetg(lz, t_REAL) will not overwrite x */
     234             :     }
     235             :   }
     236             :   else
     237             :   { /* d = 0 */
     238   619140491 :     m = 0;
     239   619140491 :     if (lx > ly) lx = ly;
     240   619140491 :     lz = lx;
     241             :   }
     242             : 
     243  4532719074 :   if (sx == sy)
     244             :   { /* addition */
     245  2348735498 :     i = lz-1;
     246  2348735498 :     j = lx-1;
     247  2348735498 :     if (extend) {
     248   473909069 :       ulong garde = addll(x[lx], y[i]);
     249   473909069 :       if (m < 4) /* don't extend for few correct bits */
     250    56064079 :         z = cgetg(--lz, t_REAL);
     251             :       else
     252             :       {
     253   417844990 :         z = cgetg(lz, t_REAL);
     254   417778105 :         z[i] = garde;
     255             :       }
     256             :     }
     257             :     else
     258             :     {
     259  1874826429 :       z = cgetg(lz, t_REAL);
     260  1874668545 :       z[i] = addll(x[j], y[i]); j--;
     261             :     }
     262  2344840292 :     i--;
     263 11952667732 :     for (; j>=2; i--,j--) z[i] = addllx(x[j],y[i]);
     264  2344840292 :     if (overflow)
     265             :     {
     266   556813801 :       z[1] = 1; /* stops since z[1] != 0 */
     267   557994658 :       for (;;) { z[i] = uel(y,i)+1; if (z[i--]) break; }
     268   556813801 :       if (i <= 0)
     269             :       {
     270   553290979 :         shift_right(z,z, 2,lz, 1,1);
     271   553592218 :         z[1] = evalsigne(sx) | evalexpo(ey+1); return z;
     272             :       }
     273             :     }
     274  2268386985 :     for (; i>=2; i--) z[i] = y[i];
     275  1791549313 :     z[1] = evalsigne(sx) | evalexpo(ey); return z;
     276             :   }
     277             : 
     278             :   /* subtraction */
     279  2183983576 :   if (e) f2 = 1;
     280             :   else
     281             :   {
     282   591325808 :     i = 2; while (i < lx && x[i] == y[i]) i++;
     283   357291323 :     if (i==lx) return real_0_bit(ey+1 - lg2prec(lx));
     284   332448445 :     f2 = (uel(y,i) > uel(x,i));
     285             :   }
     286             :   /* result is nonzero. f2 = (y > x) */
     287  2159140698 :   i = lz-1; z = cgetg(lz, t_REAL);
     288  2154557374 :   if (f2)
     289             :   {
     290  2009167727 :     j = lx-1;
     291  2009167727 :     if (extend) z[i] = subll(y[i], x[lx]);
     292  1698704269 :     else        z[i] = subll(y[i], x[j--]);
     293 11818920484 :     for (i--; j>=2; i--) z[i] = subllx(y[i], x[j--]);
     294  2009167727 :     if (overflow) /* stops since y[1] != 0 */
     295    65315881 :       for (;;) { z[i] = uel(y,i)-1; if (y[i--]) break; }
     296  2351615022 :     for (; i>=2; i--) z[i] = y[i];
     297  2009167727 :     sx = sy;
     298             :   }
     299             :   else
     300             :   {
     301   145389647 :     if (extend) z[i] = subll(x[lx], y[i]);
     302   145389647 :     else        z[i] = subll(x[i],  y[i]);
     303   702953626 :     for (i--; i>=2; i--) z[i] = subllx(x[i], y[i]);
     304             :   }
     305             : 
     306  2309685894 :   x = z+2; i = 0; while (!x[i]) i++;
     307  2154557374 :   lz -= i; z += i;
     308  2154557374 :   j = bfffo(z[2]); /* need to shift left by j bits to normalize mantissa */
     309  2154557374 :   ez = ey - (j | (i * BITS_IN_LONG));
     310  2154557374 :   if (extend)
     311             :   { /* z was extended by d+1 words [should be e bits = d words + m bits] */
     312             :     /* not worth keeping extra word if less than 5 significant bits in there */
     313   310878811 :     if (m - j < 5 && lz > 3)
     314   170149465 :     { /* shorten z */
     315   170143318 :       ulong last = (ulong)z[--lz]; /* cancelled word */
     316             : 
     317             :       /* if we need to shift anyway, shorten from left
     318             :        * If not, shorten from right, neutralizing last word of z */
     319   170143318 :       if (j == 0)
     320             :         /* stackdummy((pari_sp)(z + lz+1), (pari_sp)(z + lz)); */
     321    13255761 :         z[lz] = evaltyp(t_VECSMALL) | _evallg(1);
     322             :       else
     323             :       {
     324   156887557 :         GEN t = z;
     325   156887557 :         z++; shift_left(z,t,2,lz-1, last,j);
     326             :       }
     327   170149465 :       if ((last<<j) & HIGHBIT)
     328             :       { /* round up */
     329    61624317 :         i = lz-1;
     330    61766490 :         while (++((ulong*)z)[i] == 0 && i > 1) i--;
     331    61624317 :         if (i == 1) { ez++; z[2] = (long)HIGHBIT; }
     332             :       }
     333             :     }
     334   140735493 :     else if (j) shift_left(z,z,2,lz-1, 0,j);
     335             :   }
     336  1843678563 :   else if (j) shift_left(z,z,2,lz-1, 0,j);
     337  2155699880 :   z[1] = evalsigne(sx) | evalexpo(ez);
     338  2163070322 :   z[0] = evaltyp(t_REAL) | evallg(lz);
     339  2161809654 :   set_avma((pari_sp)z); return z;
     340             : }

Generated by: LCOV version 1.14