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 - gcd.c (source / functions) Hit Total Coverage
Test: PARI/GP v2.14.0 lcov report (development 27095-7e0f67a20c) Lines: 67 67 100.0 %
Date: 2021-11-29 07:04:58 Functions: 4 4 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : #line 2 "../src/kernel/none/gcd.c"
       2             : /* Copyright (C) 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             : /* assume y > x > 0. return y mod x */
      17             : static ulong
      18    16226106 : resiu(GEN y, ulong x)
      19             : {
      20    16226106 :   long i, ly = lgefint(y);
      21    16226106 :   ulong xi = get_Fl_red(x);
      22             :   LOCAL_HIREMAINDER;
      23             : 
      24    16226106 :   hiremainder = 0;
      25    88766289 :   for (i=2; i<ly; i++) (void)divll_pre(y[i],x,xi);
      26    16226106 :   return hiremainder;
      27             : }
      28             : 
      29             : /* Assume x>y>0, both of them odd. return x-y if x=y mod 4, x+y otherwise */
      30             : static void
      31   801505032 : gcd_plus_minus(GEN x, GEN y, GEN res)
      32             : {
      33   801505032 :   pari_sp av = avma;
      34   801505032 :   long lx = lgefint(x)-1;
      35   801505032 :   long ly = lgefint(y)-1, lt,m,i;
      36             :   GEN t;
      37             : 
      38   801505032 :   if ((x[lx]^y[ly]) & 3) /* x != y mod 4*/
      39   401360919 :     t = addiispec(x+2,y+2,lx-1,ly-1);
      40             :   else
      41   400144113 :     t = subiispec(x+2,y+2,lx-1,ly-1);
      42             : 
      43   802795698 :   lt = lgefint(t)-1; while (!t[lt]) lt--;
      44   801505032 :   m = vals(t[lt]); lt++;
      45   801505032 :   if (m == 0) /* 2^32 | t */
      46             :   {
      47       33603 :     for (i = 2; i < lt; i++) res[i] = t[i];
      48             :   }
      49   801492060 :   else if (t[2] >> m)
      50             :   {
      51   759916023 :     shift_right(res,t, 2,lt, 0,m);
      52             :   }
      53             :   else
      54             :   {
      55    41576037 :     lt--; t++;
      56    41576037 :     shift_right(res,t, 2,lt, t[1],m);
      57             :   }
      58   801505032 :   res[1] = evalsigne(1)|evallgefint(lt);
      59   801505032 :   set_avma(av);
      60   801505032 : }
      61             : 
      62             : /* uses modified right-shift binary algorithm now --GN 1998Jul23 */
      63             : static GEN
      64   235213053 : gcdii_basecase(GEN a, GEN b)
      65             : {
      66             :   long v, w;
      67             :   pari_sp av;
      68             :   GEN t, p1;
      69             : 
      70   235213053 :   switch (abscmpii(a,b))
      71             :   {
      72    43770594 :     case 0: return absi(a);
      73    95743608 :     case -1: swap(a,b);
      74             :   }
      75   191442459 :   if (!signe(b)) return absi(a);
      76             :   /* here |a|>|b|>0. Try single precision first */
      77   125414223 :   if (lgefint(a)==3)
      78    97573878 :     return igcduu((ulong)a[2], (ulong)b[2]);
      79    27840345 :   if (lgefint(b)==3)
      80             :   {
      81    16226106 :     ulong u = resiu(a,(ulong)b[2]);
      82    16226106 :     if (!u) return absi(b);
      83     8601531 :     return igcduu((ulong)b[2], u);
      84             :   }
      85             : 
      86             :   /* larger than gcd: "set_avma(av)" gerepile (erasing t) is valid */
      87    11614239 :   av = avma; (void)new_chunk(lgefint(b)); /* HACK */
      88    11614239 :   t = remii(a,b);
      89    11614239 :   if (!signe(t)) { set_avma(av); return absi(b); }
      90             : 
      91     6905082 :   a = b; b = t;
      92     6905082 :   v = vali(a); a = shifti(a,-v); setabssign(a);
      93     6905082 :   w = vali(b); b = shifti(b,-w); setabssign(b);
      94     6905082 :   if (w < v) v = w;
      95     6905082 :   switch(abscmpii(a,b))
      96             :   {
      97      143709 :     case  0: set_avma(av); a = shifti(a,v); return a;
      98     1378116 :     case -1: swap(a,b);
      99             :   }
     100     6761373 :   if (is_pm1(b)) { set_avma(av); return int2n(v); }
     101             : 
     102             :   /* we have three consecutive memory locations: a,b,t.
     103             :    * All computations are done in place */
     104             : 
     105             :   /* a and b are odd now, and a>b>1 */
     106     6711960 :   while (lgefint(a) > 3)
     107             :   {
     108             :     /* if a=b mod 4 set t=a-b, otherwise t=a+b, then strip powers of 2 */
     109             :     /* so that t <= (a+b)/4 < a/2 */
     110   801505032 :     gcd_plus_minus(a,b, t);
     111   801505032 :     if (is_pm1(t)) { set_avma(av); return int2n(v); }
     112   801206514 :     switch(abscmpii(t,b))
     113             :     {
     114   518328114 :       case -1: p1 = a; a = b; b = t; t = p1; break;
     115   281438070 :       case  1: swap(a,t); break;
     116     1440330 :       case  0: set_avma(av); b = shifti(b,v); return b;
     117             :     }
     118   806478144 :   }
     119             :   {
     120     4973112 :     long r[] = {evaltyp(t_INT)|_evallg(3), evalsigne(1)|evallgefint(3), 0};
     121     4973112 :     r[2] = (long) gcduodd((ulong)b[2], (ulong)a[2]);
     122     4973112 :     set_avma(av); return shifti(r,v);
     123             :   }
     124             : }
     125             : 
     126             : GEN
     127   235213053 : gcdii(GEN x, GEN y)
     128             : {
     129   235213053 :   pari_sp av=avma;
     130   235271727 :   while (lgefint(y)-2 >= GCD_HALFGCD_LIMIT)
     131             :   {
     132       58674 :     GEN M = HGCD0(x,y);
     133       58674 :     x = gel(M,2); y = gel(M,3);
     134       58674 :     if (signe(y) && expi(y)<magic_threshold(x))
     135             :     {
     136       41310 :       swap(x,y);
     137       41310 :       y = remii(y,x);
     138             :     }
     139       58674 :     if (gc_needed(av, 1)) gerepileall(av,2,&x,&y);
     140             :   }
     141   235213053 :   return gerepileuptoint(av, gcdii_basecase(x,y));
     142             : }

Generated by: LCOV version 1.13