Code coverage tests

This page documents the degree to which the PARI/GP source code is tested by our public test suite, distributed with the source distribution in directory src/test/. This is measured by the gcov utility; we then process gcov output using the lcov frond-end.

We test a few variants depending on Configure flags on the pari.math.u-bordeaux.fr machine (x86_64 architecture), and agregate them in the final report:

The target is to exceed 90% coverage for all mathematical modules (given that branches depending on DEBUGLEVEL or DEBUGMEM are not covered). This script is run to produce the results below.

LCOV - code coverage report
Current view: top level - basemath - ZX.c (source / functions) Hit Total Coverage
Test: PARI/GP v2.16.1 lcov report (development 28904-c3aa21e911) Lines: 700 791 88.5 %
Date: 2023-12-04 07:51:13 Functions: 95 107 88.8 %
Legend: Lines: hit not hit

          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; either version 2 of the License, or (at your option) any later
       8             : version. It is distributed in the hope that it will be useful, but WITHOUT
       9             : ANY WARRANTY WHATSOEVER.
      10             : 
      11             : Check the License for details. You should have received a copy of it, along
      12             : with the package; see the file 'COPYING'. If not, write to the Free Software
      13             : Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
      14             : 
      15             : #include "pari.h"
      16             : #include "paripriv.h"
      17             : 
      18             : /*******************************************************************/
      19             : /*                                                                 */
      20             : /*                                ZX                               */
      21             : /*                                                                 */
      22             : /*******************************************************************/
      23             : void
      24      324437 : RgX_check_QX(GEN x, const char *s)
      25      324437 : { if (!RgX_is_QX(x)) pari_err_TYPE(stack_strcat(s," [not in Q[X]]"), x); }
      26             : void
      27     1824990 : RgX_check_ZX(GEN x, const char *s)
      28     1824990 : { if (!RgX_is_ZX(x)) pari_err_TYPE(stack_strcat(s," [not in Z[X]]"), x); }
      29             : long
      30      106554 : ZX_max_lg(GEN x)
      31             : {
      32      106554 :   long i, prec = 0, lx = lg(x);
      33             : 
      34      645050 :   for (i=2; i<lx; i++) { long l = lgefint(gel(x,i)); if (l > prec) prec = l; }
      35      106554 :   return prec;
      36             : }
      37             : 
      38             : GEN
      39    39097425 : ZX_add(GEN x, GEN y)
      40             : {
      41             :   long lx,ly,i;
      42             :   GEN z;
      43    39097425 :   lx = lg(x); ly = lg(y); if (lx < ly) swapspec(x,y, lx,ly);
      44    39097425 :   z = cgetg(lx,t_POL); z[1] = x[1];
      45   243540553 :   for (i=2; i<ly; i++) gel(z,i) = addii(gel(x,i),gel(y,i));
      46    77744071 :   for (   ; i<lx; i++) gel(z,i) = icopy(gel(x,i));
      47    38897966 :   if (lx == ly) z = ZX_renormalize(z, lx);
      48    38912851 :   if (!lgpol(z)) { set_avma((pari_sp)(z + lx)); return pol_0(varn(x)); }
      49    37771538 :   return z;
      50             : }
      51             : 
      52             : GEN
      53    27783177 : ZX_sub(GEN x,GEN y)
      54             : {
      55    27783177 :   long i, lx = lg(x), ly = lg(y);
      56             :   GEN z;
      57    27783177 :   if (lx >= ly)
      58             :   {
      59    27371625 :     z = cgetg(lx,t_POL); z[1] = x[1];
      60   113009266 :     for (i=2; i<ly; i++) gel(z,i) = subii(gel(x,i),gel(y,i));
      61    27306080 :     if (lx == ly)
      62             :     {
      63    22044038 :       z = ZX_renormalize(z, lx);
      64    22054267 :       if (!lgpol(z)) { set_avma((pari_sp)(z + lx)); z = pol_0(varn(x)); }
      65             :     }
      66             :     else
      67    16296675 :       for (   ; i<lx; i++) gel(z,i) = icopy(gel(x,i));
      68             :   }
      69             :   else
      70             :   {
      71      411552 :     z = cgetg(ly,t_POL); z[1] = y[1];
      72     1115158 :     for (i=2; i<lx; i++) gel(z,i) = subii(gel(x,i),gel(y,i));
      73     1288863 :     for (   ; i<ly; i++) gel(z,i) = negi(gel(y,i));
      74             :   }
      75    27787186 :   return z;
      76             : }
      77             : 
      78             : GEN
      79      592714 : ZX_neg(GEN x)
      80             : {
      81      592714 :   long i, l = lg(x);
      82      592714 :   GEN y = cgetg(l,t_POL);
      83     2440977 :   y[1] = x[1]; for(i=2; i<l; i++) gel(y,i) = negi(gel(x,i));
      84      592758 :   return y;
      85             : }
      86             : GEN
      87     5031987 : ZX_copy(GEN x)
      88             : {
      89     5031987 :   long i, l = lg(x);
      90     5031987 :   GEN y = cgetg(l, t_POL);
      91     5031994 :   y[1] = x[1];
      92    20839458 :   for (i=2; i<l; i++)
      93             :   {
      94    15807473 :     GEN c = gel(x,i);
      95    15807473 :     gel(y,i) = lgefint(c) == 2? gen_0: icopy(c);
      96             :   }
      97     5031985 :   return y;
      98             : }
      99             : 
     100             : GEN
     101       56030 : scalar_ZX(GEN x, long v)
     102             : {
     103             :   GEN z;
     104       56030 :   if (!signe(x)) return pol_0(v);
     105        4516 :   z = cgetg(3, t_POL);
     106        4516 :   z[1] = evalsigne(1) | evalvarn(v);
     107        4516 :   gel(z,2) = icopy(x); return z;
     108             : }
     109             : 
     110             : GEN
     111       23038 : scalar_ZX_shallow(GEN x, long v)
     112             : {
     113             :   GEN z;
     114       23038 :   if (!signe(x)) return pol_0(v);
     115       19776 :   z = cgetg(3, t_POL);
     116       19776 :   z[1] = evalsigne(1) | evalvarn(v);
     117       19776 :   gel(z,2) = x; return z;
     118             : }
     119             : 
     120             : GEN
     121       87968 : ZX_Z_add(GEN y, GEN x)
     122             : {
     123             :   long lz, i;
     124       87968 :   GEN z = cgetg_copy(y, &lz);
     125       87966 :   if (lz == 2) { set_avma((pari_sp)(z + 2)); return scalar_ZX(x,varn(y)); }
     126       77228 :   z[1] = y[1];
     127       77228 :   gel(z,2) = addii(gel(y,2),x);
     128     1879142 :   for(i=3; i<lz; i++) gel(z,i) = icopy(gel(y,i));
     129       77913 :   if (lz==3) z = ZX_renormalize(z,lz);
     130       77231 :   return z;
     131             : }
     132             : GEN
     133       93722 : ZX_Z_add_shallow(GEN y, GEN x)
     134             : {
     135             :   long lz, i;
     136       93722 :   GEN z = cgetg_copy(y, &lz);
     137       93721 :   if (lz == 2) { set_avma((pari_sp)(z + 2)); return scalar_ZX_shallow(x,varn(y)); }
     138       93532 :   z[1] = y[1];
     139       93532 :   gel(z,2) = addii(gel(y,2),x);
     140      549416 :   for(i=3; i<lz; i++) gel(z,i) = gel(y,i);
     141       93515 :   if (lz==3) z = ZX_renormalize(z,lz);
     142       93522 :   return z;
     143             : }
     144             : 
     145             : GEN
     146       73965 : ZX_Z_sub(GEN y, GEN x)
     147             : {
     148             :   long lz, i;
     149       73965 :   GEN z = cgetg_copy(y, &lz);
     150       73965 :   if (lz == 2)
     151             :   { /* scalarpol(negi(x), v) */
     152         441 :     long v = varn(y);
     153         441 :     set_avma((pari_sp)(z + 2));
     154         441 :     if (!signe(x)) return pol_0(v);
     155         441 :     z = cgetg(3,t_POL);
     156         441 :     z[1] = evalvarn(v) | evalsigne(1);
     157         441 :     gel(z,2) = negi(x); return z;
     158             :   }
     159       73524 :   z[1] = y[1];
     160       73524 :   gel(z,2) = subii(gel(y,2),x);
     161      439841 :   for(i=3; i<lz; i++) gel(z,i) = icopy(gel(y,i));
     162       73524 :   if (lz==3) z = ZX_renormalize(z,lz);
     163       73524 :   return z;
     164             : }
     165             : 
     166             : GEN
     167     2688130 : Z_ZX_sub(GEN x, GEN y)
     168             : {
     169             :   long lz, i;
     170     2688130 :   GEN z = cgetg_copy(y, &lz);
     171     2688224 :   if (lz == 2) { set_avma((pari_sp)(z + 2)); return scalar_ZX(x,varn(y)); }
     172     2688224 :   z[1] = y[1];
     173     2688224 :   gel(z,2) = subii(x, gel(y,2));
     174    13473386 :   for(i=3; i<lz; i++) gel(z,i) = negi(gel(y,i));
     175     2688650 :   if (lz==3) z = ZX_renormalize(z,lz);
     176     2688300 :   return z;
     177             : }
     178             : 
     179             : GEN
     180     5089042 : ZX_Z_divexact(GEN y,GEN x)
     181             : {
     182     5089042 :   long i, l = lg(y);
     183     5089042 :   GEN z = cgetg(l,t_POL); z[1] = y[1];
     184    32669766 :   for(i=2; i<l; i++) gel(z,i) = diviiexact(gel(y,i),x);
     185     5083558 :   return z;
     186             : }
     187             : 
     188             : GEN
     189      977795 : ZX_divuexact(GEN y, ulong x)
     190             : {
     191      977795 :   long i, l = lg(y);
     192      977795 :   GEN z = cgetg(l,t_POL); z[1] = y[1];
     193     9684353 :   for(i=2; i<l; i++) gel(z,i) = diviuexact(gel(y,i),x);
     194      977795 :   return z;
     195             : }
     196             : 
     197             : GEN
     198         112 : zx_z_divexact(GEN y, long x)
     199             : {
     200         112 :   long i, l = lg(y);
     201         112 :   GEN z = cgetg(l,t_VECSMALL); z[1] = y[1];
     202         595 :   for (i=2; i<l; i++) z[i] = y[i]/x;
     203         112 :   return z;
     204             : }
     205             : 
     206             : GEN
     207    16593358 : ZX_Z_mul(GEN y,GEN x)
     208             : {
     209             :   GEN z;
     210             :   long i, l;
     211    16593358 :   if (!signe(x)) return pol_0(varn(y));
     212    13553192 :   l = lg(y); z = cgetg(l,t_POL); z[1] = y[1];
     213    91264814 :   for(i=2; i<l; i++) gel(z,i) = mulii(gel(y,i),x);
     214    13543855 :   return z;
     215             : }
     216             : 
     217             : GEN
     218      252619 : ZX_mulu(GEN y, ulong x)
     219             : {
     220             :   GEN z;
     221             :   long i, l;
     222      252619 :   if (!x) return pol_0(varn(y));
     223      252619 :   l = lg(y); z = cgetg(l,t_POL); z[1] = y[1];
     224     1024336 :   for(i=2; i<l; i++) gel(z,i) = mului(x,gel(y,i));
     225      252619 :   return z;
     226             : }
     227             : 
     228             : GEN
     229     6013228 : ZX_shifti(GEN y, long n)
     230             : {
     231             :   GEN z;
     232             :   long i, l;
     233     6013228 :   l = lg(y); z = cgetg(l,t_POL); z[1] = y[1];
     234    29730116 :   for(i=2; i<l; i++) gel(z,i) = shifti(gel(y,i),n);
     235     5995080 :   return ZX_renormalize(z,l);
     236             : }
     237             : 
     238             : GEN
     239      107527 : ZX_remi2n(GEN y, long n)
     240             : {
     241             :   GEN z;
     242             :   long i, l;
     243      107527 :   l = lg(y); z = cgetg(l,t_POL); z[1] = y[1];
     244     4830644 :   for(i=2; i<l; i++) gel(z,i) = remi2n(gel(y,i),n);
     245      101175 :   return ZX_renormalize(z,l);
     246             : }
     247             : 
     248             : GEN
     249       46630 : ZXT_remi2n(GEN z, long n)
     250             : {
     251       46630 :   if (typ(z) == t_POL)
     252       40157 :     return ZX_remi2n(z, n);
     253             :   else
     254             :   {
     255        6473 :     long i,l = lg(z);
     256        6473 :     GEN x = cgetg(l, t_VEC);
     257       19431 :     for (i=1; i<l; i++) gel(x,i) = ZXT_remi2n(gel(z,i), n);
     258        6476 :     return x;
     259             :   }
     260             : }
     261             : 
     262             : GEN
     263        1323 : zx_to_ZX(GEN z)
     264             : {
     265        1323 :   long i, l = lg(z);
     266        1323 :   GEN x = cgetg(l,t_POL);
     267      100912 :   for (i=2; i<l; i++) gel(x,i) = stoi(z[i]);
     268        1323 :   x[1] = evalsigne(l-2!=0)| z[1]; return x;
     269             : }
     270             : 
     271             : GEN
     272     4977499 : ZX_deriv(GEN x)
     273             : {
     274     4977499 :   long i,lx = lg(x)-1;
     275             :   GEN y;
     276             : 
     277     4977499 :   if (lx<3) return pol_0(varn(x));
     278     4895279 :   y = cgetg(lx,t_POL);
     279    29180274 :   for (i=2; i<lx ; i++) gel(y,i) = mului(i-1,gel(x,i+1));
     280     4893486 :   y[1] = x[1]; return y;
     281             : }
     282             : 
     283             : int
     284     2053069 : ZX_equal(GEN V, GEN W)
     285             : {
     286     2053069 :   long i, l = lg(V);
     287     2053069 :   if (lg(W) != l) return 0;
     288     5988331 :   for (i = 2; i < l; i++)
     289     4652714 :     if (!equalii(gel(V,i), gel(W,i))) return 0;
     290     1335617 :   return 1;
     291             : }
     292             : 
     293             : static long
     294   260473528 : ZX_valspec(GEN x, long nx)
     295             : {
     296             :   long vx;
     297   332413844 :   for (vx = 0; vx<nx ; vx++)
     298   332422487 :     if (signe(gel(x,vx))) break;
     299   260473528 :   return vx;
     300             : }
     301             : 
     302             : long
     303      328815 : ZX_val(GEN x)
     304             : {
     305             :   long vx;
     306      328815 :   if (!signe(x)) return LONG_MAX;
     307      263337 :   for (vx = 0;; vx++)
     308      263337 :     if (signe(gel(x,2+vx))) break;
     309      213495 :   return vx;
     310             : }
     311             : long
     312    23262435 : ZX_valrem(GEN x, GEN *Z)
     313             : {
     314             :   long vx;
     315    23262435 :   if (!signe(x)) { *Z = pol_0(varn(x)); return LONG_MAX; }
     316    43950221 :   for (vx = 0;; vx++)
     317    43950221 :     if (signe(gel(x,2+vx))) break;
     318    23262435 :   *Z = RgX_shift_shallow(x, -vx);
     319    23262451 :   return vx;
     320             : }
     321             : 
     322             : GEN
     323          21 : ZX_div_by_X_1(GEN a, GEN *r)
     324             : {
     325          21 :   long l = lg(a), i;
     326          21 :   GEN a0, z0, z = cgetg(l-1, t_POL);
     327          21 :   z[1] = a[1];
     328          21 :   a0 = a + l-1;
     329          21 :   z0 = z + l-2; *z0 = *a0--;
     330        4732 :   for (i=l-3; i>1; i--) /* z[i] = a[i+1] + z[i+1] */
     331             :   {
     332        4711 :     GEN t = addii(gel(a0--,0), gel(z0--,0));
     333        4711 :     gel(z0,0) = t;
     334             :   }
     335          21 :   if (r) *r = addii(gel(a0,0), gel(z0,0));
     336          21 :   return z;
     337             : }
     338             : 
     339             : /* return P(X + c) using destructive Horner, optimize for c = 1,-1 */
     340             : static GEN
     341     1278473 : ZX_translate_basecase(GEN P, GEN c)
     342             : {
     343     1278473 :   pari_sp av = avma;
     344             :   GEN Q, R;
     345             :   long i, k, n;
     346             : 
     347     1278473 :   if (!signe(P) || !signe(c)) return ZX_copy(P);
     348     1237604 :   Q = leafcopy(P);
     349     1237613 :   R = Q+2; n = degpol(P);
     350     1237612 :   if (equali1(c))
     351             :   {
     352     5960096 :     for (i=1; i<=n; i++)
     353             :     {
     354    35242622 :       for (k=n-i; k<n; k++) gel(R,k) = addii(gel(R,k), gel(R,k+1));
     355     4992187 :       if (gc_needed(av,2))
     356             :       {
     357           0 :         if(DEBUGMEM>1) pari_warn(warnmem,"ZX_translate(1), i = %ld/%ld", i,n);
     358           0 :         Q = gerepilecopy(av, Q); R = Q+2;
     359             :       }
     360             :     }
     361             :   }
     362      269702 :   else if (equalim1(c))
     363             :   {
     364       55550 :     for (i=1; i<=n; i++)
     365             :     {
     366      182266 :       for (k=n-i; k<n; k++) gel(R,k) = subii(gel(R,k), gel(R,k+1));
     367       45929 :       if (gc_needed(av,2))
     368             :       {
     369           0 :         if(DEBUGMEM>1) pari_warn(warnmem,"ZX_translate(-1), i = %ld/%ld", i,n);
     370           0 :         Q = gerepilecopy(av, Q); R = Q+2;
     371             :       }
     372             :     }
     373             :   }
     374             :   else
     375             :   {
     376     1607083 :     for (i=1; i<=n; i++)
     377             :     {
     378     7600558 :       for (k=n-i; k<n; k++) gel(R,k) = addmulii_inplace(gel(R,k), c, gel(R,k+1));
     379     1347002 :       if (gc_needed(av,2))
     380             :       {
     381           0 :         if(DEBUGMEM>1) pari_warn(warnmem,"ZX_translate, i = %ld/%ld", i,n);
     382           0 :         Q = gerepilecopy(av, Q); R = Q+2;
     383             :       }
     384             :     }
     385             :   }
     386     1237415 :   return gerepilecopy(av, Q);
     387             : }
     388             : 
     389             : static GEN
     390           0 : Z_Xpm1_powu(long n, long s, long v)
     391             : {
     392             :   long d, k;
     393             :   GEN C;
     394           0 :   if (!n) return pol_1(v);
     395           0 :   d = (n + 1) >> 1;
     396           0 :   C = cgetg(n+3, t_POL);
     397           0 :   C[1] = evalsigne(1)| evalvarn(v);
     398           0 :   gel(C,2) = gen_1;
     399           0 :   gel(C,3) = utoipos(n);
     400           0 :   for (k=2; k <= d; k++)
     401           0 :     gel(C,k+2) = diviuexact(mului(n-k+1, gel(C,k+1)), k);
     402           0 :   if (s < 0)
     403           0 :     for (k = odd(n)? 0: 1; k <= d; k += 2)
     404           0 :       togglesign_safe(&gel(C,k+2));
     405           0 :   if (s > 0 || !odd(n))
     406           0 :     for (k = d+1; k <= n; k++) gel(C,k+2) = gel(C,n-k+2);
     407             :   else
     408           0 :     for (k = d+1; k <= n; k++) gel(C,k+2) = negi(gel(C,n-k+2));
     409           0 :   return C;
     410             : }
     411             : /* return (x+u)^n */
     412             : static GEN
     413           0 : Z_XpN_powu(GEN u, long n, long v)
     414             : {
     415             :   pari_sp av;
     416             :   long k;
     417             :   GEN B, C, V;
     418           0 :   if (!n) return pol_1(v);
     419           0 :   if (is_pm1(u))
     420           0 :     return Z_Xpm1_powu(n, signe(u), v);
     421           0 :   av = avma;
     422           0 :   V = gpowers(u, n);
     423           0 :   B = vecbinomial(n);
     424           0 :   C = cgetg(n+3, t_POL);
     425           0 :   C[1] = evalsigne(1)| evalvarn(v);
     426           0 :   for (k=1; k <= n+1; k++)
     427           0 :     gel(C,k+1) = mulii(gel(V,n+2-k), gel(B,k));
     428           0 :   return gerepileupto(av, C);
     429             : }
     430             : 
     431             : GEN
     432     1278467 : ZX_translate(GEN P, GEN c)
     433             : {
     434     1278467 :   pari_sp av = avma;
     435     1278467 :   long n = degpol(P);
     436     1278471 :   if (n < 220)
     437     1278472 :     return ZX_translate_basecase(P, c);
     438             :   else
     439             :   {
     440           0 :     long d = n >> 1;
     441           0 :     GEN Q = ZX_translate(RgX_shift_shallow(P, -d), c);
     442           0 :     GEN R = ZX_translate(RgXn_red_shallow(P, d), c);
     443           0 :     GEN S = Z_XpN_powu(c, d, varn(P));
     444           0 :     return gerepileupto(av, ZX_add(ZX_mul(Q, S), R));
     445             :   }
     446             : }
     447             : 
     448             : /* P(ax + b) */
     449             : GEN
     450      981188 : ZX_affine(GEN P, GEN a, GEN b)
     451             : {
     452      981188 :   if (signe(b)) P = ZX_translate(P, b);
     453      981188 :   return ZX_unscale(P, a);
     454             : }
     455             : 
     456             : GEN
     457      506976 : ZX_Z_eval(GEN x, GEN y)
     458             : {
     459      506976 :   long i = lg(x)-1, j;
     460      506976 :   pari_sp av = avma;
     461             :   GEN t, r;
     462             : 
     463      506976 :   if (i<=2) return (i==2)? icopy(gel(x,2)): gen_0;
     464      469519 :   if (!signe(y)) return icopy(gel(x,2));
     465             : 
     466      469400 :   t = gel(x,i); i--;
     467             : #if 0 /* standard Horner's rule */
     468             :   for ( ; i>=2; i--)
     469             :     t = addii(mulii(t,y),gel(x,i));
     470             : #endif
     471             :   /* specific attention to sparse polynomials */
     472     2367701 :   for ( ; i>=2; i = j-1)
     473             :   {
     474     2074423 :     for (j = i; !signe(gel(x,j)); j--)
     475      176113 :       if (j==2)
     476             :       {
     477        2947 :         if (i != j) y = powiu(y, i-j+1);
     478        2947 :         return gerepileuptoint(av, mulii(t,y));
     479             :       }
     480     1898310 :     r = (i==j)? y: powiu(y, i-j+1);
     481     1898322 :     t = addii(mulii(t,r), gel(x,j));
     482     1898300 :     if (gc_needed(av,2))
     483             :     {
     484           0 :       if (DEBUGMEM>1) pari_warn(warnmem,"ZX_Z_eval: i = %ld",i);
     485           0 :       t = gerepileuptoint(av, t);
     486             :     }
     487             :   }
     488      466444 :   return gerepileuptoint(av, t);
     489             : }
     490             : 
     491             : /* Return 2^(n degpol(P))  P(x >> n) */
     492             : GEN
     493           0 : ZX_rescale2n(GEN P, long n)
     494             : {
     495           0 :   long i, l = lg(P), ni = n;
     496             :   GEN Q;
     497           0 :   if (l==2) return pol_0(varn(P));
     498           0 :   Q = cgetg(l,t_POL);
     499           0 :   gel(Q,l-1) = icopy(gel(P,l-1));
     500           0 :   for (i=l-2; i>=2; i--)
     501             :   {
     502           0 :     gel(Q,i) = shifti(gel(P,i), ni);
     503           0 :     ni += n;
     504             :   }
     505           0 :   Q[1] = P[1]; return Q;
     506             : }
     507             : 
     508             : /* Return h^deg(P) P(x / h), not memory clean. h integer, P ZX */
     509             : GEN
     510       35609 : ZX_rescale(GEN P, GEN h)
     511             : {
     512       35609 :   long l = lg(P);
     513       35609 :   GEN Q = cgetg(l,t_POL);
     514       35611 :   if (l != 2)
     515             :   {
     516       35614 :     long i = l-1;
     517       35614 :     GEN hi = h;
     518       35614 :     gel(Q,i) = gel(P,i);
     519       35614 :     if (l != 3) { i--; gel(Q,i) = mulii(gel(P,i), h); }
     520      110236 :     for (i--; i>=2; i--) { hi = mulii(hi,h); gel(Q,i) = mulii(gel(P,i), hi); }
     521             :   }
     522       35620 :   Q[1] = P[1]; return Q;
     523             : }
     524             : /* Return h^(deg(P)-1) P(x / h), P!=0, h=lt(P), memory unclean; monic result */
     525             : GEN
     526           0 : ZX_rescale_lt(GEN P)
     527             : {
     528           0 :   long l = lg(P);
     529           0 :   GEN Q = cgetg(l,t_POL);
     530           0 :   gel(Q,l-1) = gen_1;
     531           0 :   if (l != 3)
     532             :   {
     533           0 :     long i = l-1;
     534           0 :     GEN h = gel(P,i), hi = h;
     535           0 :     i--; gel(Q,i) = gel(P,i);
     536           0 :     if (l != 4) { i--; gel(Q,i) = mulii(gel(P,i), h); }
     537           0 :     for (i--; i>=2; i--) { hi = mulii(hi,h); gel(Q,i) = mulii(gel(P,i), hi); }
     538             :   }
     539           0 :   Q[1] = P[1]; return Q;
     540             : }
     541             : 
     542             : /*Eval x in 2^(k*BIL) in linear time*/
     543             : static GEN
     544    85267537 : ZX_eval2BILspec(GEN x, long k, long nx)
     545             : {
     546    85267537 :   pari_sp av = avma;
     547    85267537 :   long i,j, lz = k*nx, ki;
     548    85267537 :   GEN pz = cgetipos(2+lz);
     549    85263406 :   GEN nz = cgetipos(2+lz);
     550  3127956120 :   for(i=0; i < lz; i++)
     551             :   {
     552  3042673455 :     *int_W(pz,i) = 0UL;
     553  3042673455 :     *int_W(nz,i) = 0UL;
     554             :   }
     555   970225602 :   for(i=0, ki=0; i<nx; i++, ki+=k)
     556             :   {
     557   884942937 :     GEN c = gel(x,i);
     558   884942937 :     long lc = lgefint(c)-2;
     559   884942937 :     if (signe(c)==0) continue;
     560   661267768 :     if (signe(c) > 0)
     561  1663812457 :       for (j=0; j<lc; j++) *int_W(pz,j+ki) = *int_W(c,j);
     562             :     else
     563   298287020 :       for (j=0; j<lc; j++) *int_W(nz,j+ki) = *int_W(c,j);
     564             :   }
     565    85282665 :   pz = int_normalize(pz,0);
     566    85282565 :   nz = int_normalize(nz,0); return gerepileuptoint(av, subii(pz,nz));
     567             : }
     568             : 
     569             : static long
     570   137379701 : ZX_expispec(GEN x, long nx)
     571             : {
     572   137379701 :   long i, m = 0;
     573  1169478612 :   for(i = 0; i < nx; i++)
     574             :   {
     575  1032138004 :     long e = expi(gel(x,i));
     576  1032098911 :     if (e > m) m = e;
     577             :   }
     578   137340608 :   return m;
     579             : }
     580             : 
     581             : static GEN
     582    50786767 : Z_mod2BIL_ZX(GEN x, long bs, long d, long vx)
     583             : {
     584    50786767 :   long i, offset, lm = lgefint(x)-2, l = d+vx+3, sx = signe(x);
     585    50786767 :   GEN s1 = int2n(bs*BITS_IN_LONG), pol = cgetg(l, t_POL);
     586    50773804 :   int carry = 0;
     587    50773804 :   pol[1] = evalsigne(1);
     588    71277814 :   for (i=0; i<vx; i++) gel(pol,i+2) = gen_0;
     589   967237136 :   for (offset=0; i <= d+vx; i++, offset += bs)
     590             :   {
     591   916806254 :     pari_sp av = avma;
     592   916806254 :     long lz = minss(bs, lm-offset);
     593   918143630 :     GEN z = lz > 0 ?adduispec_offset(carry, x, offset, lz): utoi(carry);
     594   916047702 :     if (lgefint(z) == 3+bs) { carry = 1; z = gen_0;}
     595             :     else
     596             :     {
     597   902719183 :       carry = (lgefint(z) == 2+bs && (HIGHBIT & *int_W(z,bs-1)));
     598   902719183 :       if (carry)
     599    52609123 :         z = gerepileuptoint(av, (sx==-1)? subii(s1,z): subii(z,s1));
     600   850110060 :       else if (sx==-1) togglesign(z);
     601             :     }
     602   916463332 :     gel(pol,i+2) = z;
     603             :   }
     604    50430882 :   return ZX_renormalize(pol,l);
     605             : }
     606             : 
     607             : static GEN
     608    15082130 : ZX_sqrspec_sqri(GEN x, long nx, long ex, long v)
     609             : {
     610    15082130 :   long e = 2*ex + expu(nx) + 3;
     611    15081937 :   long N = divsBIL(e)+1;
     612    15081815 :   GEN  z = sqri(ZX_eval2BILspec(x,N,nx));
     613    15080373 :   return Z_mod2BIL_ZX(z, N, nx*2-2, v);
     614             : }
     615             : 
     616             : static GEN
     617    34648783 : ZX_mulspec_mulii(GEN x, GEN y, long nx, long ny, long ex, long ey, long v)
     618             : {
     619    34648783 :   long e = ex + ey + expu(minss(nx,ny)) + 3;
     620    34647729 :   long N = divsBIL(e)+1;
     621    34647647 :   GEN  z = mulii(ZX_eval2BILspec(x,N,nx), ZX_eval2BILspec(y,N,ny));
     622    34647033 :   return Z_mod2BIL_ZX(z, N, nx+ny-2, v);
     623             : }
     624             : 
     625             : INLINE GEN
     626   242238073 : ZX_sqrspec_basecase_limb(GEN x, long a, long i)
     627             : {
     628   242238073 :   pari_sp av = avma;
     629   242238073 :   GEN s = gen_0;
     630   242238073 :   long j, l = (i+1)>>1;
     631   524498608 :   for (j=a; j<l; j++)
     632             :   {
     633   282984151 :     GEN xj = gel(x,j), xx = gel(x,i-j);
     634   282984151 :     if (signe(xj) && signe(xx))
     635   278829239 :       s = addii(s, mulii(xj, xx));
     636             :   }
     637   241514457 :   s = shifti(s,1);
     638   241692231 :   if ((i&1) == 0)
     639             :   {
     640   147235408 :     GEN t = gel(x, i>>1);
     641   147235408 :     if (signe(t))
     642   146944123 :       s = addii(s, sqri(t));
     643             :   }
     644   241246141 :   return gerepileuptoint(av,s);
     645             : }
     646             : 
     647             : static GEN
     648    52094862 : ZX_sqrspec_basecase(GEN x, long nx, long v)
     649             : {
     650             :   long i, lz, nz;
     651             :   GEN z;
     652             : 
     653    52094862 :   lz = (nx << 1) + 1; nz = lz-2;
     654    52094862 :   lz += v;
     655    52094862 :   z = cgetg(lz,t_POL); z[1] = evalsigne(1); z += 2;
     656    52289591 :   for (i=0; i<v; i++) gel(z++, 0) = gen_0;
     657   199286004 :   for (i=0; i<nx; i++)
     658   147292595 :     gel(z,i) = ZX_sqrspec_basecase_limb(x, 0, i);
     659   147269263 :   for (  ; i<nz; i++) gel(z,i) = ZX_sqrspec_basecase_limb(x, i-nx+1, i);
     660    51995079 :   z -= v+2; return z;
     661             : }
     662             : 
     663             : static GEN
     664    27613828 : Z_sqrshiftspec_ZX(GEN x, long vx)
     665             : {
     666    27613828 :   long i, nz = 2*vx+1;
     667    27613828 :   GEN z = cgetg(2+nz, t_POL);
     668    27608169 :   z[1] = evalsigne(1);
     669    30001641 :   for(i=2;i<nz+1;i++) gel(z,i) = gen_0;
     670    27608169 :   gel(z,nz+1) = sqri(x);
     671    27551731 :   return z;
     672             : }
     673             : 
     674             : static GEN
     675    36272937 : Z_ZX_mulshiftspec(GEN x, GEN y, long ny, long vz)
     676             : {
     677    36272937 :   long i, nz = vz+ny;
     678    36272937 :   GEN z = cgetg(2+nz, t_POL);
     679    36272939 :   z[1] = evalsigne(1);
     680    84504422 :   for (i=0; i<vz; i++)   gel(z,i+2)    = gen_0;
     681   111974088 :   for (i=0; i<ny; i++) gel(z,i+vz+2) = mulii(x, gel(y,i));
     682    36262069 :   return z;
     683             : }
     684             : 
     685             : GEN
     686    95160554 : ZX_sqrspec(GEN x, long nx)
     687             : {
     688             : #ifdef PARI_KERNEL_GMP
     689    54641114 :   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};
     690    54641114 :   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};
     691             : #else
     692    40519440 :   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};
     693    40519440 :   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};
     694             : #endif
     695    95160554 :   const long nblow = numberof(low);
     696             :   pari_sp av;
     697             :   long ex, vx;
     698             :   GEN z;
     699    95160554 :   if (!nx) return pol_0(0);
     700    94682627 :   vx = ZX_valspec(x,nx); nx-=vx; x+=vx;
     701    94790221 :   if (nx==1) return Z_sqrshiftspec_ZX(gel(x, 0), vx);
     702    67174929 :   av = avma;
     703    67174929 :   ex = ZX_expispec(x,nx);
     704    67169160 :   if (nx-2 < nblow && low[nx-2]<=ex && ex<=high[nx-2])
     705    52096662 :     z = ZX_sqrspec_basecase(x, nx, 2*vx);
     706             :   else
     707    15072498 :     z = ZX_sqrspec_sqri(x, nx, ex, 2*vx);
     708    67125560 :   return gerepileupto(av, z);
     709             : }
     710             : 
     711             : GEN
     712    95169150 : ZX_sqr(GEN x)
     713             : {
     714    95169150 :   GEN z = ZX_sqrspec(x+2, lgpol(x));
     715    95017433 :   z[1] = x[1];
     716    95017433 :   return z;
     717             : }
     718             : 
     719             : GEN
     720    92582470 : ZX_mulspec(GEN x, GEN y, long nx, long ny)
     721             : {
     722             :   pari_sp av;
     723             :   long ex, ey, vx, vy, v;
     724    92582470 :   if (!nx || !ny) return pol_0(0);
     725    82845791 :   vx = ZX_valspec(x,nx); nx-=vx; x += vx;
     726    82845501 :   vy = ZX_valspec(y,ny); ny-=vy; y += vy;
     727    82848974 :   v = vx + vy;
     728    82848974 :   if (nx==1) return Z_ZX_mulshiftspec(gel(x,0), y, ny, v);
     729    56104675 :   if (ny==1) return Z_ZX_mulshiftspec(gel(y,0), x, nx, v);
     730    46575790 :   if (nx == 2 && ny == 2)
     731             :   {
     732    11928557 :     GEN a0 = gel(x,0), a1 = gel(x,1), A0, A1, A2;
     733    11928557 :     GEN b0 = gel(y,0), b1 = gel(y,1), z = cgetg(5 + v, t_POL);
     734             :     long i;
     735    11928572 :     z[1] = evalvarn(0) | evalsigne(1);
     736    11928572 :     A0 = mulii(a0, b0);
     737    11928261 :     A2 = mulii(a1, b1); av = avma;
     738    11928173 :     A1 = gerepileuptoint(av, subii(addii(A0,A2),
     739             :                                    mulii(subii(a1,a0), subii(b1,b0))));
     740    11928459 :     i = 4 + v;
     741    11928459 :     gel(z,i--) = A2;
     742    11928459 :     gel(z,i--) = A1;
     743    14005506 :     gel(z,i--) = A0; while (i > 1) gel(z, i--) = gen_0;
     744    11928459 :     return z;
     745             :   }
     746             : #if 0
     747             :   /* generically slower even when degrees differ a lot; sometimes about twice
     748             :    * faster when bitsize is moderate */
     749             :   if (DEBUGVAR)
     750             :     return RgX_mulspec(x - vx, y - vy, nx + vx, ny + vy);
     751             : #endif
     752    34647233 :   av = avma;
     753    34647233 :   ex = ZX_expispec(x, nx);
     754    34647841 :   ey = ZX_expispec(y, ny);
     755    34648446 :   return gerepileupto(av,  ZX_mulspec_mulii(x,y,nx,ny,ex,ey,v));
     756             : }
     757             : GEN
     758    85319819 : ZX_mul(GEN x, GEN y)
     759             : {
     760             :   GEN z;
     761    85319819 :   if (x == y) return ZX_sqr(x);
     762    84583888 :   z = ZX_mulspec(x+2,y+2,lgpol(x),lgpol(y));
     763    84575308 :   z[1] = x[1];
     764    84575308 :   if (!signe(y)) z[1] &= VARNBITS;
     765    84575308 :   return z;
     766             : }
     767             : 
     768             : /* x,y two ZX in the same variable; assume y is monic */
     769             : GEN
     770     9840850 : ZX_rem(GEN x, GEN y)
     771             : {
     772             :   long vx, dx, dy, dz, i, j, sx, lr;
     773             :   pari_sp av0, av;
     774             :   GEN z,p1,rem;
     775             : 
     776     9840850 :   vx = varn(x);
     777     9840850 :   dy = degpol(y);
     778     9840809 :   dx = degpol(x);
     779     9840785 :   if (dx < dy) return ZX_copy(x);
     780     5165949 :   if (!dy) return pol_0(vx); /* y is constant */
     781     5163254 :   av0 = avma; dz = dx-dy;
     782     5163254 :   z=cgetg(dz+3,t_POL); z[1] = x[1];
     783     5163315 :   x += 2; y += 2; z += 2;
     784             : 
     785     5163315 :   p1 = gel(x,dx);
     786     5163315 :   gel(z,dz) = icopy(p1);
     787    27059364 :   for (i=dx-1; i>=dy; i--)
     788             :   {
     789    21896057 :     av=avma; p1=gel(x,i);
     790   211194970 :     for (j=i-dy+1; j<=i && j<=dz; j++)
     791   189307181 :       p1 = subii(p1, mulii(gel(z,j),gel(y,i-j)));
     792    21887789 :     gel(z,i-dy) = avma == av? icopy(p1): gerepileuptoint(av, p1);
     793             :   }
     794     5163307 :   rem = (GEN)avma; av = (pari_sp)new_chunk(dx+3);
     795     7717651 :   for (sx=0; ; i--)
     796             :   {
     797     7717651 :     p1 = gel(x,i);
     798    54189532 :     for (j=0; j<=i && j<=dz; j++)
     799    46472114 :       p1 = subii(p1, mulii(gel(z,j),gel(y,i-j)));
     800     7717418 :     if (signe(p1)) { sx = 1; break; }
     801     2820221 :     if (!i) break;
     802     2554443 :     set_avma(av);
     803             :   }
     804     5162975 :   lr=i+3; rem -= lr;
     805     5162975 :   rem[0] = evaltyp(t_POL) | evallg(lr);
     806     5162949 :   rem[1] = z[-1];
     807     5162949 :   p1 = gerepileuptoint((pari_sp)rem, p1);
     808     5163264 :   rem += 2; gel(rem,i) = p1;
     809    31453403 :   for (i--; i>=0; i--)
     810             :   {
     811    26290351 :     av=avma; p1 = gel(x,i);
     812   245828003 :     for (j=0; j<=i && j<=dz; j++)
     813   219566132 :       p1 = subii(p1, mulii(gel(z,j),gel(y,i-j)));
     814    26261871 :     gel(rem,i) = avma == av? icopy(p1): gerepileuptoint(av, p1);
     815             :   }
     816     5163052 :   rem -= 2;
     817     5163052 :   if (!sx) (void)ZX_renormalize(rem, lr);
     818     5163052 :   return gerepileupto(av0,rem);
     819             : }
     820             : 
     821             : /* return x(1) */
     822             : GEN
     823        4718 : ZX_eval1(GEN x)
     824             : {
     825        4718 :   pari_sp av = avma;
     826        4718 :   long i = lg(x)-1;
     827             :   GEN s;
     828        4718 :   if (i < 2) return gen_0;
     829        4193 :   s = gel(x,i); i--;
     830        4193 :   if (i == 1) return icopy(s);
     831       34608 :   for ( ; i>=2; i--)
     832             :   {
     833       31423 :     GEN c = gel(x,i);
     834       31423 :     if (signe(c)) s = addii(s, c);
     835             :   }
     836        3185 :   return gerepileuptoint(av,s);
     837             : }
     838             : 
     839             : /* reduce T mod X^n - 1. Shallow function */
     840             : GEN
     841     1790643 : ZX_mod_Xnm1(GEN T, ulong n)
     842             : {
     843     1790643 :   long i, j, L = lg(T), l = n+2;
     844             :   GEN S;
     845     1790643 :   if (L <= l) return T;
     846     1599600 :   S = cgetg(l, t_POL);
     847     1599105 :   S[1] = T[1];
     848    12294165 :   for (i = 2; i < l; i++) gel(S,i) = gel(T,i);
     849     7465580 :   for (j = 2; i < L; i++) {
     850     5872618 :     gel(S,j) = addii(gel(S,j), gel(T,i));
     851     5866475 :     if (++j == l) j = 2;
     852             :   }
     853     1592962 :   return normalizepol_lg(S, l);
     854             : }
     855             : 
     856             : static GEN
     857           0 : _ZX_mul(void* E, GEN x, GEN y)
     858           0 : { (void) E; return ZX_mul(x, y); }
     859             : static GEN
     860           0 : _ZX_sqr(void *E, GEN x)
     861           0 : { (void) E; return ZX_sqr(x); }
     862             : 
     863             : static GEN
     864           0 : _ZX_divrem(void * E, GEN x, GEN y, GEN *r)
     865           0 : { (void) E; return RgX_divrem(x, y, r); }
     866             : 
     867             : static GEN
     868           0 : _ZX_add(void * E, GEN x, GEN y)
     869           0 : { (void) E; return ZX_add(x, y); }
     870             : 
     871             : static struct bb_ring ZX_ring = { _ZX_add,_ZX_mul,_ZX_sqr };
     872             : 
     873             : GEN
     874           0 : ZX_digits(GEN x, GEN T)
     875             : {
     876           0 :   long d = degpol(T), n = (lgpol(x)+d-1)/d;
     877           0 :   return gen_digits(x, T, n, NULL, &ZX_ring, _ZX_divrem);
     878             : }
     879             : 
     880             : GEN
     881           0 : ZXV_ZX_fromdigits(GEN x, GEN T)
     882           0 : { return gen_fromdigits(x,T, NULL, &ZX_ring); }
     883             : 
     884             : /*******************************************************************/
     885             : /*                                                                 */
     886             : /*                                ZXV                              */
     887             : /*                                                                 */
     888             : /*******************************************************************/
     889             : 
     890             : int
     891          98 : ZXV_equal(GEN V, GEN W)
     892             : {
     893          98 :   long l = lg(V);
     894          98 :   if (l!=lg(W)) return 0;
     895          98 :   while (--l > 0)
     896          98 :     if (!ZX_equal(gel(V,l), gel(W,l))) return 0;
     897           0 :   return 1;
     898             : }
     899             : 
     900             : GEN
     901        7476 : ZXV_Z_mul(GEN x, GEN y)
     902       29904 : { pari_APPLY_same(ZX_Z_mul(gel(x,i), y)) }
     903             : 
     904             : GEN
     905           0 : ZXV_remi2n(GEN x, long N)
     906           0 : { pari_APPLY_same(ZX_remi2n(gel(x,i), N)) }
     907             : 
     908             : GEN
     909       82943 : ZXV_dotproduct(GEN x, GEN y)
     910             : {
     911       82943 :   pari_sp av = avma;
     912       82943 :   long i, lx = lg(x);
     913             :   GEN c;
     914       82943 :   if (lx == 1) return pol_0(varn(x));
     915       82943 :   c = ZX_mul(gel(x,1), gel(y,1));
     916      392175 :   for (i = 2; i < lx; i++)
     917             :   {
     918      309232 :     GEN t = ZX_mul(gel(x,i), gel(y,i));
     919      309232 :     if (signe(t)) c = ZX_add(c, t);
     920             :   }
     921       82943 :   return gerepileupto(av, c);
     922             : }
     923             : 
     924             : GEN
     925      122289 : ZXC_to_FlxC(GEN x, ulong p, long sv)
     926     5044760 : { pari_APPLY_type(t_COL,typ(gel(x,i))==t_INT ?
     927             :                   Z_to_Flx(gel(x,i), p, sv): ZX_to_Flx(gel(x,i), p)) }
     928             : 
     929             : GEN
     930       11579 : ZXM_to_FlxM(GEN x, ulong p, long sv)
     931      102097 : { pari_APPLY_same(ZXC_to_FlxC(gel(x,i), p, sv)) }
     932             : 
     933             : /*******************************************************************/
     934             : /*                                                                 */
     935             : /*                                ZXQM                             */
     936             : /*                                                                 */
     937             : /*******************************************************************/
     938             : 
     939             : GEN
     940     2598183 : ZXn_mul(GEN x, GEN y, long n)
     941     2598183 : { return RgXn_red_shallow(ZX_mul(x, y), n); }
     942             : 
     943             : GEN
     944        1407 : ZXn_sqr(GEN x, long n)
     945        1407 : { return RgXn_red_shallow(ZX_sqr(x), n); }
     946             : 
     947             : /*******************************************************************/
     948             : /*                                                                 */
     949             : /*                                ZXQM                             */
     950             : /*                                                                 */
     951             : /*******************************************************************/
     952             : 
     953             : static long
     954     3065436 : ZX_expi(GEN x)
     955             : {
     956     3065436 :   if (signe(x)==0) return 0;
     957     1385107 :   if (typ(x)==t_INT) return expi(x);
     958      907245 :   return ZX_expispec(x+2, lgpol(x));
     959             : }
     960             : 
     961             : static long
     962      713417 : ZXC_expi(GEN x)
     963             : {
     964      713417 :   long i, l = lg(x), m=0;
     965     3778853 :   for(i = 1; i < l; i++)
     966             :   {
     967     3065436 :     long e = ZX_expi(gel(x,i));
     968     3065436 :     if (e > m) m = e;
     969             :   }
     970      713417 :   return m;
     971             : }
     972             : 
     973             : static long
     974      137354 : ZXM_expi(GEN x)
     975             : {
     976      137354 :   long i, l = lg(x), m=0;
     977      850771 :   for(i = 1; i < l; i++)
     978             :   {
     979      713417 :     long e = ZXC_expi(gel(x,i));
     980      713417 :     if (e > m) m = e;
     981             :   }
     982      137354 :   return m;
     983             : }
     984             : 
     985             : static GEN
     986     3065436 : ZX_eval2BIL(GEN x, long k)
     987             : {
     988     3065436 :   if (signe(x)==0) return gen_0;
     989     1385107 :   if (typ(x)==t_INT) return x;
     990      907245 :   return ZX_eval2BILspec(x+2, k, lgpol(x));
     991             : }
     992             : 
     993             : /*Eval x in 2^(k*BIL) in linear time*/
     994             : static GEN
     995      713417 : ZXC_eval2BIL(GEN x, long k)
     996             : {
     997      713417 :   long i, lx = lg(x);
     998      713417 :   GEN A = cgetg(lx, t_COL);
     999     3778853 :   for (i=1; i<lx; i++) gel(A,i) = ZX_eval2BIL(gel(x,i), k);
    1000      713417 :   return A;
    1001             : }
    1002             : 
    1003             : static GEN
    1004      137354 : ZXM_eval2BIL(GEN x, long k)
    1005             : {
    1006      137354 :   long i, lx = lg(x);
    1007      137354 :   GEN A = cgetg(lx, t_MAT);
    1008      850771 :   for (i=1; i<lx; i++) gel(A,i) = ZXC_eval2BIL(gel(x,i), k);
    1009      137354 :   return A;
    1010             : }
    1011             : 
    1012             : static GEN
    1013       61292 : Z_mod2BIL_ZXQ(GEN x, long bs, GEN T)
    1014             : {
    1015       61292 :   pari_sp av = avma;
    1016       61292 :   long v = varn(T), d = 2*(degpol(T)-1);
    1017       61292 :   GEN z = Z_mod2BIL_ZX(x, bs, d, 0);
    1018       61292 :   setvarn(z, v);
    1019       61292 :   return gerepileupto(av, ZX_rem(z, T));
    1020             : }
    1021             : 
    1022             : static GEN
    1023       12768 : ZC_mod2BIL_ZXQC(GEN x, long bs, GEN T)
    1024             : {
    1025       12768 :   long i, lx = lg(x);
    1026       12768 :   GEN A = cgetg(lx, t_COL);
    1027       74060 :   for (i=1; i<lx; i++) gel(A,i) = Z_mod2BIL_ZXQ(gel(x,i), bs, T);
    1028       12768 :   return A;
    1029             : }
    1030             : 
    1031             : static GEN
    1032        5957 : ZM_mod2BIL_ZXQM(GEN x, long bs, GEN T)
    1033             : {
    1034        5957 :   long i, lx = lg(x);
    1035        5957 :   GEN A = cgetg(lx, t_MAT);
    1036       18725 :   for (i=1; i<lx; i++) gel(A,i) = ZC_mod2BIL_ZXQC(gel(x,i), bs, T);
    1037        5957 :   return A;
    1038             : }
    1039             : 
    1040             : GEN
    1041        5817 : ZXQM_mul(GEN x, GEN y, GEN T)
    1042             : {
    1043        5817 :   long d = degpol(T);
    1044             :   GEN z;
    1045        5817 :   pari_sp av = avma;
    1046        5817 :   if (d == 0)
    1047           0 :     z = ZM_mul(simplify_shallow(x),simplify_shallow(y));
    1048             :   else
    1049             :   {
    1050        5817 :     long e, N, ex = ZXM_expi(x), ey = ZXM_expi(y), n = lg(x)-1;
    1051        5817 :     e = ex + ey + expu(d) + expu(n) + 4;
    1052        5817 :     N = divsBIL(e)+1;
    1053        5817 :     z = ZM_mul(ZXM_eval2BIL(x,N), ZXM_eval2BIL(y,N));
    1054        5817 :     z = ZM_mod2BIL_ZXQM(z, N, T);
    1055             :   }
    1056        5817 :   return gerepileupto(av, z);
    1057             : }
    1058             : 
    1059             : GEN
    1060         140 : ZXQM_sqr(GEN x, GEN T)
    1061             : {
    1062         140 :   long d = degpol(T);
    1063             :   GEN z;
    1064         140 :   pari_sp av = avma;
    1065         140 :   if (d == 0)
    1066           0 :     z = ZM_sqr(simplify_shallow(x));
    1067             :   else
    1068             :   {
    1069         140 :     long ex = ZXM_expi(x), d = degpol(T), n = lg(x)-1;
    1070         140 :     long e = 2*ex + expu(d) + expu(n) + 4;
    1071         140 :     long N = divsBIL(e)+1;
    1072         140 :     z = ZM_sqr(ZXM_eval2BIL(x,N));
    1073         140 :     z = ZM_mod2BIL_ZXQM(z, N, T);
    1074             :   }
    1075         140 :   return gerepileupto(av, z);
    1076             : }
    1077             : 
    1078             : GEN
    1079        4396 : QXQM_mul(GEN x, GEN y, GEN T)
    1080             : {
    1081        4396 :   GEN dx, nx = Q_primitive_part(x, &dx);
    1082        4396 :   GEN dy, ny = Q_primitive_part(y, &dy);
    1083        4396 :   GEN z = ZXQM_mul(nx, ny, T);
    1084        4396 :   if (dx || dy)
    1085             :   {
    1086        4396 :     GEN d = dx ? dy ? gmul(dx, dy): dx : dy;
    1087        4396 :     if (!gequal1(d)) z = RgM_Rg_mul(z, d);
    1088             :   }
    1089        4396 :   return z;
    1090             : }
    1091             : 
    1092             : GEN
    1093           7 : QXQM_sqr(GEN x, GEN T)
    1094             : {
    1095           7 :   GEN dx, nx = Q_primitive_part(x, &dx);
    1096           7 :   GEN z = ZXQM_sqr(nx, T);
    1097           7 :   if (dx) z = RgM_Rg_mul(z, gsqr(dx));
    1098           7 :   return z;
    1099             : }
    1100             : 
    1101             : static GEN
    1102     1002608 : Z_mod2BIL_Fq(GEN x, long bs, GEN T, GEN p)
    1103             : {
    1104     1002608 :   pari_sp av = avma;
    1105     1002608 :   long v = get_FpX_var(T), d = 2*(get_FpX_degree(T)-1);
    1106     1002608 :   GEN z = Z_mod2BIL_ZX(x, bs, d, 0);
    1107     1002608 :   setvarn(z, v);
    1108     1002608 :   return gerepileupto(av, FpX_rem(z, T, p));
    1109             : }
    1110             : 
    1111             : static GEN
    1112      240617 : ZC_mod2BIL_FqC(GEN x, long bs, GEN T, GEN p)
    1113             : {
    1114      240617 :   long i, lx = lg(x);
    1115      240617 :   GEN A = cgetg(lx, t_COL);
    1116     1243225 :   for (i=1; i<lx; i++) gel(A,i) = Z_mod2BIL_Fq(gel(x,i), bs, T, p);
    1117      240617 :   return A;
    1118             : }
    1119             : 
    1120             : static GEN
    1121       62790 : ZM_mod2BIL_FqM(GEN x, long bs, GEN T, GEN p)
    1122             : {
    1123       62790 :   long i, lx = lg(x);
    1124       62790 :   GEN A = cgetg(lx, t_MAT);
    1125      303407 :   for (i=1; i<lx; i++) gel(A,i) = ZC_mod2BIL_FqC(gel(x,i), bs, T, p);
    1126       62790 :   return A;
    1127             : }
    1128             : 
    1129             : GEN
    1130       62790 : FqM_mul_Kronecker(GEN x, GEN y, GEN T, GEN p)
    1131             : {
    1132       62790 :   pari_sp av = avma;
    1133       62790 :   long ex = ZXM_expi(x), ey = ZXM_expi(y), d= degpol(T), n = lg(x)-1;
    1134       62790 :   long e = ex + ey + expu(d) + expu(n) + 4;
    1135       62790 :   long N = divsBIL(e)+1;
    1136       62790 :   GEN  z = ZM_mul(ZXM_eval2BIL(x,N), ZXM_eval2BIL(y,N));
    1137       62790 :   return gerepileupto(av, ZM_mod2BIL_FqM(z, N, T, p));
    1138             : }
    1139             : 
    1140             : /*******************************************************************/
    1141             : /*                                                                 */
    1142             : /*                                ZXX                              */
    1143             : /*                                                                 */
    1144             : /*******************************************************************/
    1145             : 
    1146             : void
    1147         994 : RgX_check_ZXX(GEN x, const char *s)
    1148             : {
    1149         994 :   long k = lg(x)-1;
    1150        9765 :   for ( ; k>1; k--) {
    1151        8771 :     GEN t = gel(x,k);
    1152        8771 :     switch(typ(t)) {
    1153        7749 :       case t_INT: break;
    1154        1022 :       case t_POL: if (RgX_is_ZX(t)) break;
    1155             :       /* fall through */
    1156           0 :       default: pari_err_TYPE(stack_strcat(s, " not in Z[X,Y]"),x);
    1157             :     }
    1158             :   }
    1159         994 : }
    1160             : 
    1161             : /*Renormalize (in place) polynomial with t_INT or ZX coefficients.*/
    1162             : GEN
    1163   292775791 : ZXX_renormalize(GEN x, long lx)
    1164             : {
    1165             :   long i;
    1166   361948628 :   for (i = lx-1; i>1; i--)
    1167   348375764 :     if (signe(gel(x,i))) break;
    1168   292775791 :   stackdummy((pari_sp)(x + lg(x)), (pari_sp)(x + (i+1)));
    1169   292961165 :   setlg(x, i+1); setsigne(x, i!=1); return x;
    1170             : }
    1171             : 
    1172             : GEN
    1173       28548 : ZXX_evalx0(GEN y)
    1174             : {
    1175       28548 :   long i, l = lg(y);
    1176       28548 :   GEN z = cgetg(l,t_POL); z[1] = y[1];
    1177      480693 :   for(i=2; i<l; i++)
    1178             :   {
    1179      452145 :     GEN yi = gel(y,i);
    1180      452145 :     gel(z,i) = typ(yi)==t_INT? yi: constant_coeff(yi);
    1181             :   }
    1182       28548 :   return ZX_renormalize(z,l);
    1183             : }
    1184             : 
    1185             : long
    1186        5292 : ZXX_max_lg(GEN x)
    1187             : {
    1188        5292 :   long i, prec = 0, lx = lg(x);
    1189       37226 :   for (i=2; i<lx; i++)
    1190             :   {
    1191       31934 :     GEN p = gel(x,i);
    1192       31934 :     long l = (typ(p) == t_INT)? lgefint(p): ZX_max_lg(p);
    1193       31934 :     if (l > prec) prec = l;
    1194             :   }
    1195        5292 :   return prec;
    1196             : }
    1197             : 
    1198             : GEN
    1199        8869 : ZXX_Z_mul(GEN y, GEN x)
    1200             : {
    1201        8869 :   long i, l = lg(y);
    1202        8869 :   GEN z = cgetg(l,t_POL); z[1] = y[1];
    1203      230671 :   for(i=2; i<l; i++)
    1204      221802 :     if(typ(gel(y,i))==t_INT)
    1205           0 :       gel(z,i) = mulii(gel(y,i),x);
    1206             :     else
    1207      221802 :       gel(z,i) = ZX_Z_mul(gel(y,i),x);
    1208        8869 :   return z;
    1209             : }
    1210             : 
    1211             : GEN
    1212           0 : ZXX_Z_add_shallow(GEN x, GEN y)
    1213             : {
    1214           0 :   long i, l = lg(x);
    1215             :   GEN z, a;
    1216           0 :   if (signe(x)==0) return scalarpol(y,varn(x));
    1217           0 :   z = cgetg(l,t_POL); z[1] = x[1];
    1218           0 :   a = gel(x,2);
    1219           0 :   gel(z, 2) = typ(a)==t_INT? addii(a,y): ZX_Z_add(a,y);
    1220           0 :   for(i=3; i<l; i++)
    1221           0 :     gel(z,i) = gel(x,i);
    1222           0 :   return z;
    1223             : }
    1224             : 
    1225             : GEN
    1226       55209 : ZXX_Z_divexact(GEN y, GEN x)
    1227             : {
    1228       55209 :   long i, l = lg(y);
    1229       55209 :   GEN z = cgetg(l,t_POL); z[1] = y[1];
    1230      463008 :   for(i=2; i<l; i++)
    1231      407799 :     if(typ(gel(y,i))==t_INT)
    1232        2989 :       gel(z,i) = diviiexact(gel(y,i),x);
    1233             :     else
    1234      404810 :       gel(z,i) = ZX_Z_divexact(gel(y,i),x);
    1235       55209 :   return z;
    1236             : }
    1237             : 
    1238             : /* Kronecker substitution, ZXX -> ZX:
    1239             :  * P(X,Y) = sum_{0<=i<lP} P_i(X) * Y^i, where deg P_i < n.
    1240             :  * Returns P(X,X^(2n-1)) */
    1241             : GEN
    1242     9993450 : RgXX_to_Kronecker_spec(GEN P, long lP, long n)
    1243             : {
    1244     9993450 :   long i, k, N = (n<<1) + 1;
    1245             :   GEN y;
    1246     9993450 :   if (!lP) return pol_0(0);
    1247     9974160 :   y = cgetg((N-2)*lP + 2, t_POL) + 2;
    1248    45078768 :   for (k=i=0; i<lP; i++)
    1249             :   {
    1250             :     long j;
    1251    45083166 :     GEN c = gel(P,i);
    1252    45083166 :     if (typ(c)!=t_POL)
    1253             :     {
    1254     3195174 :       gel(y,k++) = c;
    1255     3195174 :       j = 3;
    1256             :     }
    1257             :     else
    1258             :     {
    1259    41887992 :       long l = lg(c);
    1260    41887992 :       if (l-3 >= n)
    1261           0 :         pari_err_BUG("RgXX_to_Kronecker, P is not reduced mod Q");
    1262   247378232 :       for (j=2; j < l; j++) gel(y,k++) = gel(c,j);
    1263             :     }
    1264    45085303 :     if (i == lP-1) break;
    1265   195525514 :     for (   ; j < N; j++) gel(y,k++) = gen_0;
    1266             :   }
    1267     9972896 :   y-=2; setlg(y, k+2); y[1] = evalsigne(1); return y;
    1268             : }
    1269             : 
    1270             : /* shallow, n = deg(T) */
    1271             : GEN
    1272     1764417 : Kronecker_to_ZXX(GEN z, long n, long v)
    1273             : {
    1274     1764417 :   long i,j,lx,l, N = (n<<1)+1;
    1275             :   GEN x, t;
    1276     1764417 :   l = lg(z); lx = (l-2) / (N-2);
    1277     1764417 :   x = cgetg(lx+3,t_POL);
    1278     1764348 :   x[1] = z[1];
    1279     8916253 :   for (i=2; i<lx+2; i++)
    1280             :   {
    1281     7151585 :     t = cgetg(N,t_POL); t[1] = evalvarn(v);
    1282   107064758 :     for (j=2; j<N; j++) gel(t,j) = gel(z,j);
    1283     7150922 :     z += (N-2);
    1284     7150922 :     gel(x,i) = ZX_renormalize(t,N);
    1285             :   }
    1286     1764668 :   N = (l-2) % (N-2) + 2;
    1287     1764668 :   t = cgetg(N,t_POL); t[1] = evalvarn(v);
    1288     5125257 :   for (j=2; j<N; j++) gel(t,j) = gel(z,j);
    1289     1764623 :   gel(x,i) = ZX_renormalize(t,N);
    1290     1764542 :   return ZXX_renormalize(x, i+1);
    1291             : }
    1292             : 
    1293             : GEN
    1294     6649167 : RgXX_to_Kronecker(GEN P, long n)
    1295             : {
    1296     6649167 :   GEN z = RgXX_to_Kronecker_spec(P+2, lgpol(P), n);
    1297     6649431 :   setvarn(z,varn(P)); return z;
    1298             : }
    1299             : GEN
    1300     3021260 : ZXX_mul_Kronecker(GEN x, GEN y, long n)
    1301     3021260 : { return ZX_mul(RgXX_to_Kronecker(x,n), RgXX_to_Kronecker(y,n)); }
    1302             : 
    1303             : GEN
    1304        5306 : ZXX_sqr_Kronecker(GEN x, long n)
    1305        5306 : { return ZX_sqr(RgXX_to_Kronecker(x,n)); }
    1306             : 
    1307             : /* shallow, n = deg(T) */
    1308             : GEN
    1309       24143 : Kronecker_to_ZXQX(GEN z, GEN T)
    1310             : {
    1311       24143 :   long i,j,lx,l, N = (degpol(T)<<1)+1;
    1312             :   GEN x, t;
    1313       24143 :   l = lg(z); lx = (l-2) / (N-2);
    1314       24143 :   x = cgetg(lx+3,t_POL);
    1315       24143 :   x[1] = z[1];
    1316      235349 :   for (i=2; i<lx+2; i++)
    1317             :   {
    1318      211206 :     t = cgetg(N,t_POL); t[1] = T[1];
    1319     1889790 :     for (j=2; j<N; j++) gel(t,j) = gel(z,j);
    1320      211205 :     z += (N-2);
    1321      211205 :     gel(x,i) = ZX_rem(ZX_renormalize(t,N), T);
    1322             :   }
    1323       24143 :   N = (l-2) % (N-2) + 2;
    1324       24143 :   t = cgetg(N,t_POL); t[1] = T[1];
    1325       56790 :   for (j=2; j<N; j++) gel(t,j) = gel(z,j);
    1326       24143 :   gel(x,i) = ZX_rem(ZX_renormalize(t,N), T);
    1327       24143 :   return ZXX_renormalize(x, i+1);
    1328             : }
    1329             : 
    1330             : GEN
    1331        1904 : ZXQX_sqr(GEN x, GEN T)
    1332             : {
    1333        1904 :   pari_sp av = avma;
    1334        1904 :   long n = degpol(T);
    1335        1904 :   GEN z = ZXX_sqr_Kronecker(x, n);
    1336        1904 :   z = Kronecker_to_ZXQX(z, T);
    1337        1904 :   return gerepilecopy(av, z);
    1338             : }
    1339             : 
    1340             : GEN
    1341       22239 : ZXQX_mul(GEN x, GEN y, GEN T)
    1342             : {
    1343       22239 :   pari_sp av = avma;
    1344       22239 :   long n = degpol(T);
    1345       22239 :   GEN z = ZXX_mul_Kronecker(x, y, n);
    1346       22239 :   z = Kronecker_to_ZXQX(z, T);
    1347       22239 :   return gerepilecopy(av, z);
    1348             : }
    1349             : 
    1350             : GEN
    1351        8862 : ZXQX_ZXQ_mul(GEN P, GEN U, GEN T)
    1352             : {
    1353             :   long i, lP;
    1354             :   GEN res;
    1355        8862 :   res = cgetg_copy(P, &lP); res[1] = P[1];
    1356       46617 :   for(i=2; i<lP; i++)
    1357       37757 :     gel(res,i) = typ(gel(P,i))==t_POL? ZXQ_mul(U, gel(P,i), T)
    1358       37757 :                                      : gmul(U, gel(P,i));
    1359        8860 :   return ZXX_renormalize(res,lP);
    1360             : }
    1361             : 
    1362             : GEN
    1363     3433357 : QX_mul(GEN x, GEN y)
    1364             : {
    1365     3433357 :   GEN dx, nx = Q_primitive_part(x, &dx);
    1366     3433357 :   GEN dy, ny = Q_primitive_part(y, &dy);
    1367     3433357 :   GEN z = ZX_mul(nx, ny);
    1368     3433357 :   if (dx || dy)
    1369             :   {
    1370     3344852 :     GEN d = dx ? dy ? gmul(dx, dy): dx : dy;
    1371     3344852 :     return ZX_Q_mul(z, d);
    1372             :   } else
    1373       88505 :     return z;
    1374             : }
    1375             : 
    1376             : GEN
    1377       28195 : QX_sqr(GEN x)
    1378             : {
    1379       28195 :   GEN dx, nx = Q_primitive_part(x, &dx);
    1380       28195 :   GEN z = ZX_sqr(nx);
    1381       28195 :   if (dx)
    1382       17829 :     return ZX_Q_mul(z, gsqr(dx));
    1383             :   else
    1384       10366 :     return z;
    1385             : }
    1386             : 
    1387             : GEN
    1388     1685611 : QX_ZX_rem(GEN x, GEN y)
    1389             : {
    1390     1685611 :   pari_sp av = avma;
    1391     1685611 :   GEN d, nx = Q_primitive_part(x, &d);
    1392     1685611 :   GEN r = ZX_rem(nx, y);
    1393     1685611 :   if (d) r = ZX_Q_mul(r, d);
    1394     1685611 :   return gerepileupto(av, r);
    1395             : }
    1396             : 
    1397             : GEN
    1398       13377 : QXQX_mul(GEN x, GEN y, GEN T)
    1399             : {
    1400       13377 :   GEN dx, nx = Q_primitive_part(x, &dx);
    1401       13377 :   GEN dy, ny = Q_primitive_part(y, &dy);
    1402       13377 :   GEN z = ZXQX_mul(nx, ny, T);
    1403       13377 :   if (dx || dy)
    1404             :   {
    1405        8309 :     GEN d = dx ? dy ? gmul(dx, dy): dx : dy;
    1406        8309 :     return ZXX_Q_mul(z, d);
    1407             :   } else
    1408        5068 :     return z;
    1409             : }
    1410             : 
    1411             : GEN
    1412        1904 : QXQX_sqr(GEN x, GEN T)
    1413             : {
    1414        1904 :   GEN dx, nx = Q_primitive_part(x, &dx);
    1415        1904 :   GEN z = ZXQX_sqr(nx, T);
    1416        1904 :   if (dx)
    1417         588 :     return ZXX_Q_mul(z, gsqr(dx));
    1418             :   else
    1419        1316 :     return z;
    1420             : }
    1421             : 
    1422             : GEN
    1423         476 : QXQX_powers(GEN P, long n, GEN T)
    1424             : {
    1425         476 :   GEN v = cgetg(n+2, t_VEC);
    1426             :   long i;
    1427         476 :   gel(v, 1) = pol_1(varn(T));
    1428         476 :   if (n==0) return v;
    1429         476 :   gel(v, 2) = gcopy(P);
    1430        1554 :   for (i = 2; i <= n; i++) gel(v,i+1) = QXQX_mul(P, gel(v,i), T);
    1431         476 :   return v;
    1432             : }
    1433             : 
    1434             : GEN
    1435        3465 : QXQX_QXQ_mul(GEN P, GEN U, GEN T)
    1436             : {
    1437             :   long i, lP;
    1438             :   GEN res;
    1439        3465 :   res = cgetg_copy(P, &lP); res[1] = P[1];
    1440       22715 :   for(i=2; i<lP; i++)
    1441       19250 :     gel(res,i) = typ(gel(P,i))==t_POL? QXQ_mul(U, gel(P,i), T)
    1442       19250 :                                      : gmul(U, gel(P,i));
    1443        3465 :   return ZXX_renormalize(res,lP);
    1444             : }

Generated by: LCOV version 1.14