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 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 - RgV.c (source / functions) Hit Total Coverage
Test: PARI/GP v2.8.0 lcov report (development 19047-48ce0fc) Lines: 438 508 86.2 %
Date: 2016-06-28 Functions: 73 83 88.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 266 373 71.3 %

           Branch data     Line data    Source code
       1                 :            : /* Copyright (C) 2000  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. It is distributed in the hope that it will be useful, but WITHOUT
       8                 :            : ANY WARRANTY WHATSOEVER.
       9                 :            : 
      10                 :            : Check the License for details. You should have received a copy of it, along
      11                 :            : with the package; see the file 'COPYING'. If not, write to the Free Software
      12                 :            : Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
      13                 :            : 
      14                 :            : #include "pari.h"
      15                 :            : #include "paripriv.h"
      16                 :            : 
      17                 :            : int
      18                 :    3652008 : RgM_is_ZM(GEN x)
      19                 :            : {
      20                 :    3652008 :   long i, j, h, l = lg(x);
      21         [ +  + ]:    3652008 :   if (l == 1) return 1;
      22                 :    3651735 :   h = lgcols(x);
      23         [ +  + ]:    3651735 :   if (h == 1) return 1;
      24         [ +  + ]:   11574849 :   for (j = l-1; j > 0; j--)
      25         [ +  + ]:   49791292 :     for (i = h-1; i > 0; i--)
      26         [ +  + ]:   41867926 :       if (typ(gcoeff(x,i,j)) != t_INT) return 0;
      27                 :    3652008 :   return 1;
      28                 :            : }
      29                 :            : 
      30                 :            : int
      31                 :         21 : RgV_is_ZMV(GEN V)
      32                 :            : {
      33                 :         21 :   long i, l = lg(V);
      34         [ +  + ]:        231 :   for (i=1; i<l; i++)
      35 [ +  - ][ -  + ]:        210 :     if (typ(gel(V,i))!=t_MAT || !RgM_is_ZM(gel(V,i)))
      36                 :          0 :       return 0;
      37                 :         21 :   return 1;
      38                 :            : }
      39                 :            : 
      40                 :            : /********************************************************************/
      41                 :            : /**                                                                **/
      42                 :            : /**                   GENERIC LINEAR ALGEBRA                       **/
      43                 :            : /**                                                                **/
      44                 :            : /********************************************************************/
      45                 :            : /*           GENERIC  MULTIPLICATION involving zc/zm                */
      46                 :            : /* x non-empty t_MAT, y a compatible zc (dimension > 0). */
      47                 :            : static GEN
      48                 :     104724 : RgM_zc_mul_i(GEN x, GEN y, long c, long l)
      49                 :            : {
      50                 :            :   long i, j;
      51                 :            :   pari_sp av;
      52                 :     104724 :   GEN z = cgetg(l,t_COL);
      53                 :            : 
      54         [ +  + ]:     587085 :   for (i=1; i<l; i++)
      55                 :            :   {
      56                 :     482361 :     GEN s = NULL;
      57                 :     482361 :     av = avma;
      58         [ +  + ]:   20558059 :     for (j=1; j<c; j++)
      59                 :            :     {
      60                 :   20075698 :       long t = y[j];
      61         [ +  + ]:   20075698 :       if (!t) continue;
      62         [ +  + ]:    2376564 :       if (!s) { s = gmulgs(gcoeff(x,i,j),t); continue; }
      63      [ +  +  + ]:    1896569 :       switch(t)
      64                 :            :       {
      65                 :     983199 :         case  1: s = gadd(s, gcoeff(x,i,j)); break;
      66                 :     424333 :         case -1: s = gsub(s, gcoeff(x,i,j)); break;
      67                 :     489037 :         default: s = gadd(s, gmulgs(gcoeff(x,i,j), t)); break;
      68                 :            :       }
      69                 :            :     }
      70         [ +  + ]:     482361 :     gel(z,i) = gerepileupto(av,s? s: gen_0);
      71                 :            :   }
      72                 :     104724 :   return z;
      73                 :            : }
      74                 :            : GEN
      75                 :      76300 : RgM_zc_mul(GEN x, GEN y) { return RgM_zc_mul_i(x,y, lg(x), lgcols(x)); }
      76                 :            : /* x t_MAT, y a compatible zm (dimension > 0). */
      77                 :            : GEN
      78                 :       7069 : RgM_zm_mul(GEN x, GEN y)
      79                 :            : {
      80                 :       7069 :   long j, c, l = lg(x), ly = lg(y);
      81                 :       7069 :   GEN z = cgetg(ly, t_MAT);
      82         [ -  + ]:       7069 :   if (l == 1) return z;
      83                 :       7069 :   c = lgcols(x);
      84         [ +  + ]:      35493 :   for (j = 1; j < ly; j++) gel(z,j) = RgM_zc_mul_i(x, gel(y,j), l,c);
      85                 :       7069 :   return z;
      86                 :            : }
      87                 :            : 
      88                 :            : static GEN
      89                 :      35786 : RgV_zc_mul_i(GEN x, GEN y, long l)
      90                 :            : {
      91                 :            :   long i;
      92                 :      35786 :   GEN z = gen_0;
      93                 :      35786 :   pari_sp av = avma;
      94         [ +  + ]:    1683871 :   for (i = 1; i < l; i++) z = gadd(z, gmulgs(gel(x,i), y[i]));
      95                 :      35786 :   return gerepileupto(av, z);
      96                 :            : }
      97                 :            : GEN
      98                 :          0 : RgV_zc_mul(GEN x, GEN y) { return RgV_zc_mul_i(x, y, lg(x)); }
      99                 :            : 
     100                 :            : GEN
     101                 :       8956 : RgV_zm_mul(GEN x, GEN y)
     102                 :            : {
     103                 :       8956 :   long j, l = lg(x), ly = lg(y);
     104                 :       8956 :   GEN z = cgetg(ly, t_VEC);
     105         [ +  + ]:      44742 :   for (j = 1; j < ly; j++) gel(z,j) = RgV_zc_mul_i(x, gel(y,j), l);
     106                 :       8956 :   return z;
     107                 :            : }
     108                 :            : 
     109                 :            : /* scalar product x.x */
     110                 :            : GEN
     111                 :        868 : RgV_dotsquare(GEN x)
     112                 :            : {
     113                 :        868 :   long i, lx = lg(x);
     114                 :        868 :   pari_sp av = avma;
     115                 :            :   GEN z;
     116         [ -  + ]:        868 :   if (lx == 1) return gen_0;
     117                 :        868 :   z = gsqr(gel(x,1));
     118         [ +  + ]:       3472 :   for (i=2; i<lx; i++)
     119                 :            :   {
     120                 :       2604 :     z = gadd(z, gsqr(gel(x,i)));
     121         [ -  + ]:       2604 :     if (gc_needed(av,3))
     122                 :            :     {
     123         [ #  # ]:          0 :       if(DEBUGMEM>1) pari_warn(warnmem,"RgV_dotsquare, i = %ld",i);
     124                 :          0 :       z = gerepileupto(av, z);
     125                 :            :     }
     126                 :            :   }
     127                 :        868 :   return gerepileupto(av,z);
     128                 :            : }
     129                 :            : 
     130                 :            : /* scalar product x.y, lx = lg(x) = lg(y) */
     131                 :            : static GEN
     132                 :    1587761 : RgV_dotproduct_i(GEN x, GEN y, long lx)
     133                 :            : {
     134                 :    1587761 :   pari_sp av = avma;
     135                 :            :   long i;
     136                 :            :   GEN z;
     137         [ +  + ]:    1587761 :   if (lx == 1) return gen_0;
     138                 :    1587222 :   z = gmul(gel(x,1),gel(y,1));
     139         [ +  + ]:   44242908 :   for (i=2; i<lx; i++)
     140                 :            :   {
     141                 :   42655686 :     z = gadd(z, gmul(gel(x,i), gel(y,i)));
     142         [ -  + ]:   42655686 :     if (gc_needed(av,3))
     143                 :            :     {
     144         [ #  # ]:          0 :       if(DEBUGMEM>1) pari_warn(warnmem,"RgV_dotproduct, i = %ld",i);
     145                 :          0 :       z = gerepileupto(av, z);
     146                 :            :     }
     147                 :            :   }
     148                 :    1587761 :   return gerepileupto(av,z);
     149                 :            : }
     150                 :            : GEN
     151                 :      93205 : RgV_dotproduct(GEN x,GEN y)
     152                 :            : {
     153         [ -  + ]:      93205 :   if (x == y) return RgV_dotsquare(x);
     154                 :      93205 :   return RgV_dotproduct_i(x, y, lg(x));
     155                 :            : }
     156                 :            : /* v[1] + ... + v[lg(v)-1] */
     157                 :            : GEN
     158                 :     247960 : RgV_sum(GEN v)
     159                 :            : {
     160                 :            :   GEN p;
     161                 :     247960 :   long i, l = lg(v);
     162         [ -  + ]:     247960 :   if (l == 1) return gen_0;
     163         [ +  + ]:     659743 :   p = gel(v,1); for (i=2; i<l; i++) p = gadd(p, gel(v,i));
     164                 :     247960 :   return p;
     165                 :            : }
     166                 :            : /* v[1] + ... + v[n]. Assume lg(v) > n. */
     167                 :            : GEN
     168                 :        518 : RgV_sumpart(GEN v, long n)
     169                 :            : {
     170                 :            :   GEN p;
     171                 :            :   long i;
     172         [ -  + ]:        518 :   if (!n) return gen_0;
     173         [ +  + ]:       1372 :   p = gel(v,1); for (i=2; i<=n; i++) p = gadd(p, gel(v,i));
     174                 :        518 :   return p;
     175                 :            : }
     176                 :            : /* v[m] + ... + v[n]. Assume lg(v) > n, m > 0. */
     177                 :            : GEN
     178                 :          0 : RgV_sumpart2(GEN v, long m, long n)
     179                 :            : {
     180                 :            :   GEN p;
     181                 :            :   long i;
     182         [ #  # ]:          0 :   if (n < m) return gen_0;
     183         [ #  # ]:          0 :   p = gel(v,m); for (i=m+1; i<=n; i++) p = gadd(p, gel(v,i));
     184                 :          0 :   return p;
     185                 :            : }
     186                 :            : GEN
     187                 :        362 : RgM_sumcol(GEN A)
     188                 :            : {
     189                 :        362 :   long i,j,m,l = lg(A);
     190                 :            :   GEN v;
     191                 :            : 
     192         [ -  + ]:        362 :   if (l == 1) return cgetg(1,t_MAT);
     193         [ +  + ]:        362 :   if (l == 2) return gcopy(gel(A,1));
     194                 :        208 :   m = lgcols(A);
     195                 :        208 :   v = cgetg(m, t_COL);
     196         [ +  + ]:        680 :   for (i = 1; i < m; i++)
     197                 :            :   {
     198                 :        472 :     pari_sp av = avma;
     199                 :        472 :     GEN s = gcoeff(A,i,1);
     200         [ +  + ]:       1112 :     for (j = 2; j < l; j++) s = gadd(s, gcoeff(A,i,j));
     201                 :        472 :     gel(v, i) = gerepileupto(av, s);
     202                 :            :   }
     203                 :        362 :   return v;
     204                 :            : }
     205                 :            : 
     206                 :            : static GEN
     207                 :     702443 : _gmul(void *data, GEN x, GEN y)
     208                 :     702443 : { (void)data; return gmul(x,y); }
     209                 :            : 
     210                 :            : GEN
     211                 :      33397 : RgV_prod(GEN x)
     212                 :            : {
     213                 :      33397 :   return gen_product(x, NULL, _gmul);
     214                 :            : }
     215                 :            : 
     216                 :            : /*                    ADDITION SCALAR + MATRIX                     */
     217                 :            : /* x square matrix, y scalar; create the square matrix x + y*Id */
     218                 :            : GEN
     219                 :      17584 : RgM_Rg_add(GEN x, GEN y)
     220                 :            : {
     221                 :      17584 :   long l = lg(x), i, j;
     222                 :      17584 :   GEN z = cgetg(l,t_MAT);
     223                 :            : 
     224         [ -  + ]:      17584 :   if (l==1) return z;
     225         [ -  + ]:      17584 :   if (l != lgcols(x)) pari_err_OP( "+", x, y);
     226                 :      17584 :   z = cgetg(l,t_MAT);
     227         [ +  + ]:      81454 :   for (i=1; i<l; i++)
     228                 :            :   {
     229                 :      63870 :     GEN zi = cgetg(l,t_COL), xi = gel(x,i);
     230                 :      63870 :     gel(z,i) = zi;
     231         [ +  + ]:    2455278 :     for (j=1; j<l; j++)
     232         [ +  + ]:    2391408 :       gel(zi,j) = i==j? gadd(y,gel(xi,j)): gcopy(gel(xi,j));
     233                 :            :   }
     234                 :      17584 :   return z;
     235                 :            : }
     236                 :            : GEN
     237                 :          0 : RgM_Rg_sub(GEN x, GEN y)
     238                 :            : {
     239                 :          0 :   long l = lg(x), i, j;
     240                 :          0 :   GEN z = cgetg(l,t_MAT);
     241                 :            : 
     242         [ #  # ]:          0 :   if (l==1) return z;
     243         [ #  # ]:          0 :   if (l != lgcols(x)) pari_err_OP( "-", x, y);
     244                 :          0 :   z = cgetg(l,t_MAT);
     245         [ #  # ]:          0 :   for (i=1; i<l; i++)
     246                 :            :   {
     247                 :          0 :     GEN zi = cgetg(l,t_COL), xi = gel(x,i);
     248                 :          0 :     gel(z,i) = zi;
     249         [ #  # ]:          0 :     for (j=1; j<l; j++)
     250         [ #  # ]:          0 :       gel(zi,j) = i==j? gsub(y,gel(xi,j)): gcopy(gel(xi,j));
     251                 :            :   }
     252                 :          0 :   return z;
     253                 :            : }
     254                 :            : GEN
     255                 :       1659 : RgM_Rg_add_shallow(GEN x, GEN y)
     256                 :            : {
     257                 :       1659 :   long l = lg(x), i, j;
     258                 :       1659 :   GEN z = cgetg(l,t_MAT);
     259                 :            : 
     260         [ +  + ]:       1659 :   if (l==1) return z;
     261         [ -  + ]:       1554 :   if (l != lgcols(x)) pari_err_OP( "+", x, y);
     262         [ +  + ]:      11585 :   for (i=1; i<l; i++)
     263                 :            :   {
     264                 :      10031 :     GEN zi = cgetg(l,t_COL), xi = gel(x,i);
     265                 :      10031 :     gel(z,i) = zi;
     266         [ +  + ]:     844410 :     for (j=1; j<l; j++) gel(zi,j) = gel(xi,j);
     267                 :      10031 :     gel(zi,i) = gadd(gel(zi,i), y);
     268                 :            :   }
     269                 :       1659 :   return z;
     270                 :            : }
     271                 :            : GEN
     272                 :      31143 : RgM_Rg_sub_shallow(GEN x, GEN y)
     273                 :            : {
     274                 :      31143 :   long l = lg(x), i, j;
     275                 :      31143 :   GEN z = cgetg(l,t_MAT);
     276                 :            : 
     277         [ -  + ]:      31143 :   if (l==1) return z;
     278         [ -  + ]:      31143 :   if (l != lgcols(x)) pari_err_OP( "-", x, y);
     279         [ +  + ]:     361060 :   for (i=1; i<l; i++)
     280                 :            :   {
     281                 :     329917 :     GEN zi = cgetg(l,t_COL), xi = gel(x,i);
     282                 :     329917 :     gel(z,i) = zi;
     283         [ +  + ]:    5511730 :     for (j=1; j<l; j++) gel(zi,j) = gel(xi,j);
     284                 :     329917 :     gel(zi,i) = gsub(gel(zi,i), y);
     285                 :            :   }
     286                 :      31143 :   return z;
     287                 :            : }
     288                 :            : 
     289                 :            : GEN
     290                 :      51606 : RgC_Rg_add(GEN x, GEN y)
     291                 :            : {
     292                 :      51606 :   long k, lx = lg(x);
     293                 :      51606 :   GEN z = cgetg(lx, t_COL);
     294         [ +  + ]:      51606 :   if (lx == 1)
     295                 :            :   {
     296         [ +  - ]:          7 :     if (isintzero(y)) return z;
     297                 :          0 :     pari_err_TYPE2("+",x,y);
     298                 :            :   }
     299                 :      51599 :   gel(z,1) = gadd(y,gel(x,1));
     300         [ +  + ]:     209458 :   for (k = 2; k < lx; k++) gel(z,k) = gcopy(gel(x,k));
     301                 :      51606 :   return z;
     302                 :            : }
     303                 :            : 
     304                 :            : static GEN
     305                 :   15389046 : RgC_add_i(GEN x, GEN y, long lx)
     306                 :            : {
     307                 :   15389046 :   GEN A = cgetg(lx, t_COL);
     308                 :            :   long i;
     309         [ +  + ]:  205985749 :   for (i=1; i<lx; i++) gel(A,i) = gadd(gel(x,i), gel(y,i));
     310                 :   15389046 :   return A;
     311                 :            : }
     312                 :            : GEN
     313                 :   13017495 : RgC_add(GEN x, GEN y) { return RgC_add_i(x, y, lg(x)); }
     314                 :            : GEN
     315                 :     482828 : RgV_add(GEN x, GEN y)
     316                 :            : {
     317                 :     482828 :   long i, lx = lg(x);
     318                 :     482828 :   GEN A = cgetg(lx, t_VEC);
     319         [ +  + ]:    2162983 :   for (i=1; i<lx; i++) gel(A,i) = gadd(gel(x,i), gel(y,i));
     320                 :     482828 :   return A;
     321                 :            : }
     322                 :            : 
     323                 :            : static GEN
     324                 :    1277494 : RgC_sub_i(GEN x, GEN y, long lx)
     325                 :            : {
     326                 :            :   long i;
     327                 :    1277494 :   GEN A = cgetg(lx, t_COL);
     328         [ +  + ]:    5755821 :   for (i=1; i<lx; i++) gel(A,i) = gsub(gel(x,i), gel(y,i));
     329                 :    1277494 :   return A;
     330                 :            : }
     331                 :            : GEN
     332                 :    1248286 : RgC_sub(GEN x, GEN y) { return RgC_sub_i(x, y, lg(x)); }
     333                 :            : GEN
     334                 :      73671 : RgV_sub(GEN x, GEN y)
     335                 :            : {
     336                 :      73671 :   long i, lx = lg(x);
     337                 :      73671 :   GEN A = cgetg(lx, t_VEC);
     338         [ +  + ]:     399173 :   for (i=1; i<lx; i++) gel(A,i) = gsub(gel(x,i), gel(y,i));
     339                 :      73671 :   return A;
     340                 :            : }
     341                 :            : 
     342                 :            : GEN
     343                 :     497560 : RgM_add(GEN x, GEN y)
     344                 :            : {
     345                 :     497560 :   long lx = lg(x), l, j;
     346                 :            :   GEN z;
     347         [ -  + ]:     497560 :   if (lx == 1) return cgetg(1, t_MAT);
     348                 :     497560 :   z = cgetg(lx, t_MAT); l = lgcols(x);
     349         [ +  + ]:    2869111 :   for (j = 1; j < lx; j++) gel(z,j) = RgC_add_i(gel(x,j), gel(y,j), l);
     350                 :     497560 :   return z;
     351                 :            : }
     352                 :            : GEN
     353                 :       7167 : RgM_sub(GEN x, GEN y)
     354                 :            : {
     355                 :       7167 :   long lx = lg(x), l, j;
     356                 :            :   GEN z;
     357         [ -  + ]:       7167 :   if (lx == 1) return cgetg(1, t_MAT);
     358                 :       7167 :   z = cgetg(lx, t_MAT); l = lgcols(x);
     359         [ +  + ]:      36375 :   for (j = 1; j < lx; j++) gel(z,j) = RgC_sub_i(gel(x,j), gel(y,j), l);
     360                 :       7167 :   return z;
     361                 :            : }
     362                 :            : 
     363                 :            : static GEN
     364                 :    2666542 : RgC_neg_i(GEN x, long lx)
     365                 :            : {
     366                 :            :   long i;
     367                 :    2666542 :   GEN y = cgetg(lx, t_COL);
     368         [ +  + ]:   22455001 :   for (i=1; i<lx; i++) gel(y,i) = gneg(gel(x,i));
     369                 :    2666542 :   return y;
     370                 :            : }
     371                 :            : GEN
     372                 :      57509 : RgC_neg(GEN x) { return RgC_neg_i(x, lg(x)); }
     373                 :            : GEN
     374                 :       7617 : RgV_neg(GEN x)
     375                 :            : {
     376                 :       7617 :   long i, lx = lg(x);
     377                 :       7617 :   GEN y = cgetg(lx, t_VEC);
     378         [ +  + ]:      67674 :   for (i=1; i<lx; i++) gel(y,i) = gneg(gel(x,i));
     379                 :       7617 :   return y;
     380                 :            : }
     381                 :            : GEN
     382                 :     469490 : RgM_neg(GEN x)
     383                 :            : {
     384                 :     469490 :   long i, hx, lx = lg(x);
     385                 :     469490 :   GEN y = cgetg(lx, t_MAT);
     386         [ +  + ]:     469490 :   if (lx == 1) return y;
     387                 :     469483 :   hx = lgcols(x);
     388         [ +  + ]:    3078516 :   for (i=1; i<lx; i++) gel(y,i) = RgC_neg_i(gel(x,i), hx);
     389                 :     469490 :   return y;
     390                 :            : }
     391                 :            : 
     392                 :            : GEN
     393                 :     320952 : RgV_RgC_mul(GEN x, GEN y)
     394                 :            : {
     395                 :     320952 :   long lx = lg(x);
     396         [ +  + ]:     320952 :   if (lx != lg(y)) pari_err_OP("operation 'RgV_RgC_mul'", x, y);
     397                 :     320882 :   return RgV_dotproduct_i(x, y, lx);
     398                 :            : }
     399                 :            : GEN
     400                 :          7 : RgC_RgV_mul(GEN x, GEN y)
     401                 :            : {
     402                 :          7 :   long i, ly = lg(y);
     403                 :          7 :   GEN z = cgetg(ly,t_MAT);
     404         [ +  + ]:         21 :   for (i=1; i<ly; i++) gel(z,i) = RgC_Rg_mul(x, gel(y,i));
     405                 :          7 :   return z;
     406                 :            : }
     407                 :            : GEN
     408                 :          0 : RgC_RgM_mul(GEN x, GEN y)
     409                 :            : {
     410                 :          0 :   long i, ly = lg(y);
     411                 :          0 :   GEN z = cgetg(ly,t_MAT);
     412 [ #  # ][ #  # ]:          0 :   if (ly != 1 && lgcols(y) != 2) pari_err_OP("operation 'RgC_RgM_mul'",x,y);
     413         [ #  # ]:          0 :   for (i=1; i<ly; i++) gel(z,i) = RgC_Rg_mul(x, gcoeff(y,1,i));
     414                 :          0 :   return z;
     415                 :            : }
     416                 :            : GEN
     417                 :          0 : RgM_RgV_mul(GEN x, GEN y)
     418                 :            : {
     419         [ #  # ]:          0 :   if (lg(x) != 2) pari_err_OP("operation 'RgM_RgV_mul'", x,y);
     420                 :          0 :   return RgC_RgV_mul(gel(x,1), y);
     421                 :            : }
     422                 :            : 
     423                 :            : /* x[i,]*y, l = lg(y) > 1 */
     424                 :            : static GEN
     425                 :   68359434 : RgMrow_RgC_mul_i(GEN x, GEN y, long i, long l)
     426                 :            : {
     427                 :   68359434 :   pari_sp av = avma;
     428                 :   68359434 :   GEN t = gmul(gcoeff(x,i,1), gel(y,1)); /* l > 1 ! */
     429                 :            :   long j;
     430         [ +  + ]:  767938402 :   for (j=2; j<l; j++) t = gadd(t, gmul(gcoeff(x,i,j), gel(y,j)));
     431                 :   68359434 :   return gerepileupto(av,t);
     432                 :            : }
     433                 :            : GEN
     434                 :        455 : RgMrow_RgC_mul(GEN x, GEN y, long i)
     435                 :        455 : { return RgMrow_RgC_mul_i(x, y, i, lg(x)); }
     436                 :            : 
     437                 :            : /* compatible t_MAT * t_COL, lx = lg(x) = lg(y) > 1, l = lgcols(x) */
     438                 :            : static GEN
     439                 :   10113784 : RgM_RgC_mul_i(GEN x, GEN y, long lx, long l)
     440                 :            : {
     441                 :   10113784 :   GEN z = cgetg(l,t_COL);
     442                 :            :   long i;
     443         [ +  + ]:   78472763 :   for (i=1; i<l; i++) gel(z,i) = RgMrow_RgC_mul_i(x,y,i,lx);
     444                 :   10113784 :   return z;
     445                 :            : }
     446                 :            : 
     447                 :            : GEN
     448                 :    8713360 : RgM_RgC_mul(GEN x, GEN y)
     449                 :            : {
     450                 :    8713360 :   long lx = lg(x);
     451                 :    8713360 :   GEN ffx = NULL, ffy = NULL;
     452         [ -  + ]:    8713360 :   if (lx != lg(y)) pari_err_OP("operation 'RgM_RgC_mul'", x,y);
     453         [ -  + ]:    8713360 :   if (lx == 1) return cgetg(1,t_COL);
     454 [ +  + ][ +  - ]:    8713360 :   if (RgM_is_FFM(x, &ffx) && RgC_is_FFC(y, &ffy)) {
     455         [ -  + ]:         21 :     if (!FF_samefield(ffx, ffy))
     456                 :          0 :       pari_err_OP("*", ffx, ffy);
     457                 :         21 :     return FFM_FFC_mul(x, y, ffx);
     458                 :            :   }
     459                 :    8713360 :   return RgM_RgC_mul_i(x, y, lx, lgcols(x));
     460                 :            : }
     461                 :            : 
     462                 :            : GEN
     463                 :      99914 : RgV_RgM_mul(GEN x, GEN y)
     464                 :            : {
     465                 :      99914 :   long i, lx, ly = lg(y);
     466                 :            :   GEN z;
     467         [ +  + ]:      99914 :   if (ly == 1) return cgetg(1,t_VEC);
     468                 :      99907 :   lx = lg(x);
     469         [ +  + ]:      99907 :   if (lx != lgcols(y)) pari_err_OP("operation 'RgV_RgM_mul'", x,y);
     470                 :      99900 :   z = cgetg(ly, t_VEC);
     471         [ +  + ]:    1269689 :   for (i=1; i<ly; i++) gel(z,i) = RgV_dotproduct_i(x, gel(y,i), lx);
     472                 :      99907 :   return z;
     473                 :            : }
     474                 :            : 
     475                 :            : static int
     476                 :     390763 : is_modular_mul(GEN a, GEN b, GEN *z)
     477                 :            : {
     478                 :     390763 :   GEN p1 = NULL, p2 = NULL, p;
     479                 :            :   ulong pp;
     480 [ +  + ][ +  + ]:     390763 :   if (!RgM_is_FpM(a, &p1) || !p1) return 0;
     481 [ +  - ][ -  + ]:         77 :   if (!RgM_is_FpM(b, &p2) || !p2) return 0;
     482                 :         77 :   p = gcdii(p1, p2);
     483                 :         77 :   a = RgM_Fp_init(a, p, &pp);
     484      [ +  +  + ]:         77 :   switch(pp)
     485                 :            :   {
     486                 :            :   case 0:
     487                 :         15 :     b = RgM_to_FpM(b,p);
     488                 :         15 :     b = FpM_mul(a,b,p);
     489                 :         15 :     *z = FpM_to_mod(b,p);
     490                 :         15 :     break;
     491                 :            :   case 2:
     492                 :         28 :     b = RgM_to_F2m(b);
     493                 :         28 :     b = F2m_mul(a,b);
     494                 :         28 :     *z = F2m_to_mod(b);
     495                 :         28 :     break;
     496                 :            :   default:
     497                 :         34 :     b = RgM_to_Flm(b,pp);
     498                 :         34 :     b = Flm_mul(a,b,pp);
     499                 :         34 :     *z = Flm_to_mod(b,pp);
     500                 :            :   }
     501                 :     390763 :   return 1;
     502                 :            : }
     503                 :            : static int
     504                 :        812 : is_modular_sqr(GEN a, GEN *z)
     505                 :            : {
     506                 :        812 :   GEN p = NULL;
     507                 :            :   ulong pp;
     508 [ +  + ][ -  + ]:        812 :   if (!RgM_is_FpM(a, &p) || !p) return 0;
     509                 :         63 :   a = RgM_Fp_init(a, p, &pp);
     510      [ +  +  + ]:         63 :   switch(pp)
     511                 :            :   {
     512                 :         15 :     case 0: *z = FpM_to_mod(FpM_mul(a,a, p), p); break;
     513                 :         14 :     case 2: *z = F2m_to_mod(F2m_mul(a,a)); break;
     514                 :         34 :     default:*z = Flm_to_mod(Flm_mul(a,a, pp), pp); break;
     515                 :            :   }
     516                 :        812 :   return 1;
     517                 :            : }
     518                 :            : 
     519                 :            : GEN
     520                 :    1997965 : RgM_mul(GEN x, GEN y)
     521                 :            : {
     522                 :    1997965 :   pari_sp av = avma;
     523                 :    1997965 :   long j, l, lx, ly = lg(y);
     524                 :    1997965 :   GEN z, ffx = NULL, ffy = NULL;
     525         [ +  + ]:    1997965 :   if (ly == 1) return cgetg(1,t_MAT);
     526                 :    1997377 :   lx = lg(x);
     527         [ -  + ]:    1997377 :   if (lx != lgcols(y)) pari_err_OP("operation 'RgM_mul'", x,y);
     528         [ +  + ]:    1997377 :   if (lx == 1) return zeromat(0,ly-1);
     529 [ +  + ][ +  + ]:    1997356 :   if (RgM_is_ZM(x) && RgM_is_ZM(y))
     530                 :    1606593 :     return ZM_mul(x, y);
     531         [ +  + ]:     390763 :   if (is_modular_mul(x,y,&z)) return gerepileupto(av, z);
     532 [ +  + ][ +  - ]:     390686 :   if (RgM_is_FFM(x, &ffx) && RgM_is_FFM(y, &ffy)) {
     533         [ -  + ]:        133 :     if (!FF_samefield(ffx, ffy))
     534                 :          0 :       pari_err_OP("*", ffx, ffy);
     535                 :        133 :     return FFM_mul(x, y, ffx);
     536                 :            :   }
     537                 :     390553 :   z = cgetg(ly, t_MAT);
     538                 :     390553 :   l = lgcols(x);
     539         [ +  + ]:    1789248 :   for (j=1; j<ly; j++) gel(z,j) = RgM_RgC_mul_i(x, gel(y,j), lx, l);
     540                 :    1997965 :   return z;
     541                 :            : }
     542                 :            : /* assume result is symmetric */
     543                 :            : GEN
     544                 :          0 : RgM_multosym(GEN x, GEN y)
     545                 :            : {
     546                 :          0 :   long j, lx, ly = lg(y);
     547                 :            :   GEN M;
     548         [ #  # ]:          0 :   if (ly == 1) return cgetg(1,t_MAT);
     549                 :          0 :   lx = lg(x);
     550         [ #  # ]:          0 :   if (lx != lgcols(y)) pari_err_OP("operation 'RgM_multosym'", x,y);
     551         [ #  # ]:          0 :   if (lx == 1) return cgetg(1,t_MAT);
     552         [ #  # ]:          0 :   if (ly != lgcols(x)) pari_err_OP("operation 'RgM_multosym'", x,y);
     553                 :          0 :   M = cgetg(ly, t_MAT);
     554         [ #  # ]:          0 :   for (j=1; j<ly; j++)
     555                 :            :   {
     556                 :          0 :     GEN z = cgetg(ly,t_COL), yj = gel(y,j);
     557                 :            :     long i;
     558         [ #  # ]:          0 :     for (i=1; i<j; i++) gel(z,i) = gcoeff(M,j,i);
     559         [ #  # ]:          0 :     for (i=j; i<ly; i++)gel(z,i) = RgMrow_RgC_mul_i(x,yj,i,lx);
     560                 :          0 :     gel(M,j) = z;
     561                 :            :   }
     562                 :          0 :   return M;
     563                 :            : }
     564                 :            : /* x~ * y, assuming result is symmetric */
     565                 :            : GEN
     566                 :        490 : RgM_transmultosym(GEN x, GEN y)
     567                 :            : {
     568                 :        490 :   long i, j, l, ly = lg(y);
     569                 :            :   GEN M;
     570         [ -  + ]:        490 :   if (ly == 1) return cgetg(1,t_MAT);
     571         [ -  + ]:        490 :   if (lg(x) != ly) pari_err_OP("operation 'RgM_transmultosym'", x,y);
     572                 :        490 :   l = lgcols(y);
     573         [ -  + ]:        490 :   if (lgcols(x) != l) pari_err_OP("operation 'RgM_transmultosym'", x,y);
     574                 :        490 :   M = cgetg(ly, t_MAT);
     575         [ +  + ]:       2107 :   for (i=1; i<ly; i++)
     576                 :            :   {
     577                 :       1617 :     GEN xi = gel(x,i), c = cgetg(ly,t_COL);
     578                 :       1617 :     gel(M,i) = c;
     579         [ +  + ]:       3794 :     for (j=1; j<i; j++)
     580                 :       2177 :       gcoeff(M,i,j) = gel(c,j) = RgV_dotproduct_i(xi,gel(y,j),l);
     581                 :       1617 :     gel(c,i) = RgV_dotproduct_i(xi,gel(y,i),l);
     582                 :            :   }
     583                 :        490 :   return M;
     584                 :            : }
     585                 :            : /* x~ * y */
     586                 :            : GEN
     587                 :          0 : RgM_transmul(GEN x, GEN y)
     588                 :            : {
     589                 :          0 :   long i, j, l, lx, ly = lg(y);
     590                 :            :   GEN M;
     591         [ #  # ]:          0 :   if (ly == 1) return cgetg(1,t_MAT);
     592                 :          0 :   lx = lg(x);
     593                 :          0 :   l = lgcols(y);
     594         [ #  # ]:          0 :   if (lgcols(x) != l) pari_err_OP("operation 'RgM_transmul'", x,y);
     595                 :          0 :   M = cgetg(ly, t_MAT);
     596         [ #  # ]:          0 :   for (i=1; i<ly; i++)
     597                 :            :   {
     598                 :          0 :     GEN yi = gel(y,i), c = cgetg(lx,t_COL);
     599                 :          0 :     gel(M,i) = c;
     600         [ #  # ]:          0 :     for (j=1; j<lx; j++) gel(c,j) = RgV_dotproduct_i(yi,gel(x,j),l);
     601                 :            :   }
     602                 :          0 :   return M;
     603                 :            : }
     604                 :            : 
     605                 :            : GEN
     606                 :        119 : gram_matrix(GEN x)
     607                 :            : {
     608                 :        119 :   long i,j, l, lx = lg(x);
     609                 :            :   GEN M;
     610         [ -  + ]:        119 :   if (!is_matvec_t(typ(x))) pari_err_TYPE("gram",x);
     611         [ +  + ]:        119 :   if (lx == 1) return cgetg(1,t_MAT);
     612                 :        105 :   l = lgcols(x);
     613                 :        105 :   M = cgetg(lx,t_MAT);
     614         [ +  + ]:        294 :   for (i=1; i<lx; i++)
     615                 :            :   {
     616                 :        189 :     GEN xi = gel(x,i), c = cgetg(lx,t_COL);
     617                 :        189 :     gel(M,i) = c;
     618         [ +  + ]:        280 :     for (j=1; j<i; j++)
     619                 :         91 :       gcoeff(M,i,j) = gel(c,j) = RgV_dotproduct_i(xi,gel(x,j),l);
     620                 :        189 :     gel(c,i) = RgV_dotsquare(xi);
     621                 :            :   }
     622                 :        119 :   return M;
     623                 :            : }
     624                 :            : 
     625                 :            : GEN
     626                 :        896 : RgM_sqr(GEN x)
     627                 :            : {
     628                 :        896 :   pari_sp av = avma;
     629                 :        896 :   long j, lx = lg(x);
     630                 :        896 :   GEN z, ffx = NULL;
     631         [ +  + ]:        896 :   if (lx == 1) return cgetg(1, t_MAT);
     632         [ -  + ]:        861 :   if (lx != lgcols(x)) pari_err_OP("operation 'RgM_mul'", x,x);
     633         [ +  + ]:        861 :   if (RgM_is_ZM(x))         return ZM_sqr(x);
     634         [ +  + ]:        812 :   if (is_modular_sqr(x,&z)) return gerepileupto(av, z);
     635         [ +  + ]:        749 :   if (RgM_is_FFM(x, &ffx))  return FFM_mul(x, x, ffx);
     636                 :        721 :   z = cgetg(lx, t_MAT);
     637         [ +  + ]:       2471 :   for (j=1; j<lx; j++) gel(z,j) = RgM_RgC_mul_i(x, gel(x,j), lx, lx);
     638                 :        896 :   return z;
     639                 :            : }
     640                 :            : 
     641                 :            : static GEN
     642                 :       1309 : _RgM_add(void *E, GEN x, GEN y) { (void)E; return RgM_add(x, y); }
     643                 :            : 
     644                 :            : static GEN
     645                 :          0 : _RgM_sub(void *E, GEN x, GEN y) { (void)E; return RgM_sub(x, y); }
     646                 :            : 
     647                 :            : static GEN
     648                 :       2128 : _RgM_cmul(void *E, GEN P, long a, GEN x) { (void)E; return RgM_Rg_mul(x,gel(P,a+2)); }
     649                 :            : 
     650                 :            : static GEN
     651                 :        105 : _RgM_sqr(void *E, GEN x) { (void) E; return RgM_sqr(x); }
     652                 :            : 
     653                 :            : static GEN
     654                 :        224 : _RgM_mul(void *E, GEN x, GEN y) { (void) E; return RgM_mul(x, y); }
     655                 :            : 
     656                 :            : static GEN
     657                 :       1498 : _RgM_one(void *E) { long *n = (long*) E; return matid(*n); }
     658                 :            : 
     659                 :            : static GEN
     660                 :          0 : _RgM_zero(void *E) { long *n = (long*) E; return zeromat(*n,*n); }
     661                 :            : 
     662                 :            : static GEN
     663                 :       1085 : _RgM_red(void *E, GEN x) { (void)E; return x; }
     664                 :            : 
     665                 :            : static struct bb_algebra RgM_algebra = { _RgM_red, _RgM_add, _RgM_sub,
     666                 :            :        _RgM_mul, _RgM_sqr, _RgM_one, _RgM_zero };
     667                 :            : 
     668                 :            : /* generates the list of powers of x of degree 0,1,2,...,l*/
     669                 :            : GEN
     670                 :        154 : RgM_powers(GEN x, long l)
     671                 :            : {
     672                 :        154 :   long n = lg(x)-1;
     673                 :        154 :   return gen_powers(x,l,1,(void *) &n, &_RgM_sqr, &_RgM_mul, &_RgM_one);
     674                 :            : }
     675                 :            : 
     676                 :            : GEN
     677                 :        462 : RgX_RgMV_eval(GEN Q, GEN x)
     678                 :            : {
     679         [ +  - ]:        462 :   long n = lg(x)>1 ? lg(gel(x,1))-1:0;
     680                 :        462 :   return gen_bkeval_powers(Q,degpol(Q),x,(void*)&n,&RgM_algebra,&_RgM_cmul);
     681                 :            : }
     682                 :            : 
     683                 :            : GEN
     684                 :        357 : RgX_RgM_eval(GEN Q, GEN x)
     685                 :            : {
     686                 :        357 :   long n = lg(x)-1;
     687                 :        357 :   return gen_bkeval(Q,degpol(Q),x,1,(void*)&n,&RgM_algebra,&_RgM_cmul);
     688                 :            : }
     689                 :            : 
     690                 :            : GEN
     691                 :    1063903 : RgC_Rg_div(GEN x, GEN y) {
     692                 :    1063903 :   long i, lx = lg(x);
     693                 :    1063903 :   GEN z = cgetg(lx, t_COL);
     694         [ +  + ]:    5119431 :   for (i=1; i<lx; i++) gel(z,i) = gdiv(gel(x,i),y);
     695                 :    1063903 :   return z;
     696                 :            : }
     697                 :            : GEN
     698                 :    3716119 : RgC_Rg_mul(GEN x, GEN y) {
     699                 :    3716119 :   long i, lx = lg(x);
     700                 :    3716119 :   GEN z = cgetg(lx, t_COL);
     701         [ +  + ]:   21187201 :   for (i=1; i<lx; i++) gel(z,i) = gmul(gel(x,i),y);
     702                 :    3716119 :   return z;
     703                 :            : }
     704                 :            : GEN
     705                 :       3086 : RgV_Rg_mul(GEN x, GEN y) {
     706                 :       3086 :   long i, lx = lg(x);
     707                 :       3086 :   GEN z = cgetg(lx, t_VEC);
     708         [ +  + ]:      12450 :   for (i=1; i<lx; i++) gel(z,i) = gmul(gel(x,i),y);
     709                 :       3086 :   return z;
     710                 :            : }
     711                 :            : GEN
     712                 :     105892 : RgM_Rg_div(GEN X, GEN c) {
     713                 :     105892 :   long i, j, h, l = lg(X);
     714                 :     105892 :   GEN A = cgetg(l, t_MAT);
     715         [ +  + ]:     105892 :   if (l == 1) return A;
     716                 :     105843 :   h = lgcols(X);
     717         [ +  + ]:     765490 :   for (j=1; j<l; j++)
     718                 :            :   {
     719                 :     659647 :     GEN a = cgetg(h, t_COL), x = gel(X, j);
     720         [ +  + ]:    8935081 :     for (i = 1; i < h; i++) gel(a,i) = gdiv(gel(x,i), c);
     721                 :     659647 :     gel(A,j) = a;
     722                 :            :   }
     723                 :     105892 :   return A;
     724                 :            : }
     725                 :            : GEN
     726                 :      67841 : RgM_Rg_mul(GEN X, GEN c) {
     727                 :      67841 :   long i, j, h, l = lg(X);
     728                 :      67841 :   GEN A = cgetg(l, t_MAT);
     729         [ +  + ]:      67841 :   if (l == 1) return A;
     730                 :      67806 :   h = lgcols(X);
     731         [ +  + ]:     278278 :   for (j=1; j<l; j++)
     732                 :            :   {
     733                 :     210472 :     GEN a = cgetg(h, t_COL), x = gel(X, j);
     734         [ +  + ]:    2097106 :     for (i = 1; i < h; i++) gel(a,i) = gmul(gel(x,i), c);
     735                 :     210472 :     gel(A,j) = a;
     736                 :            :   }
     737                 :      67841 :   return A;
     738                 :            : }
     739                 :            : 
     740                 :            : /********************************************************************/
     741                 :            : /*                                                                  */
     742                 :            : /*                    SCALAR TO MATRIX/VECTOR                       */
     743                 :            : /*                                                                  */
     744                 :            : /********************************************************************/
     745                 :            : /* fill the square nxn matrix equal to t*Id */
     746                 :            : static void
     747                 :    1672836 : fill_scalmat(GEN y, GEN t, long n)
     748                 :            : {
     749                 :            :   long i;
     750         [ +  + ]:    8036832 :   for (i = 1; i <= n; i++)
     751                 :            :   {
     752                 :    6363996 :     gel(y,i) = zerocol(n);
     753                 :    6363996 :     gcoeff(y,i,i) = t;
     754                 :            :   }
     755                 :    1672836 : }
     756                 :            : 
     757                 :            : GEN
     758                 :     279910 : scalarmat(GEN x, long n) {
     759                 :     279910 :   GEN y = cgetg(n+1, t_MAT);
     760         [ -  + ]:     279910 :   if (!n) return y;
     761                 :     279910 :   fill_scalmat(y, gcopy(x), n); return y;
     762                 :            : }
     763                 :            : GEN
     764                 :          7 : scalarmat_shallow(GEN x, long n) {
     765                 :          7 :   GEN y = cgetg(n+1, t_MAT);
     766                 :          7 :   fill_scalmat(y, x, n); return y;
     767                 :            : }
     768                 :            : GEN
     769                 :        189 : scalarmat_s(long x, long n) {
     770                 :        189 :   GEN y = cgetg(n+1, t_MAT);
     771         [ -  + ]:        189 :   if (!n) return y;
     772                 :        189 :   fill_scalmat(y, stoi(x), n); return y;
     773                 :            : }
     774                 :            : GEN
     775                 :    1392737 : matid(long n) {
     776                 :            :   GEN y;
     777         [ +  + ]:    1392737 :   if (n < 0) pari_err_DOMAIN("matid", "size", "<", gen_0, stoi(n));
     778                 :    1392730 :   y = cgetg(n+1, t_MAT);
     779                 :    1392730 :   fill_scalmat(y, gen_1, n); return y;
     780                 :            : }
     781                 :            : 
     782                 :            : INLINE GEN
     783                 :     479983 : scalarcol_i(GEN x, long n, long c)
     784                 :            : {
     785                 :            :   long i;
     786                 :     479983 :   GEN y = cgetg(n+1,t_COL);
     787         [ -  + ]:     479983 :   if (!n) return y;
     788         [ +  + ]:     479983 :   gel(y,1) = c? gcopy(x): x;
     789         [ +  + ]:    2137275 :   for (i=2; i<=n; i++) gel(y,i) = gen_0;
     790                 :     479983 :   return y;
     791                 :            : }
     792                 :            : 
     793                 :            : GEN
     794                 :     122978 : scalarcol(GEN x, long n) { return scalarcol_i(x,n,1); }
     795                 :            : 
     796                 :            : GEN
     797                 :     357005 : scalarcol_shallow(GEN x, long n) { return scalarcol_i(x,n,0); }
     798                 :            : 
     799                 :            : int
     800                 :       8232 : RgM_isscalar(GEN x, GEN s)
     801                 :            : {
     802                 :       8232 :   long i, j, lx = lg(x);
     803                 :            : 
     804         [ -  + ]:       8232 :   if (lx == 1) return 1;
     805         [ -  + ]:       8232 :   if (lx != lgcols(x)) return 0;
     806         [ +  - ]:       8232 :   if (!s) s = gcoeff(x,1,1);
     807                 :            : 
     808         [ +  + ]:      19838 :   for (j=1; j<lx; j++)
     809                 :            :   {
     810                 :      16737 :     GEN c = gel(x,j);
     811         [ +  + ]:      22668 :     for (i=1; i<j; )
     812         [ +  + ]:       9940 :       if (!gequal0(gel(c,i++))) return 0;
     813                 :            :     /* i = j */
     814         [ +  + ]:      12728 :       if (!gequal(gel(c,i++),s)) return 0;
     815         [ +  + ]:      23009 :     for (   ; i<lx; )
     816         [ -  + ]:      11403 :       if (!gequal0(gel(c,i++))) return 0;
     817                 :            :   }
     818                 :       8232 :   return 1;
     819                 :            : }
     820                 :            : 
     821                 :            : int
     822                 :       1771 : RgM_isidentity(GEN x)
     823                 :            : {
     824                 :       1771 :   long i,j, lx = lg(x);
     825                 :            : 
     826         [ -  + ]:       1771 :   if (lx == 1) return 1;
     827         [ -  + ]:       1771 :   if (lx != lgcols(x)) return 0;
     828         [ +  + ]:       3255 :   for (j=1; j<lx; j++)
     829                 :            :   {
     830                 :       2604 :     GEN c = gel(x,j);
     831         [ +  + ]:       2954 :     for (i=1; i<j; )
     832         [ +  + ]:        833 :       if (!gequal0(gel(c,i++))) return 0;
     833                 :            :     /* i = j */
     834         [ +  + ]:       2121 :       if (!gequal1(gel(c,i++))) return 0;
     835         [ +  + ]:       2408 :     for (   ; i<lx; )
     836         [ -  + ]:        924 :       if (!gequal0(gel(c,i++))) return 0;
     837                 :            :   }
     838                 :       1771 :   return 1;
     839                 :            : }
     840                 :            : 
     841                 :            : long
     842                 :          0 : RgC_is_ei(GEN x)
     843                 :            : {
     844                 :          0 :   long i, j = 0, l = lg(x);
     845         [ #  # ]:          0 :   for (i = 1; i < l; i++)
     846                 :            :   {
     847                 :          0 :     GEN c = gel(x,i);
     848         [ #  # ]:          0 :     if (gequal0(c)) continue;
     849 [ #  # ][ #  # ]:          0 :     if (!gequal1(c) || j) return 0;
     850                 :          0 :     j = i;
     851                 :            :   }
     852                 :          0 :   return j;
     853                 :            : }
     854                 :            : 
     855                 :            : int
     856                 :         28 : RgM_isdiagonal(GEN x)
     857                 :            : {
     858                 :         28 :   long i,j, lx = lg(x);
     859         [ -  + ]:         28 :   if (lx == 1) return 1;
     860         [ -  + ]:         28 :   if (lx != lgcols(x)) return 0;
     861                 :            : 
     862         [ +  + ]:         77 :   for (j=1; j<lx; j++)
     863                 :            :   {
     864                 :         56 :     GEN c = gel(x,j);
     865         [ +  + ]:         91 :     for (i=1; i<j; i++)
     866         [ -  + ]:         35 :       if (!gequal0(gel(c,i))) return 0;
     867         [ +  + ]:         91 :     for (i++; i<lx; i++)
     868         [ +  + ]:         42 :       if (!gequal0(gel(c,i))) return 0;
     869                 :            :   }
     870                 :         28 :   return 1;
     871                 :            : }
     872                 :            : int
     873                 :          7 : isdiagonal(GEN x)
     874                 :            : {
     875 [ +  - ][ +  - ]:          7 :   return (typ(x)==t_MAT) && RgM_isdiagonal(x);
     876                 :            : }
     877                 :            : 
     878                 :            : /* returns the first index i<=n such that x=v[i] if it exists, 0 otherwise */
     879                 :            : long
     880                 :      21833 : RgV_isin(GEN v, GEN x)
     881                 :            : {
     882                 :      21833 :   long i, l = lg(v);
     883         [ +  + ]:     406525 :   for (i = 1; i < l; i++)
     884         [ +  + ]:     406329 :     if (gequal(gel(v,i), x)) return i;
     885                 :      21833 :   return 0;
     886                 :            : }
     887                 :            : 
     888                 :            : GEN
     889                 :       6678 : RgM_det_triangular(GEN mat)
     890                 :            : {
     891                 :       6678 :   long i,l = lg(mat);
     892                 :            :   pari_sp av;
     893                 :            :   GEN s;
     894                 :            : 
     895 [ +  + ][ +  - ]:       6678 :   if (l<3) return l<2? gen_1: gcopy(gcoeff(mat,1,1));
     896                 :       5250 :   av = avma; s = gcoeff(mat,1,1);
     897         [ +  + ]:      12740 :   for (i=2; i<l; i++) s = gmul(s,gcoeff(mat,i,i));
     898         [ -  + ]:       6678 :   return av==avma? gcopy(s): gerepileupto(av,s);
     899                 :            : }
     900                 :            : 
     901                 :            : GEN
     902                 :       3479 : RgV_kill0(GEN v)
     903                 :            : {
     904                 :            :   long i, l;
     905                 :       3479 :   GEN w = cgetg_copy(v, &l);
     906         [ +  + ]:    1818963 :   for (i = 1; i < l; i++)
     907                 :            :   {
     908                 :    1815484 :     GEN a = gel(v,i);
     909         [ +  + ]:    1815484 :     gel(w,i) = gequal0(a) ? NULL: a;
     910                 :            :   }
     911                 :       3479 :   return w;
     912                 :            : }

Generated by: LCOV version 1.9