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 - basemath - F3v.c (source / functions) Hit Total Coverage
Test: PARI/GP v2.14.0 lcov report (development 27775-aca467eab2) Lines: 152 182 83.5 %
Date: 2022-07-03 07:33:15 Functions: 23 30 76.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* Copyright (C) 2021 The PARI group.
       2             : 
       3             : This file is part of the PARI/GP package.
       4             : 
       5             : PARI/GP is free software; you can redistribute it and/or modify it under the
       6             : terms of the GNU General Public License as published by the Free Software
       7             : Foundation; either version 2 of the License, or (at your option) any later
       8             : version. 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             : #include "pari.h"
      16             : #include "paripriv.h"
      17             : 
      18             : #define DEBUGLEVEL DEBUGLEVEL_mat
      19             : 
      20             : GEN
      21      234675 : zero_F3v(long m)
      22             : {
      23      234675 :   long l = nbits2nlong(2*m);
      24      234675 :   GEN v  = const_vecsmall(l+1, 0);
      25      234675 :   v[1] = m;
      26      234675 :   return v;
      27             : }
      28             : 
      29             : GEN
      30       84041 : zero_F3m_copy(long m, long n)
      31             : {
      32             :   long i;
      33       84041 :   GEN M = cgetg(n+1, t_MAT);
      34      241368 :   for (i = 1; i <= n; i++)
      35      157327 :     gel(M,i)= zero_F3v(m);
      36       84041 :   return M;
      37             : }
      38             : #define TRITS_IN_LONG (BITS_IN_LONG>>1)
      39             : #define TRITS_MASK (ULONG_MAX/3UL)
      40             : #define TWOPOTTRITS_IN_LONG (TWOPOTBITS_IN_LONG-1)
      41             : 
      42             : ulong
      43     4461872 : F3v_coeff(GEN x,long v)
      44             : {
      45     4461872 :   long pos = (v-1)>>TWOPOTTRITS_IN_LONG;
      46     4461872 :   long r = (v-1)&(BITS_IN_LONG-1);
      47     4461872 :   ulong u=(ulong)x[2+pos];
      48     4461872 :   return (u>>(2*r))&3UL;
      49             : }
      50             : 
      51             : void
      52      450951 : F3v_clear(GEN x, long v)
      53             : {
      54      450951 :   long pos = (v-1)>>TWOPOTTRITS_IN_LONG;
      55      450951 :   long r = (v-1)&(BITS_IN_LONG-1);
      56      450951 :   ulong *u=(ulong*)&x[2+pos];
      57      450951 :   *u&=~(3UL<<(2*r));
      58      450951 : }
      59             : 
      60             : void
      61     1121093 : F3v_set(GEN x, long v, ulong n)
      62             : {
      63     1121093 :   long pos = (v-1)>>TWOPOTTRITS_IN_LONG;
      64     1121093 :   long r = (v-1)&(BITS_IN_LONG-1);
      65     1121093 :   ulong *u=(ulong*)&x[2+pos];
      66     1121093 :   *u&=~(3UL<<(2*r));
      67     1121093 :   *u|=(n<<(2*r));
      68     1121093 : }
      69             : 
      70             : INLINE void
      71     1197740 : F3v_setneg(GEN x, long v)
      72             : {
      73     1197740 :   long pos = (v-1)>>TWOPOTTRITS_IN_LONG;
      74     1197740 :   long r = (v-1)&(BITS_IN_LONG-1);
      75     1197740 :   ulong *u=(ulong*)&x[2+pos];
      76     1197740 :   if ((*u>>(2*r))&3UL)
      77      436981 :     *u^=(3UL<<(2*r));
      78     1197740 : }
      79             : 
      80             : INLINE void
      81     1197740 : F3m_setneg(GEN x, long a, long b) { F3v_setneg(gel(x,b), a); }
      82             : 
      83             : static ulong
      84     2846740 : bitswap(ulong a)
      85             : {
      86     2846740 :   const ulong m  = TRITS_MASK;
      87     2846740 :   return ((a&m)<<1)|((a>>1)&m);
      88             : }
      89             : 
      90             : static ulong
      91      539756 : F3_add(ulong a, ulong b)
      92             : {
      93      539756 :   ulong c = a^b^bitswap(a&b);
      94      539756 :   return c&~bitswap(c);
      95             : }
      96             : 
      97             : static ulong
      98      589076 : F3_sub(ulong a, ulong b)
      99             : {
     100      589076 :   ulong bi = bitswap(b);
     101      589076 :   ulong c = a^bi^bitswap(a&bi);
     102      589076 :   return c&~bitswap(c);
     103             : }
     104             : 
     105             : /* Allow lg(y)<lg(x) */
     106             : static void
     107      352946 : F3v_add_inplace(GEN x, GEN y)
     108             : {
     109      352946 :   long n = lg(y);
     110             :   long i;
     111      892702 :   for (i = 2; i < n; i++)
     112      539756 :     x[i] = F3_add(x[i], y[i]);
     113      352946 : }
     114             : 
     115             : /* Allow lg(y)<lg(x) */
     116             : static void
     117      407875 : F3v_sub_inplace(GEN x, GEN y)
     118             : {
     119      407875 :   long n = lg(y);
     120             :   long i;
     121      996951 :   for (i = 2; i < n; i++)
     122      589076 :     x[i] = F3_sub(x[i], y[i]);
     123      407875 : }
     124             : 
     125             : GEN
     126           0 : Flv_to_F3v(GEN x)
     127             : {
     128           0 :   long l = lg(x)-1;
     129           0 :   GEN z = cgetg(nbits2lg(2*l), t_VECSMALL);
     130             :   long i,j,k;
     131           0 :   z[1] = l;
     132           0 :   for(i=1,k=1,j=BITS_IN_LONG; i<=l; i++,j+=2)
     133             :   {
     134           0 :     if (j==BITS_IN_LONG) { j=0; z[++k]=0; }
     135           0 :     z[k] |= (uel(x,i)%3)<<j;
     136             :   }
     137           0 :   return z;
     138             : }
     139             : 
     140             : GEN
     141           0 : Flm_to_F3m(GEN x) { pari_APPLY_same(Flv_to_F3v(gel(x,i))) }
     142             : 
     143             : GEN
     144      775605 : ZV_to_F3v(GEN x)
     145             : {
     146      775605 :   long l = lg(x)-1;
     147      775605 :   GEN z = cgetg(nbits2lg(2*l), t_VECSMALL);
     148             :   long i,j,k;
     149      775606 :   z[1] = l;
     150     8088020 :   for(i=1,k=1,j=BITS_IN_LONG; i<=l; i++,j+=2)
     151             :   {
     152     7312415 :     if (j==BITS_IN_LONG) { j=0; z[++k]=0; }
     153     7312415 :     z[k] |= umodiu(gel(x,i),3)<<j;
     154             :   }
     155      775605 :   return z;
     156             : }
     157             : 
     158             : GEN
     159      936958 : ZM_to_F3m(GEN x) { pari_APPLY_same(ZV_to_F3v(gel(x,i))) }
     160             : 
     161             : GEN
     162         546 : RgV_to_F3v(GEN x)
     163             : {
     164         546 :   long l = lg(x)-1;
     165         546 :   GEN z = cgetg(nbits2lg(2*l), t_VECSMALL);
     166             :   long i,j,k;
     167         546 :   z[1] = l;
     168       34958 :   for(i=1,k=1,j=BITS_IN_LONG; i<=l; i++,j+=2)
     169             :   {
     170       34412 :     if (j==BITS_IN_LONG) { j=0; z[++k]=0; }
     171       34412 :     z[k] |= Rg_to_Fl(gel(x,i),3)<<j;
     172             :   }
     173         546 :   return z;
     174             : }
     175             : 
     176             : GEN
     177         581 : RgM_to_F3m(GEN x) { pari_APPLY_same(RgV_to_F3v(gel(x,i))) }
     178             : 
     179             : GEN
     180           0 : F3v_to_Flv(GEN x)
     181             : {
     182           0 :   long l = x[1]+1, i, j, k;
     183           0 :   GEN z = cgetg(l, t_VECSMALL);
     184           0 :   for (i=2,k=1; i<lg(x); i++)
     185           0 :     for (j=0; j<BITS_IN_LONG && k<l; j+=2,k++)
     186           0 :       z[k] = (uel(x,i)>>j)&3UL;
     187           0 :   return z;
     188             : }
     189             : GEN
     190      234171 : F3c_to_ZC(GEN x)
     191             : {
     192      234171 :   long l = x[1]+1, i, j, k;
     193      234171 :   GEN z = cgetg(l, t_COL);
     194      469618 :   for (i=2,k=1; i<lg(x); i++)
     195     1485160 :     for (j=0; j<BITS_IN_LONG && k<l; j+=2,k++)
     196     1249713 :       switch((uel(x,i)>>j)&3UL)
     197             :       {
     198      782351 :       case 0: gel(z,k) = gen_0; break;
     199      336654 :       case 1: gel(z,k) = gen_1; break;
     200      130708 :       default:gel(z,k) = gen_2; break;
     201             :       }
     202      234171 :   return z;
     203             : }
     204             : GEN
     205         504 : F3c_to_mod(GEN x)
     206             : {
     207         504 :   long l = x[1]+1, i, j, k;
     208         504 :   GEN z = cgetg(l, t_COL), N = utoipos(3);
     209         504 :   GEN _0 = mkintmod(gen_0, N);
     210         504 :   GEN _1 = mkintmod(gen_1, N);
     211         504 :   GEN _2 = mkintmod(gen_2, N);
     212        2096 :   for (i=2,k=1; i<lg(x); i++)
     213       34968 :     for (j=0; j<BITS_IN_LONG && k<l; j+=2,k++)
     214       33376 :       switch((uel(x,i)>>j)&3UL)
     215             :       {
     216       32228 :       case 0: gel(z,k) = _0; break;
     217         819 :       case 1: gel(z,k) = _1; break;
     218         329 :       default: gel(z,k)= _2; break;
     219             :       }
     220         504 :   return z;
     221             : }
     222             : 
     223             : GEN
     224      240885 : F3m_to_ZM(GEN x) { pari_APPLY_same(F3c_to_ZC(gel(x,i))) }
     225             : GEN
     226         525 : F3m_to_mod(GEN x) { pari_APPLY_same(F3c_to_mod(gel(x,i))) }
     227             : GEN
     228           0 : F3m_to_Flm(GEN x) { pari_APPLY_same(F3v_to_Flv(gel(x,i))) }
     229             : 
     230             : /* in place, destroy x */
     231             : GEN
     232      161361 : F3m_ker_sp(GEN x, long deplin)
     233             : {
     234             :   GEN y, c, d;
     235             :   long i, j, k, r, m, n;
     236             : 
     237      161361 :   n = lg(x)-1;
     238      161361 :   m = mael(x,1,1); r=0;
     239             : 
     240      161361 :   d = cgetg(n+1, t_VECSMALL);
     241      161361 :   c = const_F2v(m);
     242      769638 :   for (k=1; k<=n; k++)
     243             :   {
     244      685597 :     GEN xk = gel(x,k);
     245     3425851 :     for (j=1; j<=m; j++)
     246     3191205 :       if (F2v_coeff(c,j) && F3m_coeff(x,j,k)) break;
     247      685596 :     if (j>m)
     248             :     {
     249      234646 :       if (deplin) {
     250       77320 :         GEN v = zero_F3v(n);
     251      365974 :         for (i=1; i<k; i++) F3v_set(v, i, F3v_coeff(xk, d[i]));
     252       77320 :         F3v_set(v, k, 1); return v;
     253             :       }
     254      157326 :       r++; d[k] = 0;
     255             :     }
     256             :     else
     257             :     {
     258      450950 :       ulong xkj = F3v_coeff(xk,j);
     259      450950 :       F3v_clear(xk, j);
     260      450951 :       F2v_clear(c,j); d[k] = j;
     261     2253808 :       for (i=k+1; i<=n; i++)
     262             :       {
     263     1802857 :         GEN xi = gel(x,i);
     264     1802857 :         ulong u = F3v_coeff(xi,j);
     265     1802857 :         if (u)
     266             :         {
     267      760772 :           if (u==xkj) F3v_sub_inplace(xi, xk);
     268      352932 :           else        F3v_add_inplace(xi, xk);
     269             :         }
     270             :       }
     271      450951 :       F3v_set(xk, j, 2);
     272      450951 :       if (xkj==1)
     273     1507327 :         for (i=k+1; i<=n; i++) F3m_setneg(x,j,i);
     274             :     }
     275             :   }
     276       84041 :   if (deplin) return NULL;
     277       84041 :   y = zero_F3m_copy(n,r);
     278      241368 :   for (j=k=1; j<=r; j++,k++)
     279             :   {
     280      157327 :     GEN C = gel(y,j);
     281      230718 :     while (d[k]) k++;
     282      529314 :     for (i=1; i<k; i++)
     283      371987 :       if (d[i]) F3v_set(C,i,F3m_coeff(x,d[i],k));
     284      157327 :     F3v_set(C, k, 1);
     285             :   }
     286       84041 :   return y;
     287             : }
     288             : 
     289             : GEN
     290           0 : F3m_ker(GEN x) { return F3m_ker_sp(F3m_copy(x), 0); }
     291             : 
     292             : INLINE GEN
     293          28 : F3m_F3c_mul_i(GEN x, GEN y, long lx, long l)
     294             : {
     295             :   long j;
     296          28 :   GEN z = zero_F3v(l);
     297             : 
     298          84 :   for (j=1; j<lx; j++)
     299             :   {
     300          56 :     ulong c = F3v_coeff(y,j);
     301          56 :     if (!c) continue;
     302          49 :     if (c==1)
     303          14 :       F3v_add_inplace(z,gel(x,j));
     304             :     else
     305          35 :       F3v_sub_inplace(z,gel(x,j));
     306             :   }
     307          28 :   return z;
     308             : }
     309             : 
     310             : GEN
     311          14 : F3m_mul(GEN x, GEN y)
     312             : {
     313          14 :   long i,j,l,lx=lg(x), ly=lg(y);
     314             :   GEN z;
     315          14 :   if (ly==1) return cgetg(1,t_MAT);
     316          14 :   z = cgetg(ly,t_MAT);
     317          14 :   if (lx==1)
     318             :   {
     319           0 :     for (i=1; i<ly; i++) gel(z,i) = mkvecsmall(0);
     320           0 :     return z;
     321             :   }
     322          14 :   l = coeff(x,1,1);
     323          42 :   for (j=1; j<ly; j++) gel(z,j) = F3m_F3c_mul_i(x, gel(y,j), lx, l);
     324          14 :   return z;
     325             : }
     326             : 
     327             : GEN
     328           0 : F3m_row(GEN x, long j)
     329             : {
     330           0 :   long i, l = lg(x);
     331           0 :   GEN V = zero_F3v(l-1);
     332           0 :   for(i = 1; i < l; i++) F3v_set(V, i, F3m_coeff(x,j,i));
     333           0 :   return V;
     334             : }
     335             : 
     336             : GEN
     337           0 : F3m_transpose(GEN x)
     338             : {
     339             :   long i, l;
     340             :   GEN y;
     341           0 :   if (lg(x) == 1) return cgetg(1,t_MAT);
     342           0 :   l = coeff(x,1,1) + 1; y = cgetg(l, t_MAT);
     343           0 :   for (i = 1; i < l; i++) gel(y,i) = F3m_row(x,i);
     344           0 :   return y;
     345             : }

Generated by: LCOV version 1.13