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 - FpV.c (source / functions) Hit Total Coverage
Test: PARI/GP v2.10.0 lcov report (development 21072-998352a) Lines: 650 848 76.7 %
Date: 2017-09-26 06:25:23 Functions: 93 119 78.2 %
Legend: Lines: hit not hit

          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             : /********************************************************************/
      18             : /**                                                                **/
      19             : /**                           REDUCTION                            **/
      20             : /**                                                                **/
      21             : /********************************************************************/
      22             : /* z in Z^n, return lift(Col(z) * Mod(1,p)) */
      23             : GEN
      24     9153250 : FpC_red(GEN z, GEN p)
      25             : {
      26     9153250 :   long i,l = lg(z);
      27     9153250 :   GEN x = cgetg(l, t_COL);
      28     9153250 :   for (i=1; i<l; i++) gel(x,i) = modii(gel(z,i),p);
      29     9153250 :   return x;
      30             : }
      31             : 
      32             : /* z in Z^n, return lift(Vec(z) * Mod(1,p)) */
      33             : GEN
      34      202013 : FpV_red(GEN z, GEN p)
      35             : {
      36      202013 :   long i,l = lg(z);
      37      202013 :   GEN x = cgetg(l, t_VEC);
      38      202013 :   for (i=1; i<l; i++) gel(x,i) = modii(gel(z,i),p);
      39      202013 :   return x;
      40             : }
      41             : GEN
      42      395521 : FpC_center(GEN z, GEN p, GEN pov2)
      43             : {
      44      395521 :   long i,l = lg(z);
      45      395521 :   GEN x = cgetg(l, t_COL);
      46      395521 :   for (i=1; i<l; i++) gel(x,i) = Fp_center(gel(z,i),p, pov2);
      47      395521 :   return x;
      48             : }
      49             : 
      50             : /* assume 0 <= u < p and ps2 = p>>1 */
      51             : INLINE void
      52          28 : Fp_center_inplace(GEN u, GEN p, GEN ps2)
      53          28 : { if (abscmpii(u,ps2) > 0) subiiz(u,p,u); }
      54             : 
      55             : void
      56          14 : FpC_center_inplace(GEN z, GEN p, GEN ps2)
      57             : {
      58          14 :   long i,l = lg(z);
      59          42 :   for (i=1; i<l; i++)
      60          28 :     Fp_center_inplace(gel(z,i), p, ps2);
      61          14 : }
      62             : 
      63             : GEN
      64      111692 : Flv_center(GEN z, ulong p, ulong ps2)
      65             : {
      66      111692 :   long i, l = lg(z);
      67      111692 :   GEN x = cgetg(l,t_VECSMALL);
      68      111692 :   for (i=1; i<l; i++) x[i] = Fl_center(z[i],p,ps2);
      69      111692 :   return x;
      70             : }
      71             : 
      72             : /* z in Mat m,n(Z), return lift(z * Mod(1,p)) */
      73             : GEN
      74     1819868 : FpM_red(GEN z, GEN p)
      75             : {
      76     1819868 :   long i, l = lg(z);
      77     1819868 :   GEN x = cgetg(l,t_MAT);
      78     1819868 :   for (i=1; i<l; i++) gel(x,i) = FpC_red(gel(z,i), p);
      79     1819868 :   return x;
      80             : }
      81             : GEN
      82       49805 : FpM_center(GEN z, GEN p, GEN pov2)
      83             : {
      84       49805 :   long i, l = lg(z);
      85       49805 :   GEN x = cgetg(l,t_MAT);
      86       49805 :   for (i=1; i<l; i++) gel(x,i) = FpC_center(gel(z,i), p, pov2);
      87       49805 :   return x;
      88             : }
      89             : 
      90             : void
      91          14 : FpM_center_inplace(GEN z, GEN p, GEN pov2)
      92             : {
      93          14 :   long i, l = lg(z);
      94          14 :   for (i=1; i<l; i++) FpC_center_inplace(gel(z,i), p, pov2);
      95          14 : }
      96             : GEN
      97        7896 : Flm_center(GEN z, ulong p, ulong ps2)
      98             : {
      99        7896 :   long i, l = lg(z);
     100        7896 :   GEN x = cgetg(l,t_MAT);
     101        7896 :   for (i=1; i<l; i++) gel(x,i) = Flv_center(gel(z,i),p,ps2);
     102        7896 :   return x;
     103             : }
     104             : 
     105             : GEN
     106           0 : random_FpV(long d, GEN p)
     107             : {
     108             :   long i;
     109           0 :   GEN y = cgetg(d+1,t_VEC);
     110           0 :   for (i=1; i<=d; i++) gel(y,i) = randomi(p);
     111           0 :   return y;
     112             : }
     113             : 
     114             : GEN
     115          28 : random_FpC(long d, GEN p)
     116             : {
     117             :   long i;
     118          28 :   GEN y = cgetg(d+1,t_COL);
     119          28 :   for (i=1; i<=d; i++) gel(y,i) = randomi(p);
     120          28 :   return y;
     121             : }
     122             : 
     123             : GEN
     124        3087 : random_Flv(long n, ulong p)
     125             : {
     126        3087 :   GEN y = cgetg(n+1, t_VECSMALL);
     127             :   long i;
     128        3087 :   for (i=1; i<=n; i++) uel(y,i) = random_Fl(p);
     129        3087 :   return y;
     130             : }
     131             : 
     132             : /********************************************************************/
     133             : /**                                                                **/
     134             : /**                           ADD, SUB                             **/
     135             : /**                                                                **/
     136             : /********************************************************************/
     137             : GEN
     138      394009 : FpC_add(GEN x, GEN y, GEN p)
     139             : {
     140      394009 :   long i, lx = lg(x);
     141      394009 :   GEN z = cgetg(lx, t_COL);
     142      394009 :   for (i = 1; i < lx; i++) gel(z, i) = Fp_add(gel(x, i), gel(y, i), p);
     143      394009 :   return z;
     144             : }
     145             : GEN
     146           0 : FpV_add(GEN x, GEN y, GEN p)
     147             : {
     148           0 :   long i, lx = lg(x);
     149           0 :   GEN z = cgetg(lx, t_VEC);
     150           0 :   for (i = 1; i < lx; i++) gel(z, i) = Fp_add(gel(x, i), gel(y, i), p);
     151           0 :   return z;
     152             : }
     153             : GEN
     154           0 : FpM_add(GEN x, GEN y, GEN p)
     155             : {
     156           0 :   long lx = lg(x), j;
     157             :   GEN z;
     158           0 :   if (lx == 1) return cgetg(1, t_MAT);
     159           0 :   z = cgetg(lx, t_MAT);
     160           0 :   for (j = 1; j < lx; j++) gel(z,j) = FpC_add(gel(x,j), gel(y,j), p);
     161           0 :   return z;
     162             : }
     163             : 
     164             : GEN
     165      959441 : Flv_add(GEN x, GEN y, ulong p)
     166             : {
     167      959441 :   long i, l = lg(x);
     168      959441 :   GEN z = cgetg(l, t_VECSMALL);
     169      959441 :   if (p==2)
     170       45822 :     for (i = 1; i < l; i++) z[i] = x[i]^y[i];
     171             :   else
     172      913619 :     for (i = 1; i < l; i++) z[i] = Fl_add(x[i], y[i], p);
     173      959441 :   return z;
     174             : }
     175             : 
     176             : void
     177      167364 : Flv_add_inplace(GEN x, GEN y, ulong p)
     178             : {
     179      167364 :   long i, l = lg(x);
     180      167364 :   if (p==2)
     181      165222 :     for (i = 1; i < l; i++) x[i] ^= y[i];
     182             :   else
     183        2142 :     for (i = 1; i < l; i++) x[i] = Fl_add(x[i], y[i], p);
     184      167364 : }
     185             : 
     186             : ulong
     187        3822 : Flv_sum(GEN x, ulong p)
     188             : {
     189        3822 :   long i, l = lg(x);
     190        3822 :   ulong s = 0;
     191        3822 :   if (p==2)
     192        3822 :     for (i = 1; i < l; i++) s ^= x[i];
     193             :   else
     194           0 :     for (i = 1; i < l; i++) s = Fl_add(s, x[i], p);
     195        3822 :   return s;
     196             : }
     197             : 
     198             : GEN
     199      354144 : FpC_sub(GEN x, GEN y, GEN p)
     200             : {
     201      354144 :   long i, lx = lg(x);
     202      354144 :   GEN z = cgetg(lx, t_COL);
     203      354144 :   for (i = 1; i < lx; i++) gel(z, i) = Fp_sub(gel(x, i), gel(y, i), p);
     204      354144 :   return z;
     205             : }
     206             : GEN
     207           0 : FpV_sub(GEN x, GEN y, GEN p)
     208             : {
     209           0 :   long i, lx = lg(x);
     210           0 :   GEN z = cgetg(lx, t_VEC);
     211           0 :   for (i = 1; i < lx; i++) gel(z, i) = Fp_sub(gel(x, i), gel(y, i), p);
     212           0 :   return z;
     213             : }
     214             : 
     215             : GEN
     216           0 : FpM_sub(GEN x, GEN y, GEN p)
     217             : {
     218           0 :   long i, l = lg(x);
     219           0 :   GEN z = cgetg(l, t_MAT);
     220           0 :   for (i = 1; i < l; i++) gel(z, i) = FpC_sub(gel(x, i), gel(y, i), p);
     221           0 :   return z;
     222             : }
     223             : 
     224             : GEN
     225    77382951 : Flv_sub(GEN x, GEN y, ulong p)
     226             : {
     227    77382951 :   long i, l = lg(x);
     228    77382951 :   GEN z = cgetg(l, t_VECSMALL);
     229    77382951 :   for (i = 1; i < l; i++) z[i] = Fl_sub(x[i], y[i], p);
     230    77382951 :   return z;
     231             : }
     232             : 
     233             : void
     234           0 : Flv_sub_inplace(GEN x, GEN y, ulong p)
     235             : {
     236           0 :   long i, l = lg(x);
     237           0 :   for (i = 1; i < l; i++) x[i] = Fl_sub(x[i], y[i], p);
     238           0 : }
     239             : 
     240             : GEN
     241        7714 : Flm_Fl_add(GEN x, ulong y, ulong p)
     242             : {
     243        7714 :   long l = lg(x), i, j;
     244        7714 :   GEN z = cgetg(l,t_MAT);
     245             : 
     246        7714 :   if (l==1) return z;
     247        7714 :   if (l != lgcols(x)) pari_err_OP( "+", x, utoi(y));
     248       31465 :   for (i=1; i<l; i++)
     249             :   {
     250       23751 :     GEN zi = cgetg(l,t_VECSMALL), xi = gel(x,i);
     251       23751 :     gel(z,i) = zi;
     252       23751 :     for (j=1; j<l; j++) zi[j] = xi[j];
     253       23751 :     zi[i] = Fl_add(zi[i], y, p);
     254             :   }
     255        7714 :   return z;
     256             : }
     257             : 
     258             : GEN
     259       14672 : Flm_add(GEN x, GEN y, ulong p)
     260             : {
     261       14672 :   long i, l = lg(x);
     262       14672 :   GEN z = cgetg(l,t_MAT);
     263       14672 :   for (i = 1; i < l; i++) gel(z,i) = Flv_add(gel(x,i),gel(y,i),p);
     264       14672 :   return z;
     265             : }
     266             : 
     267             : GEN
     268     7766503 : Flm_sub(GEN x, GEN y, ulong p)
     269             : {
     270     7766503 :   long i, l = lg(x);
     271     7766503 :   GEN z = cgetg(l, t_MAT);
     272     7766503 :   for (i = 1; i < l; i++) gel(z, i) = Flv_sub(gel(x, i), gel(y, i), p);
     273     7766503 :   return z;
     274             : }
     275             : 
     276             : /********************************************************************/
     277             : /**                                                                **/
     278             : /**                           MULTIPLICATION                       **/
     279             : /**                                                                **/
     280             : /********************************************************************/
     281             : GEN
     282     1124249 : FpC_Fp_mul(GEN x, GEN y, GEN p)
     283             : {
     284     1124249 :   long i, l = lg(x);
     285     1124249 :   GEN z = cgetg(l, t_COL);
     286     1124249 :   for (i=1;i<l;i++) gel(z,i) = Fp_mul(gel(x,i),y,p);
     287     1124249 :   return z;
     288             : }
     289             : GEN
     290      786154 : Flv_Fl_mul(GEN x, ulong y, ulong p)
     291             : {
     292      786154 :   long i, l = lg(x);
     293      786154 :   GEN z = cgetg(l, t_VECSMALL);
     294      786154 :   for (i=1;i<l;i++) z[i] = Fl_mul(x[i], y, p);
     295      786154 :   return z;
     296             : }
     297             : GEN
     298         329 : Flv_Fl_div(GEN x, ulong y, ulong p)
     299             : {
     300         329 :   return Flv_Fl_mul(x, Fl_inv(y, p), p);
     301             : }
     302             : void
     303           0 : Flv_Fl_div_inplace(GEN x, ulong y, ulong p)
     304             : {
     305           0 :   Flv_Fl_mul_inplace(x, Fl_inv(y, p), p);
     306           0 : }
     307             : GEN
     308        1351 : FpM_Fp_mul(GEN X, GEN c, GEN p) {
     309        1351 :   long i, j, h, l = lg(X);
     310        1351 :   GEN A = cgetg(l, t_MAT);
     311        1351 :   if (l == 1) return A;
     312        1351 :   h = lgcols(X);
     313       10479 :   for (j=1; j<l; j++)
     314             :   {
     315        9128 :     GEN a = cgetg(h, t_COL), x = gel(X, j);
     316        9128 :     for (i = 1; i < h; i++) gel(a,i) = Fp_mul(gel(x,i), c, p);
     317        9128 :     gel(A,j) = a;
     318             :   }
     319        1351 :   return A;
     320             : }
     321             : 
     322             : /* x *= y */
     323             : void
     324     1544990 : Flv_Fl_mul_part_inplace(GEN x, ulong y, ulong p, long l)
     325             : {
     326             :   long i;
     327     1544990 :   for (i=1;i<=l;i++) x[i] = Fl_mul(x[i], y, p);
     328     1544990 : }
     329             : void
     330           0 : Flv_Fl_mul_inplace(GEN x, ulong y, ulong p)
     331           0 : { Flv_Fl_mul_part_inplace(x, y, p, lg(x)-1); }
     332             : 
     333             : /* set y *= x */
     334             : void
     335       45367 : Flm_Fl_mul_inplace(GEN y, ulong x, ulong p)
     336             : {
     337       45367 :   long i, j, m, l = lg(y);
     338       90734 :   if (l == 1) return;
     339       45367 :   m = lgcols(y);
     340       45367 :   if (HIGHWORD(x | p))
     341      325782 :     for(j=1; j<l; j++)
     342      280415 :       for(i=1; i<m; i++) ucoeff(y,i,j) = Fl_mul(ucoeff(y,i,j), x, p);
     343             :   else
     344           0 :     for(j=1; j<l; j++)
     345           0 :       for(i=1; i<m; i++) ucoeff(y,i,j) = (ucoeff(y,i,j) * x) % p;
     346             : }
     347             : 
     348             : /* return x * y */
     349             : GEN
     350     6484347 : Flm_Fl_mul(GEN y, ulong x, ulong p)
     351             : {
     352     6484347 :   long i, j, m, l = lg(y);
     353     6484347 :   GEN z = cgetg(l, t_MAT);
     354     6484347 :   if (l == 1) return z;
     355     6484347 :   m = lgcols(y);
     356     6484347 :   if (HIGHWORD(x | p))
     357    35804688 :     for(j=1; j<l; j++) {
     358    32344663 :       GEN c = cgetg(m, t_VECSMALL); gel(z,j) = c;
     359    32344663 :       for(i=1; i<m; i++) c[i] = Fl_mul(ucoeff(y,i,j), x, p);
     360             :     }
     361             :   else
     362    22396504 :     for(j=1; j<l; j++) {
     363    19372182 :       GEN c = cgetg(m, t_VECSMALL); gel(z,j) = c;
     364    19372182 :       for(i=1; i<m; i++) c[i] = (ucoeff(y,i,j) * x) % p;
     365             :     }
     366     6484347 :   return z;
     367             : }
     368             : 
     369             : GEN
     370     1863397 : Flv_neg(GEN v, ulong p)
     371             : {
     372     1863397 :   long i, m = lg(v);
     373     1863397 :   GEN c = cgetg(m, t_VECSMALL);
     374     1863397 :   for(i=1; i<m; i++) uel(c,i) = Fl_neg(uel(v,i), p);
     375     1863397 :   return c;
     376             : }
     377             : 
     378             : void
     379        5289 : Flv_neg_inplace(GEN v, ulong p)
     380             : {
     381             :   long i;
     382      167660 :   for (i = 1; i < lg(v); ++i)
     383      162371 :     v[i] = Fl_neg(v[i], p);
     384        5289 : }
     385             : 
     386             : GEN
     387      170700 : Flm_neg(GEN y, ulong p)
     388             : {
     389      170700 :   long j, l = lg(y);
     390      170700 :   GEN z = cgetg(l, t_MAT);
     391     2010391 :   for(j=1; j<l; j++)
     392     1839691 :     gel(z,j) = Flv_neg(gel(y,j), p);
     393      170700 :   return z;
     394             : }
     395             : 
     396             : /* x[i,]*y. Assume lx > 1 and 0 < i < lgcols(x) */
     397             : static GEN
     398    18232302 : ZMrow_ZC_mul_i(GEN x, GEN y, long lx, long i)
     399             : {
     400    18232302 :   GEN c = mulii(gcoeff(x,i,1), gel(y,1));
     401             :   long k;
     402   344195429 :   for (k = 2; k < lx; k++)
     403             :   {
     404   325963127 :     GEN t = mulii(gcoeff(x,i,k), gel(y,k));
     405   325963127 :     if (signe(t)) c = addii(c, t);
     406             :   }
     407    18232302 :   return c;
     408             : }
     409             : 
     410             : static long
     411    21635523 : zmrow_zc_mul(GEN x, GEN y, long lx, long i)
     412             : {
     413             :   long k;
     414    21635523 :   long c = coeff(x,i,1) * y[1];
     415   289227596 :   for (k = 2; k < lx; k++)
     416   267592073 :     c += coeff(x,i,k) * y[k];
     417    21635523 :   return c;
     418             : }
     419             : 
     420             : GEN
     421     1653225 : zm_zc_mul(GEN x, GEN y)
     422             : {
     423     1653225 :   long lx = lg(x), l, i;
     424             :   GEN z;
     425     1653225 :   if (lx == 1) return cgetg(1, t_VECSMALL);
     426     1653225 :   l = lg(gel(x,1));
     427     1653225 :   z = cgetg(l,t_VECSMALL);
     428     1653225 :   for (i=1; i<l; i++) z[i] = zmrow_zc_mul(x, y, lx, i);
     429     1653225 :   return z;
     430             : }
     431             : 
     432             : GEN
     433         252 : zm_mul(GEN x, GEN y)
     434             : {
     435         252 :   long i,j,lx=lg(x), ly=lg(y);
     436             :   GEN z;
     437         252 :   if (ly==1) return cgetg(1,t_MAT);
     438         252 :   z = cgetg(ly,t_MAT);
     439         252 :   if (lx==1)
     440             :   {
     441           0 :     for (i=1; i<ly; i++) gel(z,i) = cgetg(1,t_VECSMALL);
     442           0 :     return z;
     443             :   }
     444        2128 :   for (j=1; j<ly; j++)
     445        1876 :     gel(z,j) = zm_zc_mul(x, gel(y,j));
     446         252 :   return z;
     447             : }
     448             : 
     449             : static ulong
     450   318190168 : Flmrow_Flc_mul_SMALL(GEN x, GEN y, ulong p, long lx, long i)
     451             : {
     452   318190168 :   ulong c = ucoeff(x,i,1) * uel(y,1);
     453             :   long k;
     454  7362215722 :   for (k = 2; k < lx; k++) {
     455  7044025554 :     c += ucoeff(x,i,k) * uel(y,k);
     456  7044025554 :     if (c & HIGHBIT) c %= p;
     457             :   }
     458   318190168 :   return c % p;
     459             : }
     460             : 
     461             : static ulong
     462   130885345 : Flmrow_Flc_mul_i(GEN x, GEN y, ulong p, ulong pi, long lx, long i)
     463             : {
     464             :   ulong l0, l1, v1, h0, h1;
     465   130885345 :   long k = 1;
     466             :   LOCAL_OVERFLOW;
     467             :   LOCAL_HIREMAINDER;
     468   130885345 :   l1 = mulll(ucoeff(x,i,k), uel(y,k)); h1 = hiremainder; v1 = 0;
     469  1573716176 :   while (++k < lx) {
     470  1311945486 :     l0 = mulll(ucoeff(x,i,k), uel(y,k)); h0 = hiremainder;
     471  1311945486 :     l1 = addll(l0, l1); h1 = addllx(h0, h1); v1 += overflow;
     472             :   }
     473   130885345 :   if (v1 == 0) return remll_pre(h1, l1, p, pi);
     474     4856879 :   else return remlll_pre(v1, h1, l1, p, pi);
     475             : }
     476             : 
     477             : static GEN
     478      147294 : Flm_Flc_mul_i_2(GEN x, GEN y, long lx, long l)
     479             : {
     480             :   long i,j;
     481      147294 :   GEN z = NULL;
     482             : 
     483     3774155 :   for (j=1; j<lx; j++)
     484             :   {
     485     3626861 :     if (!y[j]) continue;
     486      278629 :     if (!z) z = Flv_copy(gel(x,j));
     487      169373 :     else for (i = 1; i < l; i++) z[i] ^= coeff(x,i,j);
     488             :   }
     489      147294 :   if (!z) z = zero_zv(l-1);
     490      147294 :   return z;
     491             : }
     492             : 
     493             : static GEN
     494     1269685 : FpM_FpC_mul_i(GEN x, GEN y, long lx, long l, GEN p)
     495             : {
     496     1269685 :   GEN z = cgetg(l,t_COL);
     497             :   long i;
     498    18571729 :   for (i = 1; i < l; i++)
     499             :   {
     500    17302044 :     pari_sp av = avma;
     501    17302044 :     GEN c = ZMrow_ZC_mul_i(x, y, lx, i);
     502    17302044 :     gel(z,i) = gerepileuptoint(av, modii(c,p));
     503             :   }
     504     1269685 :   return z;
     505             : }
     506             : 
     507             : static void
     508    35107584 : __Flm_Flc_mul_i_SMALL(GEN z, GEN x, GEN y, long lx, long l, ulong p)
     509             : {
     510             :   long i;
     511    35107584 :   for (i = 1; i < l; i++) z[i] = Flmrow_Flc_mul_SMALL(x, y, p, lx, i);
     512    35093486 : }
     513             : static GEN
     514    31971952 : Flm_Flc_mul_i_SMALL(GEN x, GEN y, long lx, long l, ulong p)
     515             : {
     516    31971952 :   GEN z = cgetg(l,t_VECSMALL);
     517    31971952 :   __Flm_Flc_mul_i_SMALL(z, x, y, lx, l, p);
     518    31971952 :   return z;
     519             : }
     520             : 
     521             : static void
     522    25041020 : __Flm_Flc_mul_i(GEN z, GEN x, GEN y, long lx, long l, ulong p, ulong pi)
     523             : {
     524             :   long i;
     525    25041020 :   for (i = 1; i < l; i++) z[i] = Flmrow_Flc_mul_i(x, y, p, pi, lx, i);
     526    25042108 : }
     527             : static GEN
     528    21162215 : Flm_Flc_mul_i(GEN x, GEN y, long lx, long l, ulong p, ulong pi)
     529             : {
     530    21162215 :   GEN z = cgetg(l,t_VECSMALL);
     531    21162215 :   __Flm_Flc_mul_i(z, x, y, lx, l, p, pi);
     532    21162215 :   return z;
     533             : }
     534             : 
     535             : INLINE GEN
     536      295010 : F2m_F2c_mul_i(GEN x, GEN y, long lx, long l)
     537             : {
     538             :   long j;
     539      295010 :   GEN z = NULL;
     540             : 
     541     3820884 :   for (j=1; j<lx; j++)
     542             :   {
     543     3525874 :     if (!F2v_coeff(y,j)) continue;
     544      847967 :     if (!z) z = vecsmall_copy(gel(x,j));
     545      573453 :     else F2v_add_inplace(z,gel(x,j));
     546             :   }
     547      295010 :   if (!z) z = zero_F2v(l);
     548      295010 :   return z;
     549             : }
     550             : 
     551             : GEN
     552      431633 : FpM_mul(GEN x, GEN y, GEN p)
     553             : {
     554      431633 :   long j, l, lx=lg(x), ly=lg(y);
     555             :   GEN z;
     556      431633 :   if (ly==1) return cgetg(1,t_MAT);
     557      431633 :   if (lx==1) return zeromat(0, ly-1);
     558      431633 :   if (lgefint(p) == 3)
     559             :   {
     560      430910 :     pari_sp av = avma;
     561      430910 :     ulong pp = uel(p,2);
     562      430910 :     if (pp == 2)
     563             :     {
     564       61156 :       x = ZM_to_F2m(x);
     565       61156 :       y = ZM_to_F2m(y);
     566       61156 :       z = F2m_to_ZM(F2m_mul(x,y));
     567             :     }
     568             :     else
     569             :     {
     570      369754 :       x = ZM_to_Flm(x, pp);
     571      369754 :       y = ZM_to_Flm(y, pp);
     572      369754 :       z = Flm_to_ZM(Flm_mul(x,y, pp));
     573             :     }
     574      430910 :     return gerepileupto(av, z);
     575             :   }
     576         723 :   l = lgcols(x); z = cgetg(ly,t_MAT);
     577         723 :   for (j=1; j<ly; j++) gel(z,j) = FpM_FpC_mul_i(x, gel(y,j), lx, l, p);
     578         723 :   return z;
     579             : }
     580             : GEN
     581     5903205 : Flm_mul(GEN x, GEN y, ulong p)
     582             : {
     583     5903205 :   long i,j,l,lx=lg(x), ly=lg(y);
     584             :   GEN z;
     585     5903205 :   if (ly==1) return cgetg(1,t_MAT);
     586     5902414 :   z = cgetg(ly,t_MAT);
     587     5902414 :   if (lx==1)
     588             :   {
     589           0 :     for (i=1; i<ly; i++) gel(z,i) = cgetg(1,t_VECSMALL);
     590           0 :     return z;
     591             :   }
     592     5902414 :   l = lgcols(x);
     593     5902414 :   if (SMALL_ULONG(p)) {
     594    34763644 :     for (j=1; j<ly; j++)
     595    31724770 :       gel(z,j) = Flm_Flc_mul_i_SMALL(x, gel(y,j), lx, l, p);
     596             :   } else {
     597     2863540 :     ulong pi = get_Fl_red(p);
     598    23889682 :     for (j=1; j<ly; j++)
     599    21026142 :       gel(z,j) = Flm_Flc_mul_i(x, gel(y,j), lx, l, p, pi);
     600             :   }
     601     5902414 :   return z;
     602             : }
     603             : GEN
     604       61205 : F2m_mul(GEN x, GEN y)
     605             : {
     606       61205 :   long i,j,l,lx=lg(x), ly=lg(y);
     607             :   GEN z;
     608       61205 :   if (ly==1) return cgetg(1,t_MAT);
     609       61205 :   z = cgetg(ly,t_MAT);
     610       61205 :   if (lx==1)
     611             :   {
     612           0 :     for (i=1; i<ly; i++) gel(z,i) = mkvecsmall(0);
     613           0 :     return z;
     614             :   }
     615       61205 :   l = coeff(x,1,1);
     616       61205 :   for (j=1; j<ly; j++) gel(z,j) = F2m_F2c_mul_i(x, gel(y,j), lx, l);
     617       61205 :   return z;
     618             : }
     619             : 
     620             : static GEN
     621       14217 : _Flm_mul(void *p , GEN x, GEN y)
     622       14217 : { return Flm_mul(x,y,*(ulong*)p); }
     623             : static GEN
     624       43470 : _Flm_sqr(void *p, GEN x)
     625       43470 : { return Flm_mul(x,x,*(ulong*)p); }
     626             : GEN
     627       20426 : Flm_powu(GEN x, ulong n, ulong p)
     628             : {
     629       20426 :   pari_sp av = avma;
     630       20426 :   if (!n) return matid(lg(x)-1);
     631       20426 :   return gerepileupto(av, gen_powu(x, n, (void*)&p, &_Flm_sqr, &_Flm_mul));
     632             : }
     633             : static GEN
     634           0 : _F2m_mul(void *data, GEN x, GEN y)
     635           0 : { (void) data; return F2m_mul(x,y); }
     636             : static GEN
     637           0 : _F2m_sqr(void *data, GEN x)
     638           0 : { (void) data; return F2m_mul(x,x); }
     639             : GEN
     640           0 : F2m_powu(GEN x, ulong n)
     641             : {
     642           0 :   pari_sp av = avma;
     643           0 :   if (!n) return matid(lg(x)-1);
     644           0 :   return gerepileupto(av, gen_powu(x, n,NULL, &_F2m_sqr, &_F2m_mul));
     645             : }
     646             : static GEN
     647           0 : _FpM_mul(void *p , GEN x, GEN y)
     648           0 : { return FpM_mul(x,y,(GEN)p); }
     649             : static GEN
     650           0 : _FpM_sqr(void *p, GEN x)
     651           0 : { return FpM_mul(x,x,(GEN)p); }
     652             : GEN
     653           0 : FpM_powu(GEN x, ulong n, GEN p)
     654             : {
     655           0 :   pari_sp av = avma;
     656           0 :   if (!n) return matid(lg(x)-1);
     657           0 :   if (lgefint(p) == 3)
     658             :   {
     659           0 :     pari_sp av = avma;
     660           0 :     ulong pp = uel(p,2);
     661             :     GEN z;
     662           0 :     if (pp == 2)
     663           0 :       z = F2m_to_ZM(F2m_powu(ZM_to_F2m(x),n));
     664             :     else
     665           0 :       z = Flm_to_ZM(Flm_powu(ZM_to_Flm(x, pp), n, pp));
     666           0 :     return gerepileupto(av, z);
     667             :   }
     668           0 :   return gerepileupto(av, gen_powu(x, n, (void*)p, &_FpM_sqr, &_FpM_mul));
     669             : }
     670             : 
     671             : /*Multiple a column vector by a line vector to make a matrix*/
     672             : GEN
     673        1540 : FpC_FpV_mul(GEN x, GEN y, GEN p)
     674             : {
     675        1540 :   long i,j, lx=lg(x), ly=lg(y);
     676             :   GEN z;
     677        1540 :   if (ly==1) return cgetg(1,t_MAT);
     678        1540 :   z = cgetg(ly,t_MAT);
     679       28252 :   for (j=1; j < ly; j++)
     680             :   {
     681       26712 :     gel(z,j) = cgetg(lx,t_COL);
     682       26712 :     for (i=1; i<lx; i++) gcoeff(z,i,j) = Fp_mul(gel(x,i),gel(y,j), p);
     683             :   }
     684        1540 :   return z;
     685             : }
     686             : 
     687             : /* Multiply a line vector by a column and return a scalar (t_INT) */
     688             : GEN
     689     2307831 : FpV_dotproduct(GEN x, GEN y, GEN p)
     690             : {
     691     2307831 :   long i, lx = lg(x);
     692             :   pari_sp av;
     693             :   GEN c;
     694     2307831 :   if (lx == 1) return gen_0;
     695     2307789 :   av = avma; c = mulii(gel(x,1),gel(y,1));
     696     2307789 :   for (i=2; i<lx; i++) c = addii(c, mulii(gel(x,i),gel(y,i)));
     697     2307789 :   return gerepileuptoint(av, modii(c,p));
     698             : }
     699             : GEN
     700           0 : FpV_dotsquare(GEN x, GEN p)
     701             : {
     702           0 :   long i, lx = lg(x);
     703             :   pari_sp av;
     704             :   GEN c;
     705           0 :   if (lx == 1) return gen_0;
     706           0 :   av = avma; c = sqri(gel(x,1));
     707           0 :   for (i=2; i<lx; i++) c = addii(c, sqri(gel(x,i)));
     708           0 :   return gerepileuptoint(av, modii(c,p));
     709             : }
     710             : 
     711             : INLINE ulong
     712      890746 : Flv_dotproductspec_SMALL(GEN x, GEN y, ulong p, long lx)
     713             : {
     714      890746 :   ulong c = uel(x,0) * uel(y,0);
     715             :   long k;
     716    12320212 :   for (k = 1; k < lx; k++) {
     717    11429466 :     c += uel(x,k) * uel(y,k);
     718    11429466 :     if (c & HIGHBIT) c %= p;
     719             :   }
     720      890746 :   return c % p;
     721             : }
     722             : 
     723             : INLINE ulong
     724        5542 : Flv_dotproductspec_i(GEN x, GEN y, ulong p, ulong pi, long lx)
     725             : {
     726             :   ulong l0, l1, v1, h0, h1;
     727        5542 :   long i = 0;
     728             :   LOCAL_OVERFLOW;
     729             :   LOCAL_HIREMAINDER;
     730        5542 :   l1 = mulll(uel(x,i), uel(y,i)); h1 = hiremainder; v1 = 0;
     731      166552 :   while (++i < lx) {
     732      155468 :     l0 = mulll(uel(x,i), uel(y,i)); h0 = hiremainder;
     733      155468 :     l1 = addll(l0, l1); h1 = addllx(h0, h1); v1 += overflow;
     734             :   }
     735        5542 :   if (v1 == 0) return remll_pre(h1, l1, p, pi);
     736           0 :   else return remlll_pre(v1, h1, l1, p, pi);
     737             : }
     738             : 
     739             : ulong
     740      453292 : Flv_dotproduct(GEN x, GEN y, ulong p)
     741             : {
     742      453292 :   long lx = lg(x)-1;
     743      453292 :   if (lx == 0) return 0;
     744      453292 :   if (SMALL_ULONG(p))
     745      453292 :     return Flv_dotproductspec_SMALL(x+1, y+1, p, lx);
     746             :   else
     747           0 :     return Flv_dotproductspec_i(x+1, y+1, p, get_Fl_red(p), lx);
     748             : }
     749             : 
     750             : ulong
     751       53459 : Flv_dotproduct_pre(GEN x, GEN y, ulong p, ulong pi)
     752             : {
     753       53459 :   long lx = lg(x)-1;
     754       53459 :   if (lx == 0) return 0;
     755       53459 :   if (SMALL_ULONG(p))
     756       48001 :     return Flv_dotproductspec_SMALL(x+1, y+1, p, lx);
     757             :   else
     758        5458 :     return Flv_dotproductspec_i(x+1, y+1, p, pi, lx);
     759             : }
     760             : 
     761             : ulong
     762      399864 : Flx_dotproduct(GEN x, GEN y, ulong p)
     763             : {
     764      399864 :   long lx = minss(lgpol(x), lgpol(y));
     765      399864 :   if (lx == 0) return 0;
     766      389536 :   if (SMALL_ULONG(p))
     767      389452 :     return Flv_dotproductspec_SMALL(x+2, y+2, p, lx);
     768             :   else
     769          84 :     return Flv_dotproductspec_i(x+2, y+2, p, get_Fl_red(p), lx);
     770             : }
     771             : 
     772             : ulong
     773           0 : F2v_dotproduct(GEN x, GEN y)
     774             : {
     775           0 :   long i, lx = lg(x);
     776             :   ulong c;
     777           0 :   if (lx == 1) return 0;
     778           0 :   c = uel(x,1) & uel(y,1);
     779           0 :   for (i=2; i<lx; i++) c ^= uel(x,i) & uel(y,i);
     780             : #ifdef LONG_IS_64BIT
     781           0 :   c ^= c >> 32;
     782             : #endif
     783           0 :   c ^= c >> 16;
     784           0 :   c ^= c >>  8;
     785           0 :   c ^= c >>  4;
     786           0 :   c ^= c >>  2;
     787           0 :   c ^= c >>  1;
     788           0 :   return c & 1;
     789             : }
     790             : 
     791             : GEN
     792     1263003 : FpM_FpC_mul(GEN x, GEN y, GEN p)
     793             : {
     794     1263003 :   long lx = lg(x);
     795     1263003 :   return lx==1? cgetg(1,t_COL): FpM_FpC_mul_i(x, y, lx, lgcols(x), p);
     796             : }
     797             : GEN
     798      530549 : Flm_Flc_mul(GEN x, GEN y, ulong p)
     799             : {
     800      530549 :   long l, lx = lg(x);
     801      530549 :   if (lx==1) return cgetg(1,t_VECSMALL);
     802      530549 :   l = lgcols(x);
     803      530549 :   if (p==2)
     804      147294 :     return Flm_Flc_mul_i_2(x, y, lx, l);
     805      383255 :   else if (SMALL_ULONG(p))
     806      247182 :     return Flm_Flc_mul_i_SMALL(x, y, lx, l, p);
     807             :   else
     808      136073 :     return Flm_Flc_mul_i(x, y, lx, l, p, get_Fl_red(p));
     809             : }
     810             : 
     811             : GEN
     812        4815 : Flm_Flc_mul_pre(GEN x, GEN y, ulong p, ulong pi)
     813             : {
     814        4815 :   long l, lx = lg(x);
     815             :   GEN z;
     816        4815 :   if (lx==1) return cgetg(1,t_VECSMALL);
     817        4815 :   l = lgcols(x);
     818        4815 :   z = cgetg(l, t_VECSMALL);
     819        4816 :   if (SMALL_ULONG(p))
     820        4128 :     __Flm_Flc_mul_i_SMALL(z, x, y, lx, l, p);
     821             :   else
     822         688 :     __Flm_Flc_mul_i(z, x, y, lx, l, p, pi);
     823        4816 :   return z;
     824             : }
     825             : 
     826             : GEN
     827     6984198 : Flm_Flc_mul_pre_Flx(GEN x, GEN y, ulong p, ulong pi, long sv)
     828             : {
     829     6984198 :   long l, lx = lg(x);
     830             :   GEN z;
     831     6984198 :   if (lx==1) return pol0_Flx(sv);
     832     6984198 :   l = lgcols(x);
     833     6989744 :   z = cgetg(l + 1, t_VECSMALL); z[1] = sv;
     834     6994204 :   if (SMALL_ULONG(p))
     835     3115953 :     __Flm_Flc_mul_i_SMALL(z + 1, x, y, lx, l, p);
     836             :   else
     837     3878251 :     __Flm_Flc_mul_i(z + 1, x, y, lx, l, p, pi);
     838     6995677 :   return Flx_normalize(z, l + 1);
     839             : }
     840             : 
     841             : GEN
     842           0 : F2m_F2c_mul(GEN x, GEN y)
     843             : {
     844           0 :   long l, lx = lg(x);
     845           0 :   if (lx==1) return cgetg(1,t_VECSMALL);
     846           0 :   l = coeff(x,1,1);
     847           0 :   return F2m_F2c_mul_i(x, y, lx, l);
     848             : }
     849             : /* RgV_to_RgX(FpM_FpC_mul(x,y,p), v), p != NULL, memory clean */
     850             : GEN
     851      324964 : FpM_FpC_mul_FpX(GEN x, GEN y, GEN p, long v)
     852             : {
     853      324964 :   long i, l, lx = lg(x);
     854             :   GEN z;
     855      324964 :   if (lx==1) return pol_0(v);
     856      324964 :   l = lgcols(x);
     857      324964 :   z = new_chunk(l+1);
     858      709606 :   for (i=l-1; i; i--)
     859             :   {
     860      561197 :     pari_sp av = avma;
     861      561197 :     GEN p1 = ZMrow_ZC_mul_i(x,y,lx,i);
     862      561197 :     p1 = modii(p1, p);
     863      561197 :     if (signe(p1))
     864             :     {
     865      176555 :       if (i != l-1) stackdummy((pari_sp)(z + l+1), (pari_sp)(z + i+2));
     866      176555 :       gel(z,i+1) = gerepileuptoint(av, p1);
     867      176555 :       break;
     868             :     }
     869      384642 :     avma = av;
     870             :   }
     871      324964 :   if (!i) { avma = (pari_sp)(z + l+1); return pol_0(v); }
     872      176555 :   z[0] = evaltyp(t_POL) | evallg(i+2);
     873      176555 :   z[1] = evalsigne(1) | evalvarn(v);
     874      545616 :   for (; i; i--)
     875             :   {
     876      369061 :     pari_sp av = avma;
     877      369061 :     GEN p1 = ZMrow_ZC_mul_i(x,y,lx,i);
     878      369061 :     gel(z,i+1) = gerepileuptoint(av, modii(p1,p));
     879             :   }
     880      176555 :   return z;
     881             : }
     882             : 
     883             : /********************************************************************/
     884             : /**                                                                **/
     885             : /**                           TRANSPOSITION                        **/
     886             : /**                                                                **/
     887             : /********************************************************************/
     888             : 
     889             : /* == zm_transpose */
     890             : GEN
     891      370957 : Flm_transpose(GEN x)
     892             : {
     893      370957 :   long i, dx, lx = lg(x);
     894             :   GEN y;
     895      370957 :   if (lx == 1) return cgetg(1,t_MAT);
     896      370957 :   dx = lgcols(x); y = cgetg(dx,t_MAT);
     897      370961 :   for (i=1; i<dx; i++) gel(y,i) = Flm_row(x,i);
     898      370957 :   return y;
     899             : }
     900             : 
     901             : /********************************************************************/
     902             : /**                                                                **/
     903             : /**                           SCALAR MATRICES                      **/
     904             : /**                                                                **/
     905             : /********************************************************************/
     906             : 
     907             : GEN
     908        1841 : gen_matid(long n, void *E, const struct bb_field *S)
     909             : {
     910        1841 :   GEN y = cgetg(n+1,t_MAT), _0, _1;
     911             :   long i;
     912        1841 :   if (n < 0) pari_err_DOMAIN("gen_matid", "dimension","<",gen_0,stoi(n));
     913        1841 :   _0 = S->s(E,0);
     914        1841 :   _1 = S->s(E,1);
     915        7889 :   for (i=1; i<=n; i++)
     916             :   {
     917        6048 :     GEN z = const_col(n, _0); gel(z,i) = _1;
     918        6048 :     gel(y, i) = z;
     919             :   }
     920        1841 :   return y;
     921             : }
     922             : 
     923             : GEN
     924       12859 : matid_F2m(long n)
     925             : {
     926       12859 :   GEN y = cgetg(n+1,t_MAT);
     927             :   long i;
     928       12859 :   if (n < 0) pari_err_DOMAIN("matid_F2m", "dimension","<",gen_0,stoi(n));
     929       12859 :   for (i=1; i<=n; i++) { gel(y,i) = zero_F2v(n); F2v_set(gel(y,i),i); }
     930       12859 :   return y;
     931             : }
     932             : 
     933             : GEN
     934          35 : matid_F2xqM(long n, GEN T)
     935             : {
     936             :   void *E;
     937          35 :   const struct bb_field *S = get_F2xq_field(&E, T);
     938          35 :   return gen_matid(n, E, S);
     939             : }
     940             : GEN
     941        1806 : matid_FlxqM(long n, GEN T, ulong p)
     942             : {
     943             :   void *E;
     944        1806 :   const struct bb_field *S = get_Flxq_field(&E, T, p);
     945        1806 :   return gen_matid(n, E, S);
     946             : }
     947             : 
     948             : GEN
     949     1001310 : matid_Flm(long n)
     950             : {
     951     1001310 :   GEN y = cgetg(n+1,t_MAT);
     952             :   long i;
     953     1001310 :   if (n < 0) pari_err_DOMAIN("matid_Flm", "dimension","<",gen_0,stoi(n));
     954     1001310 :   for (i=1; i<=n; i++) { gel(y,i) = zero_zv(n); ucoeff(y, i,i) = 1; }
     955     1001310 :   return y;
     956             : }
     957             : 
     958             : GEN
     959          42 : scalar_Flm(long s, long n)
     960             : {
     961             :   long i;
     962          42 :   GEN y = cgetg(n+1,t_MAT);
     963          42 :   for (i=1; i<=n; i++) { gel(y,i) = zero_Flv(n); coeff(y, i,i) = s; }
     964          42 :   return y;
     965             : }
     966             : 
     967             : /********************************************************************/
     968             : /**                                                                **/
     969             : /**                           CONVERSIONS                          **/
     970             : /**                                                                **/
     971             : /********************************************************************/
     972             : GEN
     973    21515334 : ZV_to_Flv(GEN x, ulong p)
     974             : {
     975    21515334 :   long i, n = lg(x);
     976    21515334 :   GEN y = cgetg(n,t_VECSMALL);
     977    21515398 :   for (i=1; i<n; i++) y[i] = umodiu(gel(x,i), p);
     978    21515344 :   return y;
     979             : }
     980             : GEN
     981     3787721 : ZM_to_Flm(GEN x, ulong p)
     982             : {
     983     3787721 :   long j,n = lg(x);
     984     3787721 :   GEN y = cgetg(n,t_MAT);
     985     3787727 :   if (n == 1) return y;
     986     3787552 :   for (j=1; j<n; j++) gel(y,j) = ZV_to_Flv(gel(x,j), p);
     987     3787555 :   return y;
     988             : }
     989             : GEN
     990        1484 : ZMV_to_FlmV(GEN z, ulong m)
     991             : {
     992        1484 :   long i, l = lg(z);
     993        1484 :   GEN x = cgetg(l,t_VEC);
     994        1484 :   for (i=1; i<l; i++) gel(x,i) = ZM_to_Flm(gel(z,i), m);
     995        1484 :   return x;
     996             : }
     997             : 
     998             : /*                          TO INTMOD                        */
     999             : static GEN
    1000     7073623 : to_intmod(GEN x, GEN p) { retmkintmod(modii(x, p), p); }
    1001             : static GEN
    1002       27194 : Fl_to_intmod(ulong x, GEN p) { retmkintmod(utoi(x), p); }
    1003             : 
    1004             : GEN
    1005      291967 : Fp_to_mod(GEN z, GEN p)
    1006             : {
    1007      291967 :   retmkintmod(modii(z, p), icopy(p));
    1008             : }
    1009             : 
    1010             : /* z in Z[X], return z * Mod(1,p), normalized*/
    1011             : GEN
    1012      682162 : FpX_to_mod(GEN z, GEN p)
    1013             : {
    1014      682162 :   long i,l = lg(z);
    1015      682162 :   GEN x = cgetg(l,t_POL);
    1016      682162 :   if (l >2) p = icopy(p);
    1017      682162 :   for (i=2; i<l; i++) gel(x,i) = to_intmod(gel(z,i), p);
    1018      682162 :   x[1] = z[1]; return normalizepol_lg(x,l);
    1019             : }
    1020             : 
    1021             : /* z in Z^n, return z * Mod(1,p), normalized*/
    1022             : GEN
    1023        4403 : FpV_to_mod(GEN z, GEN p)
    1024             : {
    1025        4403 :   long i,l = lg(z);
    1026        4403 :   GEN x = cgetg(l, t_VEC);
    1027        4403 :   if (l == 1) return x;
    1028        4403 :   p = icopy(p);
    1029        4403 :   for (i=1; i<l; i++) gel(x,i) = to_intmod(gel(z,i), p);
    1030        4403 :   return x;
    1031             : }
    1032             : /* z in Z^n, return z * Mod(1,p), normalized*/
    1033             : GEN
    1034          63 : FpC_to_mod(GEN z, GEN p)
    1035             : {
    1036          63 :   long i, l = lg(z);
    1037          63 :   GEN x = cgetg(l, t_COL);
    1038          63 :   if (l == 1) return x;
    1039          63 :   p = icopy(p);
    1040          63 :   for (i=1; i<l; i++) gel(x,i) = to_intmod(gel(z,i), p);
    1041          63 :   return x;
    1042             : }
    1043             : /* z in Mat m,n(Z), return z * Mod(1,p), normalized*/
    1044             : GEN
    1045         100 : FpM_to_mod(GEN z, GEN p)
    1046             : {
    1047         100 :   long i, j, m, l = lg(z);
    1048         100 :   GEN  x = cgetg(l,t_MAT), y, zi;
    1049         100 :   if (l == 1) return x;
    1050          93 :   m = lgcols(z);
    1051          93 :   p = icopy(p);
    1052         790 :   for (i=1; i<l; i++)
    1053             :   {
    1054         697 :     gel(x,i) = cgetg(m,t_COL);
    1055         697 :     y = gel(x,i); zi= gel(z,i);
    1056         697 :     for (j=1; j<m; j++) gel(y,j) = to_intmod(gel(zi,j), p);
    1057             :   }
    1058          93 :   return x;
    1059             : }
    1060             : GEN
    1061          28 : Flc_to_mod(GEN z, ulong pp)
    1062             : {
    1063          28 :   long i, l = lg(z);
    1064          28 :   GEN p, x = cgetg(l, t_COL);
    1065          28 :   if (l == 1) return x;
    1066          28 :   p = utoipos(pp);
    1067          28 :   for (i=1; i<l; i++) gel(x,i) = Fl_to_intmod(z[i], p);
    1068          28 :   return x;
    1069             : }
    1070             : GEN
    1071         264 : Flm_to_mod(GEN z, ulong pp)
    1072             : {
    1073         264 :   long i, j, m, l = lg(z);
    1074         264 :   GEN p, x = cgetg(l,t_MAT), y, zi;
    1075         264 :   if (l == 1) return x;
    1076         236 :   m = lgcols(z);
    1077         236 :   p = utoipos(pp);
    1078        1961 :   for (i=1; i<l; i++)
    1079             :   {
    1080        1725 :     gel(x,i) = cgetg(m,t_COL);
    1081        1725 :     y = gel(x,i); zi= gel(z,i);
    1082        1725 :     for (j=1; j<m; j++) gel(y,j) = Fl_to_intmod(zi[j], p);
    1083             :   }
    1084         236 :   return x;
    1085             : }
    1086             : 
    1087             : GEN
    1088        1820 : FpVV_to_mod(GEN z, GEN p)
    1089             : {
    1090        1820 :   long i, j, m, l = lg(z);
    1091        1820 :   GEN  x = cgetg(l,t_VEC), y, zi;
    1092        1820 :   if (l == 1) return x;
    1093        1743 :   m = lgcols(z);
    1094        1743 :   p = icopy(p);
    1095        3647 :   for (i=1; i<l; i++)
    1096             :   {
    1097        1904 :     gel(x,i) = cgetg(m,t_VEC);
    1098        1904 :     y = gel(x,i); zi= gel(z,i);
    1099        1904 :     for (j=1; j<m; j++) gel(y,j) = to_intmod(gel(zi,j), p);
    1100             :   }
    1101        1743 :   return x;
    1102             : }
    1103             : 
    1104             : /* z in Z^n, return z * Mod(1,p), normalized*/
    1105             : GEN
    1106           7 : FpXQC_to_mod(GEN z, GEN T, GEN p)
    1107             : {
    1108           7 :   long i,l = lg(z);
    1109           7 :   GEN x = cgetg(l, t_COL);
    1110           7 :   if (l == 1) return x;
    1111           7 :   T = FpX_to_mod(T, p);
    1112          21 :   for (i=1; i<l; i++)
    1113          14 :     gel(x,i) = mkpolmod(FpX_to_mod(gel(z,i), p), T);
    1114           7 :   return x;
    1115             : }
    1116             : 
    1117             : /********************************************************************/
    1118             : /*                                                                  */
    1119             : /*                     Blackbox linear algebra                      */
    1120             : /*                                                                  */
    1121             : /********************************************************************/
    1122             : 
    1123             : /* A sparse column (zCs) v is a t_COL with two components C and E which are
    1124             :  * t_VECSMALL of the same length, representing sum_i E[i]*e_{C[i]}, where
    1125             :  * (e_j) is the canonical basis.
    1126             :  * A sparse matrix (zMs) is a t_VEC of zCs */
    1127             : 
    1128             : /* FpCs and FpMs are identical but E[i] is interpreted as a _signed_ C long
    1129             :  * integer representing an element of Fp. This is important since p can be
    1130             :  * large and p+E[i] would not fit in a C long.  */
    1131             : 
    1132             : /* RgCs and RgMs are similar, except that the type of the component is
    1133             :  * unspecified. Functions handling RgCs/RgMs must be independent of the type
    1134             :  * of E. */
    1135             : 
    1136             : /* Most functions take an argument nbrow which is the number of lines of the
    1137             :  * column/matrix, which cannot be derived from the data. */
    1138             : 
    1139             : GEN
    1140           0 : zCs_to_ZC(GEN R, long nbrow)
    1141             : {
    1142           0 :   GEN C = gel(R,1), E = gel(R,2), c = zerocol(nbrow);
    1143           0 :   long j, l = lg(C);
    1144           0 :   for (j = 1; j < l; ++j) gel(c, C[j]) = stoi(E[j]);
    1145           0 :   return c;
    1146             : }
    1147             : 
    1148             : GEN
    1149           0 : zMs_to_ZM(GEN M, long nbrow)
    1150             : {
    1151           0 :   long i, l = lg(M);
    1152           0 :   GEN m = cgetg(l, t_MAT);
    1153           0 :   for (i = 1; i < l; ++i) gel(m,i) = zCs_to_ZC(gel(M,i), nbrow);
    1154           0 :   return m;
    1155             : }
    1156             : 
    1157             : /* Solve equation f(X) = B (mod p) where B is a FpV, and f is an endomorphism.
    1158             :  * Return either a solution as a t_COL, or a kernel vector as a t_VEC. */
    1159             : GEN
    1160         119 : gen_FpM_Wiedemann(void *E, GEN (*f)(void*, GEN), GEN B, GEN p)
    1161             : {
    1162         119 :   pari_sp ltop = avma;
    1163         119 :   long col = 0, n = lg(B)-1, m = 2*n+1;
    1164         119 :   if (ZV_equal0(B)) return zerocol(n);
    1165         238 :   while (++col <= n)
    1166             :   {
    1167         119 :     pari_sp btop = avma, av;
    1168             :     long i, lQ;
    1169         119 :     GEN V, Q, M, W = B;
    1170         119 :     GEN b = cgetg(m+2, t_POL);
    1171         119 :     b[1] = evalsigne(1)|evalvarn(0);
    1172         119 :     gel(b, 2) = gel(W, col);
    1173       50563 :     for (i = 3; i<m+2; i++)
    1174       50444 :       gel(b, i) = cgeti(lgefint(p));
    1175         119 :     av = avma;
    1176       50563 :     for (i = 3; i<m+2; i++)
    1177             :     {
    1178       50444 :       W = f(E, W);
    1179       50444 :       affii(gel(W, col),gel(b, i));
    1180       50444 :       if (gc_needed(av,1))
    1181             :       {
    1182        2000 :         if (DEBUGMEM>1) pari_warn(warnmem,"Wiedemann: first loop, %ld",i);
    1183        2000 :         W = gerepileupto(av, W);
    1184             :       }
    1185             :     }
    1186         119 :     b = FpX_renormalize(b, m+2);
    1187         119 :     if (lgpol(b)==0) {avma = btop; continue; }
    1188         119 :     M = FpX_halfgcd(b, pol_xn(m, 0), p);
    1189         119 :     Q = FpX_neg(FpX_normalize(gcoeff(M, 2, 1),p),p);
    1190         119 :     W = B; lQ =lg(Q);
    1191         119 :     if (DEBUGLEVEL) err_printf("Wiedemann: deg. minpoly: %ld\n",lQ-3);
    1192         119 :     V = FpC_Fp_mul(W, gel(Q, lQ-2), p);
    1193         119 :     av = avma;
    1194       24809 :     for (i = lQ-3; i > 1; i--)
    1195             :     {
    1196       24690 :       W = f(E, W);
    1197       24690 :       V = ZC_lincomb(gen_1, gel(Q,i), V, W);
    1198       24690 :       if (gc_needed(av,1))
    1199             :       {
    1200        1582 :         if (DEBUGMEM>1) pari_warn(warnmem,"Wiedemann: second loop, %ld",i);
    1201        1582 :         gerepileall(av, 2, &V, &W);
    1202             :       }
    1203             :     }
    1204         119 :     V = FpC_red(V, p);
    1205         119 :     W = FpC_sub(f(E,V), B, p);
    1206         238 :     if (ZV_equal0(W)) return gerepilecopy(ltop, V);
    1207           0 :     av = avma;
    1208           0 :     for (i = 1; i <= n; ++i)
    1209             :     {
    1210           0 :       V = W;
    1211           0 :       W = f(E, V);
    1212           0 :       if (ZV_equal0(W))
    1213           0 :         return gerepilecopy(ltop, shallowtrans(V));
    1214           0 :       gerepileall(av, 2, &V, &W);
    1215             :     }
    1216           0 :     avma = btop;
    1217             :   }
    1218           0 :   return NULL;
    1219             : }
    1220             : 
    1221             : GEN
    1222           0 : zMs_ZC_mul(GEN M, GEN B)
    1223             : {
    1224             :   long i, j;
    1225           0 :   long n = lg(B)-1;
    1226           0 :   GEN V = zerocol(n);
    1227           0 :   for (i = 1; i <= n; ++i)
    1228           0 :     if (signe(gel(B, i)))
    1229             :     {
    1230           0 :       GEN R = gel(M, i), C = gel(R, 1), E = gel(R, 2);
    1231           0 :       long l = lg(C);
    1232           0 :       for (j = 1; j < l; ++j)
    1233             :       {
    1234           0 :         long k = C[j];
    1235           0 :         switch(E[j])
    1236             :         {
    1237             :         case 1:
    1238           0 :           gel(V, k) = gel(V,k)==gen_0 ? gel(B,i) : addii(gel(V, k), gel(B,i));
    1239           0 :           break;
    1240             :         case -1:
    1241           0 :           gel(V, k) = gel(V,k)==gen_0 ? negi(gel(B,i)) : subii(gel(V, k), gel(B,i));
    1242           0 :           break;
    1243             :         default:
    1244           0 :           gel(V, k) = gel(V,k)==gen_0 ? mulis(gel(B, i), E[j]) : addii(gel(V, k), mulis(gel(B, i), E[j]));
    1245           0 :           break;
    1246             :         }
    1247             :       }
    1248             :     }
    1249           0 :   return V;
    1250             : }
    1251             : 
    1252             : GEN
    1253           0 : FpMs_FpC_mul(GEN M, GEN B, GEN p) { return FpC_red(zMs_ZC_mul(M, B), p); }
    1254             : 
    1255             : GEN
    1256       75372 : ZV_zMs_mul(GEN B, GEN M)
    1257             : {
    1258             :   long i, j;
    1259       75372 :   long m = lg(M)-1;
    1260       75372 :   GEN V = cgetg(m+1,t_VEC);
    1261    39260362 :   for (i = 1; i <= m; ++i)
    1262             :   {
    1263    39184990 :     GEN R = gel(M, i), C = gel(R, 1), E = gel(R, 2);
    1264    39184990 :     long l = lg(C);
    1265    39184990 :     GEN z = mulis(gel(B, C[1]), E[1]);
    1266   329579640 :     for (j = 2; j < l; ++j)
    1267             :     {
    1268   290394650 :       long k = C[j];
    1269   290394650 :       switch(E[j])
    1270             :       {
    1271             :       case 1:
    1272   196103761 :         z = addii(z, gel(B,k));
    1273   196103761 :         break;
    1274             :       case -1:
    1275    79099731 :         z = subii(z, gel(B,k));
    1276    79099731 :         break;
    1277             :       default:
    1278    15191158 :         z = addii(z, mulis(gel(B,k), E[j]));
    1279    15191158 :         break;
    1280             :       }
    1281             :     }
    1282    39184990 :     gel(V,i) = z;
    1283             :   }
    1284       75372 :   return V;
    1285             : }
    1286             : 
    1287             : GEN
    1288         119 : FpV_FpMs_mul(GEN B, GEN M, GEN p) { return FpV_red(ZV_zMs_mul(B, M), p); }
    1289             : 
    1290             : GEN
    1291      514620 : ZlM_gauss(GEN a, GEN b, ulong p, long e, GEN C)
    1292             : {
    1293      514620 :   pari_sp av = avma, av2;
    1294      514620 :   GEN xi, xb, pi = gen_1, P;
    1295             :   long i;
    1296      514620 :   if (!C) {
    1297           0 :     C = Flm_inv(ZM_to_Flm(a, p), p);
    1298           0 :     if (!C) pari_err_INV("ZlM_gauss", a);
    1299             :   }
    1300      514620 :   P = utoipos(p);
    1301      514620 :   av2 = avma;
    1302      514620 :   xi = Flm_mul(C, ZM_to_Flm(b, p), p);
    1303      514620 :   xb = Flm_to_ZM(xi);
    1304     1149115 :   for (i = 2; i <= e; i++)
    1305             :   {
    1306      634495 :     pi = muliu(pi, p); /* = p^(i-1) */
    1307      634495 :     b = ZM_Z_divexact(ZM_sub(b, ZM_nm_mul(a, xi)), P);
    1308      634495 :     if (gc_needed(av,2))
    1309             :     {
    1310          31 :       if(DEBUGMEM>1) pari_warn(warnmem,"ZlM_gauss. i=%ld",i);
    1311          31 :       gerepileall(av2,3, &pi,&b,&xb);
    1312             :     }
    1313      634495 :     xi = Flm_mul(C, ZM_to_Flm(b, p), p);
    1314      634495 :     xb = ZM_add(xb, nm_Z_mul(xi, pi));
    1315             :   }
    1316      514620 :   return gerepileupto(av, xb);
    1317             : }
    1318             : 
    1319             : struct wrapper_modp_s {
    1320             :   GEN (*f)(void*, GEN);
    1321             :   void *E;
    1322             :   GEN p;
    1323             : };
    1324             : 
    1325             : /* compute f(x) mod p */
    1326             : static GEN
    1327       75253 : wrap_relcomb_modp(void *E, GEN x)
    1328             : {
    1329       75253 :   struct wrapper_modp_s *W = (struct wrapper_modp_s*)E;
    1330       75253 :   return FpC_red(W->f(W->E, x), W->p);
    1331             : }
    1332             : static GEN
    1333           0 : wrap_relcomb(void*E, GEN x) { return zMs_ZC_mul((GEN)E, x); }
    1334             : 
    1335             : static GEN
    1336       75253 : wrap_relker(void*E, GEN x) { return ZV_zMs_mul(x, (GEN)E); }
    1337             : 
    1338             : /* Solve f(X) = B (mod p^e); blackbox version of ZlM_gauss */
    1339             : GEN
    1340           0 : gen_ZpM_Dixon(void *E, GEN (*f)(void*, GEN), GEN B, GEN p, long e)
    1341             : {
    1342             :   struct wrapper_modp_s W;
    1343           0 :   pari_sp av = avma;
    1344           0 :   GEN xb, xi, pi = gen_1;
    1345             :   long i;
    1346           0 :   W.E = E;
    1347           0 :   W.f = f;
    1348           0 :   W.p = p;
    1349           0 :   xi = gen_FpM_Wiedemann((void*)&W, wrap_relcomb_modp, FpC_red(B, p), p); /* f^(-1) B */
    1350           0 :   if (!xi || e == 1 || typ(xi) == t_VEC) return xi;
    1351           0 :   xb = xi;
    1352           0 :   for (i = 2; i <= e; i++)
    1353             :   {
    1354           0 :     pi = mulii(pi, p); /* = p^(i-1) */
    1355           0 :     B = ZC_Z_divexact(ZC_sub(B, f(E, xi)), p);
    1356           0 :     if (gc_needed(av,2))
    1357             :     {
    1358           0 :       if(DEBUGMEM>1) pari_warn(warnmem,"gen_ZpM_Dixon. i=%ld",i);
    1359           0 :       gerepileall(av,3, &pi,&B,&xb);
    1360             :     }
    1361           0 :     xi = gen_FpM_Wiedemann((void*)&W, wrap_relcomb_modp, FpC_red(B, p), p);
    1362           0 :     if (!xi) return NULL;
    1363           0 :     if (typ(xi) == t_VEC) return gerepileupto(av, xi);
    1364           0 :     xb = ZC_add(xb, ZC_Z_mul(xi, pi));
    1365             :   }
    1366           0 :   return gerepileupto(av, xb);
    1367             : }
    1368             : 
    1369             : static GEN
    1370       25222 : vecprow(GEN A, GEN prow)
    1371             : {
    1372       25222 :   return mkvec2(vecsmallpermute(prow,gel(A,1)), gel(A,2));
    1373             : }
    1374             : 
    1375             : /* Solve the equation MX = A. Return either a solution as a t_COL,
    1376             :  * or the index of a column which is linearly dependent from the others as a
    1377             :  * t_VECSMALL with a single component. */
    1378             : GEN
    1379           0 : ZpMs_ZpCs_solve(GEN M, GEN A, long nbrow, GEN p, long e)
    1380             : {
    1381           0 :   pari_sp av = avma;
    1382             :   GEN pcol, prow;
    1383           0 :   long nbi=lg(M)-1, lR;
    1384             :   long i, n;
    1385             :   GEN Mp, Ap, Rp;
    1386             :   pari_timer ti;
    1387           0 :   if (DEBUGLEVEL) timer_start(&ti);
    1388           0 :   RgMs_structelim(M, nbrow, gel(A, 1), &pcol, &prow);
    1389           0 :   if (!pcol) { avma = av; return NULL; }
    1390           0 :   if (DEBUGLEVEL)
    1391           0 :     timer_printf(&ti,"structured elimination (%ld -> %ld)",nbi,lg(pcol)-1);
    1392           0 :   n = lg(pcol)-1;
    1393           0 :   Mp = cgetg(n+1, t_MAT);
    1394           0 :   for(i=1; i<=n; i++)
    1395           0 :     gel(Mp, i) = vecprow(gel(M,pcol[i]), prow);
    1396           0 :   Ap = zCs_to_ZC(vecprow(A, prow), n);
    1397           0 :   if (DEBUGLEVEL) timer_start(&ti);
    1398           0 :   Rp = gen_ZpM_Dixon((void*)Mp,wrap_relcomb, Ap, p, e);
    1399           0 :   if (DEBUGLEVEL) timer_printf(&ti,"linear algebra");
    1400           0 :   if (!Rp) { avma = av; return NULL; }
    1401           0 :   lR = lg(Rp)-1;
    1402           0 :   if (typ(Rp) == t_COL)
    1403             :   {
    1404           0 :     GEN R = zerocol(nbi+1);
    1405           0 :     for (i=1; i<=lR; i++)
    1406           0 :        gel(R,pcol[i]) = gel(Rp,i);
    1407           0 :     return gerepilecopy(av, R);
    1408             :   }
    1409           0 :   for (i = 1; i <= lR; ++i)
    1410           0 :     if (signe(gel(Rp, i)))
    1411           0 :       return gerepileuptoleaf(av, mkvecsmall(pcol[i]));
    1412             :   return NULL; /* LCOV_EXCL_LINE */
    1413             : }
    1414             : 
    1415             : GEN
    1416           0 : FpMs_FpCs_solve(GEN M, GEN A, long nbrow, GEN p)
    1417             : {
    1418           0 :   return ZpMs_ZpCs_solve(M, A, nbrow, p, 1);
    1419             : }
    1420             : 
    1421             : GEN
    1422           0 : FpMs_FpCs_solve_safe(GEN M, GEN A, long nbrow, GEN p)
    1423             : {
    1424             :   GEN res;
    1425           0 :   pari_CATCH(e_INV)
    1426             :   {
    1427           0 :     GEN E = pari_err_last();
    1428           0 :     GEN x = err_get_compo(E,2);
    1429           0 :     if (typ(x) != t_INTMOD) pari_err(0,E);
    1430           0 :     if (DEBUGLEVEL)
    1431           0 :       pari_warn(warner,"FpMs_FpCs_solve_safe, impossible inverse %Ps", x);
    1432           0 :     res = NULL;
    1433             :   } pari_TRY {
    1434           0 :     res = ZpMs_ZpCs_solve(M, A, nbrow, p, 1);
    1435           0 :   } pari_ENDCATCH
    1436           0 :   return res;
    1437             : }
    1438             : 
    1439             : static GEN
    1440         119 : FpMs_structelim_back(GEN M, GEN V, GEN prow, GEN p)
    1441             : {
    1442         119 :   long i, j, oldf = 0, f = 0;
    1443         119 :   long lrow = lg(prow), lM = lg(M);
    1444         119 :   GEN W = const_vecsmall(lM-1,1);
    1445         119 :   GEN R = cgetg(lrow, t_VEC);
    1446      221956 :   for (i=1; i<lrow; i++)
    1447      221837 :     gel(R,i) = prow[i]==0 ? NULL: gel(V,prow[i]);
    1448             :   do
    1449             :   {
    1450         386 :     oldf = f;
    1451      437057 :     for(i=1; i<lM; i++)
    1452      436671 :       if (W[i])
    1453             :       {
    1454      148592 :         GEN C = gel(M,i), F = gel(C,1), E = gel(C,2);
    1455      148592 :         long c=0, cj=0, lF = lg(F);
    1456     1301527 :         for(j=1; j<lF; j++)
    1457     1152935 :           if (!gel(R,F[j]))
    1458       86632 :           { c++; cj=j; }
    1459      148592 :         if (c>=2) continue;
    1460      127901 :         if (c==1)
    1461             :         {
    1462       40914 :           pari_sp av = avma;
    1463       40914 :           GEN s = gen_0;
    1464      356364 :           for(j=1; j<lF; j++)
    1465      315450 :             if (j!=cj) s = Fp_add(s, mulis(gel(R,F[j]), E[j]), p);
    1466       40914 :           gel(R,F[cj]) = gerepileupto(av, Fp_div(Fp_neg(s, p), stoi(E[cj]), p));
    1467       40914 :           f++;
    1468             :         }
    1469      127901 :         W[i]=0;
    1470             :       }
    1471         386 :   } while(oldf!=f);
    1472      221956 :   for (i=1; i<lrow; i++)
    1473      221837 :     if (!gel(R,i)) gel(R,i) = gen_0;
    1474         119 :   return R;
    1475             : }
    1476             : 
    1477             : /* Return a linear form Y such that YM is essentially 0 */
    1478             : GEN
    1479         119 : FpMs_leftkernel_elt_col(GEN M, long nbcol, long nbrow, GEN p)
    1480             : {
    1481         119 :   pari_sp av = avma, av2;
    1482             :   GEN pcol, prow;
    1483             :   long i, n;
    1484             :   GEN Mp, B, MB, R, Rp;
    1485             :   pari_timer ti;
    1486             :   struct wrapper_modp_s W;
    1487         119 :   if (DEBUGLEVEL) timer_start(&ti);
    1488         119 :   RgMs_structelim_col(M, nbcol, nbrow, cgetg(1,t_VECSMALL), &pcol, &prow);
    1489         119 :   if (!pcol) { avma = av; return NULL; }
    1490         119 :   if (DEBUGLEVEL)
    1491           0 :     timer_printf(&ti,"structured elimination (%ld -> %ld)",nbcol,lg(pcol)-1);
    1492         119 :   n = lg(pcol)-1;
    1493         119 :   Mp = cgetg(n+1, t_MAT);
    1494       25341 :   for(i=1; i<=n; i++)
    1495       25222 :     gel(Mp, i) = vecprow(gel(M,pcol[i]), prow);
    1496         119 :   W.E = (void*) Mp;
    1497         119 :   W.f = wrap_relker;
    1498         119 :   W.p = p;
    1499         119 :   av2 = avma;
    1500             :   for(;;)
    1501             :   {
    1502         119 :     avma = av2;
    1503         119 :     B = cgetg(n+1,t_VEC);
    1504       25341 :     for(i=1; i<=n; i++)
    1505       25222 :       gel(B,i) = randomi(p);
    1506         119 :     MB = FpV_FpMs_mul(B, Mp, p);
    1507         119 :     if (DEBUGLEVEL) timer_start(&ti);
    1508         119 :     pari_CATCH(e_INV)
    1509             :     {
    1510           0 :       GEN E = pari_err_last();
    1511           0 :       GEN x = err_get_compo(E,2);
    1512           0 :       if (typ(x) != t_INTMOD) pari_err(0,E);
    1513           0 :       if (DEBUGLEVEL)
    1514           0 :         pari_warn(warner,"FpMs_leftkernel_elt, impossible inverse %Ps", x);
    1515           0 :       Rp = NULL;
    1516             :     } pari_TRY {
    1517         119 :       Rp = gen_FpM_Wiedemann((void*)&W, wrap_relcomb_modp, MB, p);
    1518         119 :     } pari_ENDCATCH
    1519         119 :     if (!Rp) continue;
    1520         119 :     if (typ(Rp)==t_COL)
    1521             :     {
    1522         119 :       Rp = FpC_sub(Rp,B,p);
    1523         119 :       if (ZV_equal0(Rp)) continue;
    1524             :     }
    1525         119 :     R = FpMs_structelim_back(M, Rp, prow, p);
    1526         119 :     if (DEBUGLEVEL) timer_printf(&ti,"Wiedemann left kernel");
    1527         119 :     return gerepilecopy(av, R);
    1528           0 :   }
    1529             : }
    1530             : 
    1531             : GEN
    1532          35 : FpMs_leftkernel_elt(GEN M, long nbrow, GEN p)
    1533             : {
    1534          35 :   return FpMs_leftkernel_elt_col(M, lg(M)-1, nbrow, p);
    1535             : }

Generated by: LCOV version 1.11