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-bordeaux1.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 - ZX.c (source / functions) Hit Total Coverage
Test: PARI/GP v2.8.0 lcov report (development 17961-e5c317c) Lines: 432 458 94.3 %
Date: 2015-09-04 Functions: 54 57 94.7 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 278 315 88.3 %

           Branch data     Line data    Source code
       1                 :            : /* Copyright (C) 2007  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                 :            : /*                                ZX                               */
      20                 :            : /*                                                                 */
      21                 :            : /*******************************************************************/
      22                 :            : void
      23                 :          0 : RgX_check_QX(GEN x, const char *s)
      24         [ #  # ]:          0 : { if (!RgX_is_QX(x)) pari_err_TYPE(stack_strcat(s," [not in Q[X]]"), x); }
      25                 :            : void
      26                 :      15651 : RgX_check_ZX(GEN x, const char *s)
      27         [ -  + ]:      15651 : { if (!RgX_is_ZX(x)) pari_err_TYPE(stack_strcat(s," [not in Z[X]]"), x); }
      28                 :            : long
      29                 :       5369 : ZX_max_lg(GEN x)
      30                 :            : {
      31                 :       5369 :   long i, prec = 0, lx = lg(x);
      32                 :            : 
      33 [ +  + ][ +  + ]:      42609 :   for (i=2; i<lx; i++) { long l = lgefint(gel(x,i)); if (l > prec) prec = l; }
      34                 :       5369 :   return prec;
      35                 :            : }
      36                 :            : 
      37                 :            : GEN
      38                 :    7481389 : ZX_add(GEN x, GEN y)
      39                 :            : {
      40                 :            :   long lx,ly,i;
      41                 :            :   GEN z;
      42         [ +  + ]:    7481389 :   lx = lg(x); ly = lg(y); if (lx < ly) swapspec(x,y, lx,ly);
      43                 :    7481389 :   z = cgetg(lx,t_POL); z[1] = x[1];
      44         [ +  + ]:   64098121 :   for (i=2; i<ly; i++) gel(z,i) = addii(gel(x,i),gel(y,i));
      45         [ +  + ]:   27125391 :   for (   ; i<lx; i++) gel(z,i) = icopy(gel(x,i));
      46         [ +  + ]:    7481387 :   if (lx == ly) z = ZX_renormalize(z, lx);
      47         [ +  + ]:    7481387 :   if (!lgpol(z)) { avma = (pari_sp)(z + lx); return pol_0(varn(x)); }
      48                 :    7481390 :   return z;
      49                 :            : }
      50                 :            : 
      51                 :            : GEN
      52                 :     319933 : ZX_sub(GEN x,GEN y)
      53                 :            : {
      54                 :     319933 :   long i, lx = lg(x), ly = lg(y);
      55                 :            :   GEN z;
      56         [ +  + ]:     319933 :   if (lx >= ly)
      57                 :            :   {
      58                 :     309830 :     z = cgetg(lx,t_POL); z[1] = x[1];
      59         [ +  + ]:    4436184 :     for (i=2; i<ly; i++) gel(z,i) = subii(gel(x,i),gel(y,i));
      60         [ +  + ]:     309831 :     if (lx == ly)
      61                 :            :     {
      62                 :     287270 :       z = ZX_renormalize(z, lx);
      63         [ +  + ]:     287270 :       if (!lgpol(z)) { avma = (pari_sp)(z + lx); z = pol_0(varn(x)); }
      64                 :            :     }
      65                 :            :     else
      66         [ +  + ]:     627669 :       for (   ; i<lx; i++) gel(z,i) = icopy(gel(x,i));
      67                 :            :   }
      68                 :            :   else
      69                 :            :   {
      70                 :      10103 :     z = cgetg(ly,t_POL); z[1] = y[1];
      71         [ +  + ]:      44689 :     for (i=2; i<lx; i++) gel(z,i) = subii(gel(x,i),gel(y,i));
      72         [ +  + ]:      20976 :     for (   ; i<ly; i++) gel(z,i) = negi(gel(y,i));
      73                 :            :   }
      74                 :     319934 :   return z;
      75                 :            : }
      76                 :            : 
      77                 :            : GEN
      78                 :       3594 : ZX_neg(GEN x)
      79                 :            : {
      80                 :       3594 :   long i, l = lg(x);
      81                 :       3594 :   GEN y = cgetg(l,t_POL);
      82         [ +  + ]:      42416 :   y[1] = x[1]; for(i=2; i<l; i++) gel(y,i) = negi(gel(x,i));
      83                 :       3594 :   return y;
      84                 :            : }
      85                 :            : GEN
      86                 :     100625 : ZX_copy(GEN x)
      87                 :            : {
      88                 :     100625 :   long i, l = lg(x);
      89                 :     100625 :   GEN y = cgetg(l, t_POL);
      90                 :     100625 :   y[1] = x[1];
      91         [ +  + ]:     790066 :   for (i=2; i<l; i++)
      92                 :            :   {
      93                 :     689441 :     GEN c = gel(x,i);
      94         [ +  + ]:     689441 :     gel(y,i) = lgefint(c) == 2? gen_0: icopy(c);
      95                 :            :   }
      96                 :     100625 :   return y;
      97                 :            : }
      98                 :            : 
      99                 :            : GEN
     100                 :      20432 : scalar_ZX(GEN x, long v)
     101                 :            : {
     102                 :            :   GEN z;
     103         [ +  + ]:      20432 :   if (!signe(x)) return pol_0(v);
     104                 :       2409 :   z = cgetg(3, t_POL);
     105                 :       2409 :   z[1] = evalsigne(1) | evalvarn(v);
     106                 :      20432 :   gel(z,2) = icopy(x); return z;
     107                 :            : }
     108                 :            : 
     109                 :            : GEN
     110                 :      19300 : scalar_ZX_shallow(GEN x, long v)
     111                 :            : {
     112                 :            :   GEN z;
     113         [ +  + ]:      19300 :   if (!signe(x)) return pol_0(v);
     114                 :      19181 :   z = cgetg(3, t_POL);
     115                 :      19181 :   z[1] = evalsigne(1) | evalvarn(v);
     116                 :      19300 :   gel(z,2) = x; return z;
     117                 :            : }
     118                 :            : 
     119                 :            : GEN
     120                 :      65845 : ZX_Z_add(GEN y, GEN x)
     121                 :            : {
     122                 :            :   long lz, i;
     123                 :      65845 :   GEN z = cgetg_copy(y, &lz);
     124         [ +  + ]:      65845 :   if (lz == 2) { avma = (pari_sp)(z + 2); return scalar_ZX(x,varn(y)); }
     125                 :      65791 :   z[1] = y[1];
     126                 :      65791 :   gel(z,2) = addii(gel(y,2),x);
     127         [ +  + ]:    1100819 :   for(i=3; i<lz; i++) gel(z,i) = icopy(gel(y,i));
     128         [ +  + ]:      65791 :   if (lz==3) z = ZX_renormalize(z,lz);
     129                 :      65845 :   return z;
     130                 :            : }
     131                 :            : GEN
     132                 :       9063 : ZX_Z_add_shallow(GEN y, GEN x)
     133                 :            : {
     134                 :            :   long lz, i;
     135                 :       9063 :   GEN z = cgetg_copy(y, &lz);
     136         [ +  + ]:       9063 :   if (lz == 2) { avma = (pari_sp)(z + 2); return scalar_ZX_shallow(x,varn(y)); }
     137                 :       8930 :   z[1] = y[1];
     138                 :       8930 :   gel(z,2) = addii(gel(y,2),x);
     139         [ +  + ]:     100110 :   for(i=3; i<lz; i++) gel(z,i) = gel(y,i);
     140         [ +  + ]:       8930 :   if (lz==3) z = ZX_renormalize(z,lz);
     141                 :       9063 :   return z;
     142                 :            : }
     143                 :            : 
     144                 :            : GEN
     145                 :      34132 : ZX_Z_sub(GEN y, GEN x)
     146                 :            : {
     147                 :            :   long lz, i;
     148                 :      34132 :   GEN z = cgetg_copy(y, &lz);
     149         [ -  + ]:      34132 :   if (lz == 2)
     150                 :            :   { /* scalarpol(negi(x), v) */
     151                 :          0 :     long v = varn(y);
     152                 :          0 :     avma = (pari_sp)(z + 2);
     153         [ #  # ]:          0 :     if (!signe(x)) return pol_0(v);
     154                 :          0 :     z = cgetg(3,t_POL);
     155                 :          0 :     z[1] = evalvarn(v) | evalsigne(1);
     156                 :          0 :     gel(z,2) = negi(x); return z;
     157                 :            :   }
     158                 :      34132 :   z[1] = y[1];
     159                 :      34132 :   gel(z,2) = subii(gel(y,2),x);
     160         [ +  + ]:     180334 :   for(i=3; i<lz; i++) gel(z,i) = icopy(gel(y,i));
     161         [ -  + ]:      34132 :   if (lz==3) z = ZX_renormalize(z,lz);
     162                 :      34132 :   return z;
     163                 :            : }
     164                 :            : 
     165                 :            : GEN
     166                 :     303014 : Z_ZX_sub(GEN x, GEN y)
     167                 :            : {
     168                 :            :   long lz, i;
     169                 :     303014 :   GEN z = cgetg_copy(y, &lz);
     170         [ -  + ]:     303014 :   if (lz == 2) { avma = (pari_sp)(z + 2); return scalar_ZX(x,varn(y)); }
     171                 :     303014 :   z[1] = y[1];
     172                 :     303014 :   gel(z,2) = subii(x, gel(y,2));
     173         [ +  + ]:    2900910 :   for(i=3; i<lz; i++) gel(z,i) = negi(gel(y,i));
     174         [ -  + ]:     303014 :   if (lz==3) z = ZX_renormalize(z,lz);
     175                 :     303014 :   return z;
     176                 :            : }
     177                 :            : 
     178                 :            : GEN
     179                 :    2085389 : ZX_Z_divexact(GEN y,GEN x)
     180                 :            : {
     181                 :    2085389 :   long i, l = lg(y);
     182                 :    2085389 :   GEN z = cgetg(l,t_POL); z[1] = y[1];
     183         [ +  + ]:   17289603 :   for(i=2; i<l; i++) gel(z,i) = diviiexact(gel(y,i),x);
     184                 :    2085390 :   return z;
     185                 :            : }
     186                 :            : 
     187                 :            : GEN
     188                 :    6828663 : ZX_Z_mul(GEN y,GEN x)
     189                 :            : {
     190                 :            :   GEN z;
     191                 :            :   long i, l;
     192         [ +  + ]:    6828663 :   if (!signe(x)) return pol_0(varn(y));
     193                 :    4379159 :   l = lg(y); z = cgetg(l,t_POL); z[1] = y[1];
     194         [ +  + ]:   52146395 :   for(i=2; i<l; i++) gel(z,i) = mulii(gel(y,i),x);
     195                 :    6828663 :   return z;
     196                 :            : }
     197                 :            : 
     198                 :            : GEN
     199                 :     118510 : ZX_mulu(GEN y, ulong x)
     200                 :            : {
     201                 :            :   GEN z;
     202                 :            :   long i, l;
     203         [ -  + ]:     118510 :   if (!x) return pol_0(varn(y));
     204                 :     118510 :   l = lg(y); z = cgetg(l,t_POL); z[1] = y[1];
     205         [ +  + ]:     675787 :   for(i=2; i<l; i++) gel(z,i) = mului(x,gel(y,i));
     206                 :     118510 :   return z;
     207                 :            : }
     208                 :            : 
     209                 :            : GEN
     210                 :     176123 : ZX_shifti(GEN y, long n)
     211                 :            : {
     212                 :            :   GEN z;
     213                 :            :   long i, l;
     214                 :     176123 :   l = lg(y); z = cgetg(l,t_POL); z[1] = y[1];
     215         [ +  + ]:    2549280 :   for(i=2; i<l; i++) gel(z,i) = shifti(gel(y,i),n);
     216                 :     176116 :   return ZX_renormalize(z,l);
     217                 :            : }
     218                 :            : 
     219                 :            : GEN
     220                 :      92985 : ZX_remi2n(GEN y, long n)
     221                 :            : {
     222                 :            :   GEN z;
     223                 :            :   long i, l;
     224                 :      92985 :   l = lg(y); z = cgetg(l,t_POL); z[1] = y[1];
     225         [ +  + ]:    2774930 :   for(i=2; i<l; i++) gel(z,i) = remi2n(gel(y,i),n);
     226                 :      92971 :   return ZX_renormalize(z,l);
     227                 :            : }
     228                 :            : 
     229                 :            : GEN
     230                 :      35728 : ZXT_remi2n(GEN z, long n)
     231                 :            : {
     232         [ +  + ]:      35728 :   if (typ(z) == t_POL)
     233                 :      32888 :     return ZX_remi2n(z, n);
     234                 :            :   else
     235                 :            :   {
     236                 :       2840 :     long i,l = lg(z);
     237                 :       2840 :     GEN x = cgetg(l, t_VEC);
     238         [ +  + ]:       8527 :     for (i=1; i<l; i++) gel(x,i) = ZXT_remi2n(gel(z,i), n);
     239                 :      35728 :     return x;
     240                 :            :   }
     241                 :            : }
     242                 :            : 
     243                 :            : GEN
     244                 :         91 : zx_to_ZX(GEN z)
     245                 :            : {
     246                 :         91 :   long i, l = lg(z);
     247                 :         91 :   GEN x = cgetg(l,t_POL);
     248         [ +  + ]:        546 :   for (i=2; i<l; i++) gel(x,i) = stoi(z[i]);
     249         [ +  - ]:         91 :   x[1] = evalsigne(l-2!=0)| z[1]; return x;
     250                 :            : }
     251                 :            : 
     252                 :            : GEN
     253                 :    1696854 : ZX_deriv(GEN x)
     254                 :            : {
     255                 :    1696854 :   long i,lx = lg(x)-1;
     256                 :            :   GEN y;
     257                 :            : 
     258         [ +  + ]:    1696854 :   if (lx<3) return pol_0(varn(x));
     259                 :    1696089 :   y = cgetg(lx,t_POL);
     260         [ +  + ]:   13182256 :   for (i=2; i<lx ; i++) gel(y,i) = mului(i-1,gel(x,i+1));
     261                 :    1696854 :   y[1] = x[1]; return y;
     262                 :            : }
     263                 :            : 
     264                 :            : int
     265                 :     193656 : ZX_equal(GEN V, GEN W)
     266                 :            : {
     267                 :     193656 :   long i, l = lg(V);
     268         [ +  + ]:     193656 :   if (lg(W) != l) return 0;
     269         [ +  + ]:     584891 :   for (i = 2; i < l; i++)
     270         [ +  + ]:     543669 :     if (!equalii(gel(V,i), gel(W,i))) return 0;
     271                 :     193656 :   return 1;
     272                 :            : }
     273                 :            : 
     274                 :            : static long
     275                 :  160783560 : ZX_valspec(GEN x, long nx)
     276                 :            : {
     277                 :            :   long vx;
     278         [ +  + ]:  217814780 :   for (vx = 0; vx<nx ; vx++)
     279         [ +  + ]:  217814767 :     if (signe(gel(x,vx))) break;
     280                 :  160783560 :   return vx;
     281                 :            : }
     282                 :            : 
     283                 :            : long
     284                 :      15543 : ZX_val(GEN x)
     285                 :            : {
     286                 :            :   long vx;
     287         [ -  + ]:      15543 :   if (!signe(x)) return LONG_MAX;
     288                 :      15543 :   for (vx = 0;; vx++)
     289         [ +  + ]:      16915 :     if (signe(gel(x,2+vx))) break;
     290                 :      16915 :   return vx;
     291                 :            : }
     292                 :            : long
     293                 :    8600434 : ZX_valrem(GEN x, GEN *Z)
     294                 :            : {
     295                 :            :   long vx;
     296         [ -  + ]:    8600434 :   if (!signe(x)) { *Z = pol_0(varn(x)); return LONG_MAX; }
     297                 :    8600434 :   for (vx = 0;; vx++)
     298         [ +  + ]:   15914163 :     if (signe(gel(x,2+vx))) break;
     299                 :   15914163 :   *Z = RgX_shift_shallow(x, -vx);
     300                 :    8600434 :   return vx;
     301                 :            : }
     302                 :            : 
     303                 :            : GEN
     304                 :         21 : ZX_div_by_X_1(GEN a, GEN *r)
     305                 :            : {
     306                 :         21 :   long l = lg(a), i;
     307                 :         21 :   GEN a0, z0, z = cgetg(l-1, t_POL);
     308                 :         21 :   z[1] = a[1];
     309                 :         21 :   a0 = a + l-1;
     310                 :         21 :   z0 = z + l-2; *z0 = *a0--;
     311         [ +  + ]:       4732 :   for (i=l-3; i>1; i--) /* z[i] = a[i+1] + z[i+1] */
     312                 :            :   {
     313                 :       4711 :     GEN t = addii(gel(a0--,0), gel(z0--,0));
     314                 :       4711 :     gel(z0,0) = t;
     315                 :            :   }
     316         [ +  - ]:         21 :   if (r) *r = addii(gel(a0,0), gel(z0,0));
     317                 :         21 :   return z;
     318                 :            : }
     319                 :            : 
     320                 :            : /* Return 2^(n degpol(P))  P(x >> n), not memory clean if P is a ZX */
     321                 :            : GEN
     322                 :      22178 : ZX_rescale2n(GEN P, long n)
     323                 :            : {
     324                 :      22178 :   long i, l = lg(P), ni = n;
     325                 :      22178 :   GEN Q = cgetg(l,t_POL);
     326                 :      22178 :   Q[l-1] = P[l-1];
     327         [ +  + ]:     257587 :   for (i=l-2; i>=2; i--)
     328                 :            :   {
     329                 :     235409 :     gel(Q,i) = shifti(gel(P,i), ni);
     330                 :     235409 :     ni += n;
     331                 :            :   }
     332                 :      22178 :   Q[1] = P[1]; return Q;
     333                 :            : }
     334                 :            : 
     335                 :            : /* Return h^deg(P) P(x / h), not memory clean. h integer, P ZX */
     336                 :            : GEN
     337                 :      10485 : ZX_rescale(GEN P, GEN h)
     338                 :            : {
     339                 :      10485 :   long l = lg(P);
     340                 :      10485 :   GEN Q = cgetg(l,t_POL);
     341         [ +  - ]:      10485 :   if (l != 2)
     342                 :            :   {
     343                 :      10485 :     long i = l-1;
     344                 :      10485 :     GEN hi = h;
     345                 :      10485 :     gel(Q,i) = gel(P,i);
     346         [ +  - ]:      10485 :     if (l != 3) { i--; gel(Q,i) = mulii(gel(P,i), h); }
     347         [ +  + ]:      33625 :     for (i--; i>=2; i--) { hi = mulii(hi,h); gel(Q,i) = mulii(gel(P,i), hi); }
     348                 :            :   }
     349                 :      10485 :   Q[1] = P[1]; return Q;
     350                 :            : }
     351                 :            : /* Return h^(deg(P)-1) P(x / h), P!=0, h=lt(P), memory unclean; monic result */
     352                 :            : GEN
     353                 :          0 : ZX_rescale_lt(GEN P)
     354                 :            : {
     355                 :          0 :   long l = lg(P);
     356                 :          0 :   GEN Q = cgetg(l,t_POL);
     357                 :          0 :   gel(Q,l-1) = gen_1;
     358         [ #  # ]:          0 :   if (l != 3)
     359                 :            :   {
     360                 :          0 :     long i = l-1;
     361                 :          0 :     GEN h = gel(P,i), hi = h;
     362                 :          0 :     i--; gel(Q,i) = gel(P,i);
     363         [ #  # ]:          0 :     if (l != 4) { i--; gel(Q,i) = mulii(gel(P,i), h); }
     364         [ #  # ]:          0 :     for (i--; i>=2; i--) { hi = mulii(hi,h); gel(Q,i) = mulii(gel(P,i), hi); }
     365                 :            :   }
     366                 :          0 :   Q[1] = P[1]; return Q;
     367                 :            : }
     368                 :            : 
     369                 :            : 
     370                 :            : /*Eval x in 2^(k*BIL) in linear time*/
     371                 :            : static GEN
     372                 :  118729715 : ZX_eval2BILspec(GEN x, long k, long nx)
     373                 :            : {
     374                 :  118729715 :   long i,j, lz = k*nx, ki;
     375                 :  118729715 :   GEN pz = cgetipos(2+lz);
     376                 :  118729691 :   GEN nz = cgetipos(2+lz);
     377         [ +  + ]: 2063948368 :   for(i=0; i < lz; i++)
     378                 :            :   {
     379                 : 1945218565 :     *int_W(pz,i) = 0UL;
     380                 : 1945218565 :     *int_W(nz,i) = 0UL;
     381                 :            :   }
     382         [ +  + ]:  703434322 :   for(i=0, ki=0; i<nx; i++, ki+=k)
     383                 :            :   {
     384                 :  584704519 :     GEN c = gel(x,i);
     385                 :  584704519 :     long lc = lgefint(c)-2;
     386         [ +  + ]:  584704519 :     if (signe(c)==0) continue;
     387         [ +  + ]:  492609660 :     if (signe(c) > 0)
     388         [ +  + ]:  855472606 :       for (j=0; j<lc; j++) *int_W(pz,j+ki) = *int_W(c,j);
     389                 :            :     else
     390         [ +  + ]:  479288711 :       for (j=0; j<lc; j++) *int_W(nz,j+ki) = *int_W(c,j);
     391                 :            :   }
     392                 :  118729803 :   pz = int_normalize(pz,0);
     393                 :  118729810 :   nz = int_normalize(nz,0); return subii(pz,nz);
     394                 :            : }
     395                 :            : 
     396                 :            : static long
     397                 :  121560413 : ZX_expispec(GEN x, long nx)
     398                 :            : {
     399                 :  121560413 :   long i, m = 0;
     400         [ +  + ]:  723218664 :   for(i = 0; i < nx; i++)
     401                 :            :   {
     402                 :  601660522 :     long e = expi(gel(x,i));
     403         [ +  + ]:  601658251 :     if (e > m) m = e;
     404                 :            :   }
     405                 :  121558142 :   return m;
     406                 :            : }
     407                 :            : 
     408                 :            : static GEN
     409                 :   60171609 : Z_mod2BIL_ZX(GEN x, long bs, long d, long vx)
     410                 :            : {
     411                 :   60171609 :   long i, offset, lm = lgefint(x)-2, l = d+vx+3, sx = signe(x);
     412                 :   60171609 :   GEN s1 = int2n(bs*BITS_IN_LONG), pol = cgetg(l, t_POL);
     413                 :   60237782 :   int carry = 0;
     414                 :            : 
     415         [ +  + ]:   79966721 :   for (i=0; i<vx; i++) gel(pol,i+2) = gen_0;
     416         [ +  + ]:  608580774 :   for (offset=0; i <= d+vx; i++, offset += bs)
     417                 :            :   {
     418                 :  548409211 :     pari_sp av = avma;
     419                 :  548409211 :     long lz = minss(bs, lm-offset);
     420                 :  548560569 :     GEN z = adduispec_offset(carry, x, offset, lz);
     421         [ +  + ]:  547849489 :     if (lgefint(z) == 3+bs) { carry = 1; z = gen_0;}
     422                 :            :     else
     423                 :            :     {
     424 [ +  + ][ +  + ]:  537705141 :       carry = (lgefint(z) == 2+bs && (HIGHBIT & *int_W(z,bs-1)));
     425         [ +  + ]:  537705141 :       if (carry)
     426         [ +  + ]:   25814817 :         z = gerepileuptoint(av, (sx==-1)? subii(s1,z): subii(z,s1));
     427         [ +  + ]:  511890324 :       else if (sx==-1) togglesign(z);
     428                 :            :     }
     429                 :  548342992 :     gel(pol,i+2) = z;
     430                 :            :   }
     431                 :   60171563 :   return ZX_renormalize(pol,l);
     432                 :            : }
     433                 :            : 
     434                 :            : static GEN
     435                 :    1613418 : ZX_sqrspec_sqri(GEN x, long nx, long ex, long v)
     436                 :            : {
     437                 :    1613418 :   long e = 2*ex + expu(nx) + 3;
     438                 :    1613418 :   long N = divsBIL(e)+1;
     439                 :    1613418 :   GEN  z = sqri(ZX_eval2BILspec(x,N,nx));
     440                 :    1613414 :   return Z_mod2BIL_ZX(z, N, nx*2-2, v);
     441                 :            : }
     442                 :            : 
     443                 :            : static GEN
     444                 :   58558178 : ZX_mulspec_mulii(GEN x, GEN y, long nx, long ny, long ex, long ey, long v)
     445                 :            : {
     446                 :   58558178 :   long e = ex + ey + expu(minss(nx,ny)) + 3;
     447                 :   58558179 :   long N = divsBIL(e)+1;
     448                 :   58558176 :   GEN  z = mulii(ZX_eval2BILspec(x,N,nx), ZX_eval2BILspec(y,N,ny));
     449                 :   58558207 :   return Z_mod2BIL_ZX(z, N, nx+ny-2, v);
     450                 :            : }
     451                 :            : 
     452                 :            : INLINE GEN
     453                 :   31005791 : ZX_sqrspec_basecase_limb(GEN x, long a, long i)
     454                 :            : {
     455                 :   31005791 :   pari_sp av = avma;
     456                 :   31005791 :   GEN s = gen_0;
     457                 :   31005791 :   long j, l = (i+1)>>1;
     458         [ +  + ]:  134241017 :   for (j=a; j<l; j++)
     459                 :            :   {
     460                 :  103117506 :     GEN xj = gel(x,j), xx = gel(x,i-j);
     461 [ +  + ][ +  + ]:  103117506 :     if (signe(xj) && signe(xx))
     462                 :  101765820 :       s = addii(s, mulii(xj, xx));
     463                 :            :   }
     464                 :   31123511 :   s = shifti(s,1);
     465         [ +  + ]:   31092060 :   if ((i&1) == 0)
     466                 :            :   {
     467                 :   16986738 :     GEN t = gel(x, i>>1);
     468         [ +  + ]:   16986738 :     if (signe(t))
     469                 :   16932055 :       s = addii(s, sqri(t));
     470                 :            :   }
     471                 :   31095204 :   return gerepileuptoint(av,s);
     472                 :            : }
     473                 :            : 
     474                 :            : static GEN
     475                 :    2828921 : ZX_sqrspec_basecase(GEN x, long nx, long v)
     476                 :            : {
     477                 :            :   long i, lz, nz;
     478                 :            :   GEN z;
     479                 :            : 
     480                 :    2828921 :   lz = (nx << 1) + 1; nz = lz-2;
     481                 :    2828921 :   lz += v;
     482                 :    2828921 :   z = cgetg(lz,t_POL); z[1] = evalsigne(1); z += 2;
     483         [ +  + ]:    2868401 :   for (i=0; i<v; i++) gel(z++, 0) = gen_0;
     484         [ +  + ]:   19821056 :   for (i=0; i<nx; i++)
     485                 :   16992401 :     gel(z,i) = ZX_sqrspec_basecase_limb(x, 0, i);
     486         [ +  + ]:   16994307 :   for (  ; i<nz; i++) gel(z,i) = ZX_sqrspec_basecase_limb(x, i-nx+1, i);
     487                 :    2828823 :   z -= v+2; return z;
     488                 :            : }
     489                 :            : 
     490                 :            : static GEN
     491                 :     192083 : Z_sqrshiftspec_ZX(GEN x, long vx)
     492                 :            : {
     493                 :     192083 :   long i, nz = 2*vx+1;
     494                 :     192083 :   GEN z = cgetg(2+nz, t_POL);
     495                 :     192083 :   z[1] = evalsigne(1);
     496         [ +  + ]:    1062555 :   for(i=2;i<nz+1;i++) gel(z,i) = gen_0;
     497                 :     192083 :   gel(z,nz+1) = sqri(x);
     498                 :     192083 :   return z;
     499                 :            : }
     500                 :            : 
     501                 :            : static GEN
     502                 :   19516293 : Z_ZX_mulshiftspec(GEN x, GEN y, long ny, long vz)
     503                 :            : {
     504                 :   19516293 :   long i, nz = vz+ny;
     505                 :   19516293 :   GEN z = cgetg(2+nz, t_POL);
     506                 :   19516319 :   z[1] = evalsigne(1);
     507         [ +  + ]:   56418341 :   for (i=0; i<vz; i++)   gel(z,i+2)    = gen_0;
     508         [ +  + ]:   56381097 :   for (i=0; i<ny; i++) gel(z,i+vz+2) = mulii(x, gel(y,i));
     509                 :   19516293 :   return z;
     510                 :            : }
     511                 :            : 
     512                 :            : GEN
     513                 :    4640654 : ZX_sqrspec(GEN x, long nx)
     514                 :            : {
     515                 :            : #ifdef PARI_KERNEL_GMP
     516                 :    2904023 :   const long low[]={ 17, 32, 96, 112, 160, 128, 128, 160, 160, 160, 160, 160, 176, 192, 192, 192, 192, 192, 224, 224, 224, 240, 240, 240, 272, 288, 288, 240, 288, 304, 304, 304, 304, 304, 304, 352, 352, 368, 352, 352, 352, 368, 368, 432, 432, 496, 432, 496, 496};
     517                 :    2904023 :   const long high[]={ 102860, 70254, 52783, 27086, 24623, 18500, 15289, 13899, 12635, 11487, 10442, 9493, 8630, 7845, 7132, 7132, 6484, 6484, 5894, 5894, 4428, 4428, 3660, 4428, 3660, 3660, 2749, 2499, 2272, 2066, 1282, 1282, 1166, 1166, 1166, 1166, 1166, 1166, 1166, 963, 963, 724, 658, 658, 658, 528, 528, 528, 528};
     518                 :            : #else
     519                 :    1736631 :   const long low[]={ 17, 17, 32, 32, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 112, 112, 128, 112, 112, 112, 112, 112, 128, 128, 160, 160, 112, 128, 128, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 176, 160, 160, 176, 160, 160, 176, 176, 208, 176, 176, 176, 192, 192, 176, 176, 224, 176, 224, 224, 176, 224, 224, 224, 176, 176, 176, 176, 176, 176, 176, 176, 224, 176, 176, 224, 224, 224, 224, 224, 224, 224, 240, 288, 240, 288, 288, 240, 288, 288, 240, 240, 304, 304};
     520                 :    1736631 :   const long high[]={ 165657, 85008, 52783, 43622, 32774, 27086, 22385, 15289, 13899, 12635, 11487, 10442, 9493, 7845, 6484, 6484, 5894, 5894, 4871, 4871, 4428, 4026, 3660, 3660, 3660, 3327, 3327, 3024, 2749, 2749, 2272, 2749, 2499, 2499, 2272, 1878, 1878, 1878, 1707, 1552, 1552, 1552, 1552, 1552, 1411, 1411, 1411, 1282, 1282, 1282, 1282, 1282, 1166, 1166, 1166, 1166, 1166, 1166, 1166, 1166, 1060, 1060, 963, 963, 963, 963, 963, 963, 963, 963, 963, 963, 963, 876, 876, 876, 876, 796, 658, 724, 658, 724, 658, 658, 658, 658, 658, 658, 658, 658, 658, 658, 658, 658, 336, 658, 658, 592, 336, 336};
     521                 :            : #endif
     522                 :    4640654 :   const long nblow = numberof(low);
     523                 :            :   pari_sp av;
     524                 :            :   long ex, vx;
     525                 :            :   GEN z;
     526         [ +  + ]:    4640654 :   if (!nx) return pol_0(0);
     527                 :    4634774 :   vx = ZX_valspec(x,nx); nx-=vx; x+=vx;
     528         [ +  + ]:    4634718 :   if (nx==1) return Z_sqrshiftspec_ZX(gel(x, 0), vx);
     529                 :    4442635 :   av = avma;
     530                 :    4442635 :   ex = ZX_expispec(x,nx);
     531 [ +  + ][ +  + ]:    4442247 :   if (nx-2 < nblow && low[nx-2]<=ex && ex<=high[nx-2])
                 [ +  + ]
     532                 :    2828846 :     z = ZX_sqrspec_basecase(x, nx, 2*vx);
     533                 :            :   else
     534                 :    1613401 :     z = ZX_sqrspec_sqri(x, nx, ex, 2*vx);
     535                 :    4640190 :   return gerepileupto(av, z);
     536                 :            : }
     537                 :            : 
     538                 :            : GEN
     539                 :    4640599 : ZX_sqr(GEN x)
     540                 :            : {
     541                 :    4640599 :   GEN z = ZX_sqrspec(x+2, lgpol(x));
     542                 :    4640074 :   z[1] = x[1];
     543                 :    4640074 :   return z;
     544                 :            : }
     545                 :            : 
     546                 :            : GEN
     547                 :   81805663 : ZX_mulspec(GEN x, GEN y, long nx, long ny)
     548                 :            : {
     549                 :            :   pari_sp av;
     550                 :            :   long ex, ey, vx, vy;
     551                 :            :   GEN z;
     552 [ +  + ][ +  + ]:   81805663 :   if (!nx || !ny) return pol_0(0);
     553                 :   78074496 :   vx = ZX_valspec(x,nx); nx-=vx; x += vx;
     554                 :   78074494 :   vy = ZX_valspec(y,ny); ny-=vy; y += vy;
     555         [ +  + ]:   78074496 :   if (nx==1) return Z_ZX_mulshiftspec(gel(x,0), y, ny, vx+vy);
     556         [ +  + ]:   63285850 :   if (ny==1) return Z_ZX_mulshiftspec(gel(y,0), x, nx, vy+vx);
     557                 :   58558203 :   av = avma;
     558                 :   58558203 :   ex = ZX_expispec(x, nx); ey = ZX_expispec(y, ny);
     559                 :   58558178 :   z  = ZX_mulspec_mulii(x,y,nx,ny,ex,ey,vx+vy);
     560                 :   81805636 :   return gerepileupto(av, z);
     561                 :            : }
     562                 :            : GEN
     563                 :   81521974 : ZX_mul(GEN x, GEN y)
     564                 :            : {
     565                 :            :   GEN z;
     566         [ +  + ]:   81521974 :   if (x == y) return ZX_sqr(x);
     567                 :   81451641 :   z = ZX_mulspec(x+2,y+2,lgpol(x),lgpol(y));
     568                 :   81451643 :   z[1] = x[1];
     569         [ +  + ]:   81451643 :   if (!signe(y)) z[1] &= VARNBITS;
     570                 :   81521976 :   return z;
     571                 :            : }
     572                 :            : 
     573                 :            : /* x,y two ZX in the same variable; assume y is monic */
     574                 :            : GEN
     575                 :     131782 : ZX_rem(GEN x, GEN y)
     576                 :            : {
     577                 :            :   long vx, dx, dy, dz, i, j, sx, lr;
     578                 :            :   pari_sp av0, av;
     579                 :            :   GEN z,p1,rem;
     580                 :            : 
     581                 :     131782 :   vx = varn(x);
     582                 :     131782 :   dy = degpol(y);
     583                 :     131782 :   dx = degpol(x);
     584         [ +  + ]:     131782 :   if (dx < dy) return ZX_copy(x);
     585         [ -  + ]:     104874 :   if (!dy) return pol_0(vx); /* y is constant */
     586                 :     104874 :   av0 = avma; dz = dx-dy;
     587                 :     104874 :   z=cgetg(dz+3,t_POL); z[1] = x[1];
     588                 :     104874 :   x += 2; y += 2; z += 2;
     589                 :            : 
     590                 :     104874 :   p1 = gel(x,dx);
     591                 :     104874 :   gel(z,dz) = icopy(p1);
     592         [ +  + ]:    2444757 :   for (i=dx-1; i>=dy; i--)
     593                 :            :   {
     594                 :    2339883 :     av=avma; p1=gel(x,i);
     595 [ +  + ][ +  + ]:   47288885 :     for (j=i-dy+1; j<=i && j<=dz; j++)
     596                 :   44949002 :       p1 = subii(p1, mulii(gel(z,j),gel(y,i-j)));
     597         [ +  + ]:    2339883 :     gel(z,i-dy) = avma == av? icopy(p1): gerepileuptoint(av, p1);
     598                 :            :   }
     599                 :     104874 :   rem = (GEN)avma; av = (pari_sp)new_chunk(dx+3);
     600                 :     104874 :   for (sx=0; ; i--)
     601                 :            :   {
     602                 :     234169 :     p1 = gel(x,i);
     603 [ +  + ][ +  + ]:    4837405 :     for (j=0; j<=i && j<=dz; j++)
     604                 :    4603236 :       p1 = subii(p1, mulii(gel(z,j),gel(y,i-j)));
     605         [ +  + ]:     234169 :     if (signe(p1)) { sx = 1; break; }
     606         [ +  + ]:     129904 :     if (!i) break;
     607                 :     129295 :     avma=av;
     608                 :     129295 :   }
     609                 :     104874 :   lr=i+3; rem -= lr;
     610                 :     104874 :   rem[0] = evaltyp(t_POL) | evallg(lr);
     611                 :     104874 :   rem[1] = z[-1];
     612                 :     104874 :   p1 = gerepileuptoint((pari_sp)rem, p1);
     613                 :     104874 :   rem += 2; gel(rem,i) = p1;
     614         [ +  + ]:    3031107 :   for (i--; i>=0; i--)
     615                 :            :   {
     616                 :    2926233 :     av=avma; p1 = gel(x,i);
     617 [ +  + ][ +  + ]:   61909303 :     for (j=0; j<=i && j<=dz; j++)
     618                 :   58983070 :       p1 = subii(p1, mulii(gel(z,j),gel(y,i-j)));
     619         [ +  + ]:    2926233 :     gel(rem,i) = avma == av? icopy(p1): gerepileuptoint(av, p1);
     620                 :            :   }
     621                 :     104874 :   rem -= 2;
     622         [ +  + ]:     104874 :   if (!sx) (void)ZX_renormalize(rem, lr);
     623                 :     131782 :   return gerepileupto(av0,rem);
     624                 :            : }
     625                 :            : 
     626                 :            : /* return x(1) */
     627                 :            : GEN
     628                 :       4718 : ZX_eval1(GEN x)
     629                 :            : {
     630                 :       4718 :   pari_sp av = avma;
     631                 :       4718 :   long i = lg(x)-1;
     632                 :            :   GEN s;
     633         [ +  + ]:       4718 :   if (i < 2) return gen_0;
     634                 :       4193 :   s = gel(x,i); i--;
     635         [ +  + ]:       4193 :   if (i == 1) return icopy(s);
     636         [ +  + ]:      34608 :   for ( ; i>=2; i--)
     637                 :            :   {
     638                 :      31423 :     GEN c = gel(x,i);
     639         [ +  + ]:      31423 :     if (signe(c)) s = addii(s, c);
     640                 :            :   }
     641                 :       4718 :   return gerepileuptoint(av,s);
     642                 :            : }
     643                 :            : 
     644                 :            : /* reduce T mod X^n - 1. Shallow function */
     645                 :            : GEN
     646                 :    1495477 : ZX_mod_Xnm1(GEN T, ulong n)
     647                 :            : {
     648                 :    1495477 :   long i, j, L = lg(T), l = n+2;
     649                 :            :   GEN S;
     650         [ +  + ]:    1495477 :   if (L <= l) return T;
     651                 :    1320928 :   S = cgetg(l, t_POL);
     652                 :    1321014 :   S[1] = T[1];
     653         [ +  + ]:   10000035 :   for (i = 2; i < l; i++) gel(S,i) = gel(T,i);
     654         [ +  + ]:    6037244 :   for (j = 2; i < L; i++) {
     655                 :    4716250 :     gel(S,j) = addii(gel(S,j), gel(T,i));
     656         [ -  + ]:    4716230 :     if (++j == l) j = 2;
     657                 :            :   }
     658                 :    1495543 :   return normalizepol_lg(S, l);
     659                 :            : }
     660                 :            : 
     661                 :            : /*******************************************************************/
     662                 :            : /*                                                                 */
     663                 :            : /*                                ZXV                              */
     664                 :            : /*                                                                 */
     665                 :            : /*******************************************************************/
     666                 :            : 
     667                 :            : int
     668                 :         35 : ZXV_equal(GEN V, GEN W)
     669                 :            : {
     670                 :         35 :   long l = lg(V);
     671         [ -  + ]:         35 :   if (l!=lg(W)) return 0;
     672         [ +  - ]:         35 :   while (--l > 0)
     673         [ +  - ]:         35 :     if (!ZX_equal(gel(V,l), gel(W,l))) return 0;
     674                 :         35 :   return 1;
     675                 :            : }
     676                 :            : 
     677                 :            : GEN
     678                 :       7476 : ZXV_Z_mul(GEN y, GEN x)
     679                 :            : {
     680                 :            :   long i, l;
     681                 :       7476 :   GEN z = cgetg_copy(y, &l);
     682         [ +  + ]:      29904 :   for(i=1; i<l; i++) gel(z,i) = ZX_Z_mul(gel(y,i), x);
     683                 :       7476 :   return z;
     684                 :            : }
     685                 :            : 
     686                 :            : GEN
     687                 :          0 : ZXV_remi2n(GEN y, long N)
     688                 :            : {
     689                 :            :   long i, l;
     690                 :          0 :   GEN z = cgetg_copy(y, &l);
     691         [ #  # ]:          0 :   for(i=1; i<l; i++) gel(z,i) = ZX_remi2n(gel(y,i), N);
     692                 :          0 :   return z;
     693                 :            : }
     694                 :            : GEN
     695                 :      81648 : ZXV_dotproduct(GEN x, GEN y)
     696                 :            : {
     697                 :      81648 :   pari_sp av = avma;
     698                 :      81648 :   long i, lx = lg(x);
     699                 :            :   GEN c;
     700         [ -  + ]:      81648 :   if (lx == 1) return pol_0(varn(x));
     701                 :      81648 :   c = ZX_mul(gel(x,1), gel(y,1));
     702         [ +  + ]:     385392 :   for (i = 2; i < lx; i++)
     703                 :            :   {
     704                 :     303744 :     GEN t = ZX_mul(gel(x,i), gel(y,i));
     705         [ +  + ]:     303744 :     if (signe(t)) c = ZX_add(c, t);
     706                 :            :   }
     707                 :      81648 :   return gerepileupto(av, c);
     708                 :            : }
     709                 :            : 
     710                 :            : /*******************************************************************/
     711                 :            : /*                                                                 */
     712                 :            : /*                                ZXX                              */
     713                 :            : /*                                                                 */
     714                 :            : /*******************************************************************/
     715                 :            : 
     716                 :            : void
     717                 :         63 : RgX_check_ZXX(GEN x, const char *s)
     718                 :            : {
     719                 :         63 :   long k = lg(x)-1;
     720         [ +  + ]:      10122 :   for ( ; k>1; k--) {
     721                 :      10059 :     GEN t = gel(x,k);
     722      [ +  +  - ]:      10059 :     switch(typ(t)) {
     723                 :      10045 :       case t_INT: break;
     724         [ +  - ]:         14 :       case t_POL: if (RgX_is_ZX(t)) break;
     725                 :            :       /* fall through */
     726                 :          0 :       default: pari_err_TYPE(stack_strcat(s, " not in Z[X,Y]"),x);
     727                 :            :     }
     728                 :            :   }
     729                 :         63 : }
     730                 :            : 
     731                 :            : /*Renormalize (in place) polynomial with t_INT or ZX coefficients.*/
     732                 :            : GEN
     733                 :  176221995 : ZXX_renormalize(GEN x, long lx)
     734                 :            : {
     735                 :            :   long i;
     736         [ +  + ]:  205407079 :   for (i = lx-1; i>1; i--)
     737         [ +  + ]:  199845442 :     if (signe(gel(x,i))) break;
     738                 :  176221995 :   stackdummy((pari_sp)(x + lg(x)), (pari_sp)(x + (i+1)));
     739         [ +  + ]:  176222102 :   setlg(x, i+1); setsigne(x, i!=1); return x;
     740                 :            : }
     741                 :            : 
     742                 :            : long
     743                 :        469 : ZXX_max_lg(GEN x)
     744                 :            : {
     745                 :        469 :   long i, prec = 0, lx = lg(x);
     746         [ +  + ]:       3542 :   for (i=2; i<lx; i++)
     747                 :            :   {
     748                 :       3073 :     GEN p = gel(x,i);
     749         [ +  + ]:       3073 :     long l = (typ(p) == t_INT)? lgefint(p): ZX_max_lg(p);
     750         [ +  + ]:       3073 :     if (l > prec) prec = l;
     751                 :            :   }
     752                 :        469 :   return prec;
     753                 :            : }
     754                 :            : 
     755                 :            : GEN
     756                 :       2198 : ZXX_Z_mul(GEN y, GEN x)
     757                 :            : {
     758                 :       2198 :   long i, l = lg(y);
     759                 :       2198 :   GEN z = cgetg(l,t_POL); z[1] = y[1];
     760         [ +  + ]:     180369 :   for(i=2; i<l; i++)
     761         [ -  + ]:     178171 :     if(typ(gel(y,i))==t_INT)
     762                 :          0 :       gel(z,i) = mulii(gel(y,i),x);
     763                 :            :     else
     764                 :     178171 :       gel(z,i) = ZX_Z_mul(gel(y,i),x);
     765                 :       2198 :   return z;
     766                 :            : }
     767                 :            : 
     768                 :            : GEN
     769                 :         42 : ZXX_Z_add_shallow(GEN x, GEN y)
     770                 :            : {
     771                 :         42 :   long i, l = lg(x);
     772                 :            :   GEN z, a;
     773         [ -  + ]:         42 :   if (signe(x)==0) return scalarpol(y,varn(x));
     774                 :         42 :   z = cgetg(l,t_POL); z[1] = x[1];
     775                 :         42 :   a = gel(x,2);
     776         [ -  + ]:         42 :   gel(z, 2) = typ(a)==t_INT? addii(a,y): ZX_Z_add(a,y);
     777         [ +  + ]:        210 :   for(i=3; i<l; i++)
     778                 :        168 :     gel(z,i) = gel(x,i);
     779                 :         42 :   return z;
     780                 :            : }
     781                 :            : 
     782                 :            : GEN
     783                 :      92869 : ZXX_Z_divexact(GEN y, GEN x)
     784                 :            : {
     785                 :      92869 :   long i, l = lg(y);
     786                 :      92869 :   GEN z = cgetg(l,t_POL); z[1] = y[1];
     787         [ +  + ]:     668150 :   for(i=2; i<l; i++)
     788         [ +  + ]:     575281 :     if(typ(gel(y,i))==t_INT)
     789                 :       1137 :       gel(z,i) = diviiexact(gel(y,i),x);
     790                 :            :     else
     791                 :     574144 :       gel(z,i) = ZX_Z_divexact(gel(y,i),x);
     792                 :      92869 :   return z;
     793                 :            : }
     794                 :            : 
     795                 :            : /* Kronecker substitution, ZXX -> ZX:
     796                 :            :  * P(X,Y) = sum_{0<=i<lP} P_i(X) * Y^i, where deg P_i < n.
     797                 :            :  * Returns P(X,X^(2n-1)) */
     798                 :            : GEN
     799                 :    1323273 : ZXX_to_Kronecker_spec(GEN P, long lP, long n)
     800                 :            : {
     801                 :    1323273 :   long i, k, N = (n<<1) + 1;
     802                 :            :   GEN y;
     803         [ +  + ]:    1323273 :   if (!lP) return pol_0(0);
     804                 :    1323245 :   y = cgetg((N-2)*lP + 2, t_POL) + 2;
     805         [ +  - ]:   11688056 :   for (k=i=0; i<lP; i++)
     806                 :            :   {
     807                 :            :     long j;
     808                 :   11688056 :     GEN c = gel(P,i);
     809         [ +  + ]:   11688056 :     if (typ(c)==t_INT)
     810                 :            :     {
     811                 :    1421718 :       gel(y,k++) = c;
     812                 :    1421718 :       j = 3;
     813                 :            :     }
     814                 :            :     else
     815                 :            :     {
     816                 :   10266338 :       long l = lg(c);
     817         [ -  + ]:   10266338 :       if (l-3 >= n)
     818                 :          0 :         pari_err_BUG("ZXX_to_Kronecker, P is not reduced mod Q");
     819         [ +  + ]:   60884307 :       for (j=2; j < l; j++) gel(y,k++) = gel(c,j);
     820                 :            :     }
     821         [ +  + ]:   11688056 :     if (i == lP-1) break;
     822         [ +  + ]:   57852902 :     for (   ; j < N; j++) gel(y,k++) = gen_0;
     823                 :            :   }
     824                 :    1323273 :   y-=2; setlg(y, k+2); y[1] = evalsigne(1); return y;
     825                 :            : }
     826                 :            : 
     827                 :            : GEN
     828                 :     435355 : ZXX_to_Kronecker(GEN P, long n)
     829                 :            : {
     830                 :     435355 :   GEN z = ZXX_to_Kronecker_spec(P+2, lgpol(P), n);
     831                 :     435355 :   setvarn(z,varn(P)); return z;
     832                 :            : }

Generated by: LCOV version 1.9