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 - lfunutils.c (source / functions) Hit Total Coverage
Test: PARI/GP v2.16.2 lcov report (development 29115-f22e516b23) Lines: 1812 1980 91.5 %
Date: 2024-04-22 08:08:03 Functions: 177 187 94.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* Copyright (C) 2015  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             : /********************************************************************/
      16             : /**                                                                **/
      17             : /**                 L-functions: Applications                      **/
      18             : /**                                                                **/
      19             : /********************************************************************/
      20             : 
      21             : #include "pari.h"
      22             : #include "paripriv.h"
      23             : 
      24             : #define DEBUGLEVEL DEBUGLEVEL_lfun
      25             : 
      26             : static GEN
      27       14865 : tag(GEN x, long t) { return mkvec2(mkvecsmall(t), x); }
      28             : 
      29             : /* v a t_VEC of length > 1 */
      30             : static int
      31       82592 : is_tagged(GEN v)
      32             : {
      33       82592 :   GEN T = gel(v,1);
      34       82592 :   return (typ(T)==t_VEC && lg(T)==3 && typ(gel(T,1))==t_VECSMALL);
      35             : }
      36             : /* rough check */
      37             : static long
      38       93096 : is_ldata(GEN L)
      39             : {
      40       93096 :   long l = lg(L);
      41       93096 :   return typ(L) == t_VEC && (l == 7 || l == 8);
      42             : }
      43             : /* thorough check */
      44             : static void
      45       82480 : checkldata(GEN ldata)
      46             : {
      47             :   GEN vga, w, N;
      48             : #if 0 /* assumed already checked and true */
      49             :   if (!is_ldata(ldata) || !is_tagged(ldata)) pari_err_TYPE("checkldata", ldata);
      50             : #endif
      51       82480 :   vga = ldata_get_gammavec(ldata);
      52       82480 :   if (typ(vga) != t_VEC) pari_err_TYPE("checkldata [gammavec]",vga);
      53       82480 :   w = gel(ldata, 4); /* FIXME */
      54       82480 :   switch(typ(w))
      55             :   {
      56       80450 :     case t_INT: case t_FRAC: break;
      57        2030 :     case t_VEC: if (lg(w) == 3 && is_rational_t(typ(gel(w,1)))) break;
      58           0 :     default: pari_err_TYPE("checkldata [weight]",w);
      59             :   }
      60       82480 :   N = ldata_get_conductor(ldata);
      61       82480 :   if (typ(N) != t_INT) pari_err_TYPE("checkldata [conductor]",N);
      62       82480 : }
      63             : 
      64             : /* tag as t_LFUN_GENERIC */
      65             : static void
      66         609 : lfuncreate_tag(GEN L)
      67             : {
      68         609 :   if (is_tagged(L)) return;
      69         448 :   gel(L,1) = tag(gel(L,1), t_LFUN_GENERIC);
      70         448 :   if (typ(gel(L,2)) != t_INT) gel(L,2) = tag(gel(L,2), t_LFUN_GENERIC);
      71             : }
      72             : 
      73             : /* shallow */
      74             : static GEN
      75         168 : closure2ldata(GEN C, long prec)
      76             : {
      77         168 :   GEN L = closure_callgen0prec(C, prec);
      78         168 :   if (is_ldata(L)) { checkldata(L); lfuncreate_tag(L); }
      79          56 :   else L = lfunmisc_to_ldata_shallow(L);
      80         168 :   return L;
      81             : }
      82             : 
      83             : /* data may be either an object (polynomial, elliptic curve, etc...)
      84             :  * or a description vector [an,sd,Vga,k,conductor,rootno,{poles}]. */
      85             : GEN
      86        1883 : lfuncreate(GEN data)
      87             : {
      88        1883 :   if (is_ldata(data))
      89             :   {
      90         497 :     GEN L = gcopy(data);
      91         497 :     lfuncreate_tag(L); checkldata(L); return L;
      92             :   }
      93        1386 :   if (typ(data) == t_CLOSURE && closure_arity(data)==0)
      94             :   {
      95          14 :     pari_sp av = avma;
      96          14 :     GEN L = closure2ldata(data, DEFAULTPREC);
      97          14 :     gel(L,1) = tag(data, t_LFUN_CLOSURE0); return gerepilecopy(av, L);
      98             :   }
      99        1372 :   return lfunmisc_to_ldata(data);
     100             : }
     101             : 
     102             : GEN
     103         133 : lfunparams(GEN L, long prec)
     104             : {
     105         133 :   pari_sp av = avma;
     106             :   GEN k, N, v;
     107             :   long p;
     108             : 
     109         133 :   if (!is_ldata(L) || !is_tagged(L)) L = lfunmisc_to_ldata_shallow(L);
     110         133 :   N = ldata_get_conductor(L);
     111         133 :   k = ldata_get_k(L);
     112         133 :   v = ldata_get_gammavec(L);
     113         133 :   p = gprecision(v);
     114         133 :   if (p > prec) v = gprec_wtrunc(v, prec);
     115         133 :   else if (p < prec)
     116             :   {
     117         133 :     GEN van = ldata_get_an(L), an = gel(van,2);
     118         133 :     long t = mael(van,1,1);
     119         133 :     if (t == t_LFUN_CLOSURE0) L = closure2ldata(an, prec);
     120             :   }
     121         133 :   return gerepilecopy(av, mkvec3(N, k, v));
     122             : }
     123             : 
     124             : /********************************************************************/
     125             : /**                     Simple constructors                        **/
     126             : /********************************************************************/
     127             : static GEN ldata_eulerf(GEN van, GEN p, long prec);
     128             : 
     129             : static GEN
     130         126 : vecan_conj(GEN an, long n, long prec)
     131             : {
     132         126 :   GEN p1 = ldata_vecan(gel(an,1), n, prec);
     133         126 :   return typ(p1) == t_VEC? conj_i(p1): p1;
     134             : }
     135             : 
     136             : static GEN
     137           0 : eulerf_conj(GEN an, GEN p, long prec)
     138             : {
     139           0 :   GEN p1 = ldata_eulerf(gel(an,1), p, prec);
     140           0 :   return conj_i(p1);
     141             : }
     142             : 
     143             : static GEN
     144         308 : vecan_mul(GEN an, long n, long prec)
     145             : {
     146         308 :   GEN p1 = ldata_vecan(gel(an,1), n, prec);
     147         308 :   GEN p2 = ldata_vecan(gel(an,2), n, prec);
     148         308 :   if (typ(p1) == t_VECSMALL) p1 = vecsmall_to_vec(p1);
     149         308 :   if (typ(p2) == t_VECSMALL) p2 = vecsmall_to_vec(p2);
     150         308 :   return dirmul(p1, p2);
     151             : }
     152             : 
     153             : static GEN
     154          28 : eulerf_mul(GEN an, GEN p, long prec)
     155             : {
     156          28 :   GEN p1 = ldata_eulerf(gel(an,1), p, prec);
     157          28 :   GEN p2 = ldata_eulerf(gel(an,2), p, prec);
     158          28 :   return gmul(p1, p2);
     159             : }
     160             : 
     161             : static GEN
     162          77 : lfunconvol(GEN a1, GEN a2)
     163          77 : { return tag(mkvec2(a1, a2), t_LFUN_MUL); }
     164             : 
     165             : static GEN
     166         616 : vecan_div(GEN an, long n, long prec)
     167             : {
     168         616 :   GEN p1 = ldata_vecan(gel(an,1), n, prec);
     169         616 :   GEN p2 = ldata_vecan(gel(an,2), n, prec);
     170         616 :   if (typ(p1) == t_VECSMALL) p1 = vecsmall_to_vec(p1);
     171         616 :   if (typ(p2) == t_VECSMALL) p2 = vecsmall_to_vec(p2);
     172         616 :   return dirdiv(p1, p2);
     173             : }
     174             : 
     175             : static GEN
     176          14 : eulerf_div(GEN an, GEN p, long prec)
     177             : {
     178          14 :   GEN p1 = ldata_eulerf(gel(an,1), p, prec);
     179          14 :   GEN p2 = ldata_eulerf(gel(an,2), p, prec);
     180          14 :   return gdiv(p1, p2);
     181             : }
     182             : 
     183             : static GEN
     184          56 : lfunconvolinv(GEN a1, GEN a2)
     185          56 : { return tag(mkvec2(a1,a2), t_LFUN_DIV); }
     186             : 
     187             : static GEN
     188          84 : lfunconj(GEN a1)
     189          84 : { return tag(mkvec(a1), t_LFUN_CONJ); }
     190             : 
     191             : static GEN
     192         133 : lfuncombdual(GEN (*fun)(GEN, GEN), GEN ldata1, GEN ldata2)
     193             : {
     194         133 :   GEN a1 = ldata_get_an(ldata1), a2 = ldata_get_an(ldata2);
     195         133 :   GEN b1 = ldata_get_dual(ldata1), b2 = ldata_get_dual(ldata2);
     196         133 :   if (typ(b1)==t_INT && typ(b2)==t_INT)
     197         133 :     return utoi(signe(b1) || signe(b2));
     198             :   else
     199             :   {
     200           0 :     if (typ(b1)==t_INT) b1 = signe(b1) ? lfunconj(a1): a1;
     201           0 :     if (typ(b2)==t_INT) b2 = signe(b2) ? lfunconj(a2): a2;
     202           0 :     return fun(b1, b2);
     203             :   }
     204             : }
     205             : 
     206             : static GEN
     207         581 : vecan_twist(GEN an, long n, long prec)
     208             : {
     209         581 :   GEN p1 = ldata_vecan(gel(an,1), n, prec);
     210         581 :   GEN p2 = ldata_vecan(gel(an,2), n, prec);
     211             :   long i;
     212             :   GEN V;
     213         581 :   if (typ(p1) == t_VECSMALL) p1 = vecsmall_to_vec(p1);
     214         581 :   if (typ(p2) == t_VECSMALL) p2 = vecsmall_to_vec(p2);
     215         581 :   V = cgetg(n+1, t_VEC);
     216      415695 :   for(i = 1; i <= n ; i++)
     217      415114 :     gel(V, i) = gmul(gel(p1, i), gel(p2, i));
     218         581 :   return V;
     219             : }
     220             : 
     221             : static GEN
     222          14 : eulerf_twist(GEN an, GEN p, long prec)
     223             : {
     224          14 :   GEN p1 = ldata_eulerf(gel(an,1), p, prec);
     225          14 :   GEN p2 = ginv(ldata_eulerf(gel(an,2), p, prec));
     226          14 :   if (typ(p2)!=t_POL || degpol(p2)==0)
     227           0 :     return poleval(p1,pol_0(0));
     228          14 :   if (degpol(p2)!=1) pari_err_IMPL("lfuneuler");
     229          14 :   return poleval(p1,monomial(gneg(gel(p2,3)),1,0));
     230             : }
     231             : 
     232             : static GEN
     233         637 : vecan_shift(GEN an, long n, long prec)
     234             : {
     235         637 :   GEN p1 = ldata_vecan(gel(an,1), n, prec);
     236         637 :   GEN s = gel(an,2);
     237             :   long i;
     238             :   GEN V;
     239         637 :   if (typ(p1) == t_VECSMALL) p1 = vecsmall_to_vec(p1);
     240         637 :   V = cgetg(n+1, t_VEC);
     241         637 :   if (typ(s)==t_INT)
     242             :   {
     243         448 :     if (equali1(s))
     244       31850 :       for(i = 1; i <= n ; i++)
     245             :       {
     246       31500 :         GEN gi = gel(p1, i);
     247       31500 :         gel(V, i) = gequal0(gi)? gi: gmulgu(gi, i);
     248             :       }
     249             :     else
     250        1848 :       for(i = 1; i <= n ; i++)
     251             :       {
     252        1750 :         GEN gi = gel(p1, i);
     253        1750 :         gel(V, i) = gequal0(gi)? gi: gmul(gi, powgi(utoi(i), s));
     254             :       }
     255             :   }
     256             :   else
     257             :   {
     258         189 :     GEN D = dirpowers(n, s, prec);
     259        7049 :     for(i = 1; i <= n ; i++)
     260        6860 :       gel(V, i) = gmul(gel(p1,i), gel(D,i));
     261             :   }
     262         637 :   return V;
     263             : }
     264             : 
     265             : static GEN
     266          42 : eulerf_shift(GEN an, GEN p, long prec)
     267             : {
     268          42 :   GEN p1 = ldata_eulerf(gel(an,1), p, prec);
     269          42 :   GEN s = gel(an,2);
     270          42 :   return gsubst(p1, 0, monomial(gpow(p, s, prec), 1, 0));
     271             : }
     272             : 
     273             : static GEN
     274          84 : eulerf_hgm(GEN an, GEN p)
     275             : {
     276          84 :   GEN H = gel(an,1), t = gel(an,2);
     277          84 :   if (typ(t)==t_VEC && lg(t)==3)
     278             :   {
     279          28 :     GEN L = gel(t,2);
     280          28 :     long i, l = lg(L);
     281          28 :     t = gel(t,1);
     282          49 :     for (i = 1; i < l; i++) /* wild primes */
     283          35 :       if (equalii(p, gmael(L, i, 1))) break;
     284          28 :     if (i<l) return gmael(L,i,2);
     285             :   }
     286          70 :   return ginv(hgmeulerfactor(H, t, itos(p), NULL));
     287             : }
     288             : 
     289             : static GEN
     290         315 : deg1ser_shallow(GEN a1, GEN a0, long e)
     291         315 : { return RgX_to_ser(deg1pol_shallow(a1, a0, 0), e+2); }
     292             : /* lfunrtopoles without sort */
     293             : static GEN
     294         168 : rtopoles(GEN r)
     295             : {
     296         168 :   long j, l = lg(r);
     297         168 :   GEN v = cgetg(l, t_VEC);
     298         350 :   for (j = 1; j < l; j++)
     299             :   {
     300         182 :     GEN rj = gel(r,j), a = gel(rj,1);
     301         182 :     gel(v,j) = a;
     302             :   }
     303         168 :   return v;
     304             : }
     305             : /* re = polar part; overestimate when re = gen_0 (unknown) */
     306             : static long
     307         266 : orderpole(GEN re) { return typ(re) == t_SER? -valser(re): 1; }
     308             : static GEN
     309          77 : lfunmulpoles(GEN ldata1, GEN ldata2, long bitprec)
     310             : {
     311          77 :   GEN r, k = ldata_get_k(ldata1), b1 = NULL, b2 = NULL;
     312          77 :   GEN r1 = ldata_get_residue(ldata1);
     313          77 :   GEN r2 = ldata_get_residue(ldata2);
     314          77 :   long i, j, l, L = 0;
     315             : 
     316          77 :   if (!r1 && !r2) return NULL;
     317          70 :   if (r1 && !is_vec_t(typ(r1))) r1 = mkvec(mkvec2(k, r1));
     318          70 :   if (r2 && !is_vec_t(typ(r2))) r2 = mkvec(mkvec2(k, r2));
     319          70 :   if (r1) { b1 = rtopoles(r1); L += lg(b1); }
     320          70 :   if (r2) { b2 = rtopoles(r2); L += lg(b2); }
     321          70 :   r = cgetg(L, t_VEC); j = 1;
     322          70 :   if (b1)
     323             :   {
     324          63 :     l = lg(b1);
     325         133 :     for (i = 1; i < l; i++)
     326             :     {
     327          70 :       GEN z, z1, z2, be = gmael(r1,i,1);
     328          70 :       long n, v = orderpole(gmael(r1,i,2));
     329          70 :       if (b2 && (n = RgV_isin(b2, be))) v += orderpole(gmael(r2,n,2));
     330          70 :       z = deg1ser_shallow(gen_1, be, 2 + v);
     331          70 :       z1 = lfun(ldata1,z,bitprec);
     332          70 :       z2 = lfun(ldata2,z,bitprec);
     333          70 :       gel(r,j++) = mkvec2(be, gmul(z1, z2));
     334             :     }
     335             :   }
     336          70 :   if (b2)
     337             :   {
     338          63 :     long l = lg(b2);
     339         133 :     for (i = 1; i < l; i++)
     340             :     {
     341          70 :       GEN z, z1, z2, be = gmael(r2,i,1);
     342          70 :       long n, v = orderpole(gmael(r2,i,2));
     343          70 :       if (b1 && (n = RgV_isin(b1, be))) continue; /* done already */
     344          28 :       z = deg1ser_shallow(gen_1, be, 2 + v);
     345          28 :       z1 = lfun(ldata1,z,bitprec);
     346          28 :       z2 = lfun(ldata2,z,bitprec);
     347          28 :       gel(r,j++) = mkvec2(be, gmul(z1, z2));
     348             :     }
     349             :   }
     350          70 :   setlg(r, j); return r;
     351             : }
     352             : 
     353             : static GEN
     354          77 : lfunmul_k(GEN ldata1, GEN ldata2, GEN k, long bitprec)
     355             : {
     356             :   GEN r, N, Vga, eno, a1a2, b1b2;
     357          77 :   r = lfunmulpoles(ldata1, ldata2, bitprec);
     358          77 :   N = gmul(ldata_get_conductor(ldata1), ldata_get_conductor(ldata2));
     359          77 :   Vga = shallowconcat(ldata_get_gammavec(ldata1), ldata_get_gammavec(ldata2));
     360          77 :   Vga = sort(Vga);
     361          77 :   eno = gmul(ldata_get_rootno(ldata1), ldata_get_rootno(ldata2));
     362          77 :   a1a2 = lfunconvol(ldata_get_an(ldata1), ldata_get_an(ldata2));
     363          77 :   b1b2 = lfuncombdual(lfunconvol, ldata1, ldata2);
     364          77 :   return mkvecn(r? 7: 6, a1a2, b1b2, Vga, k, N, eno, r);
     365             : }
     366             : 
     367             : GEN
     368          63 : lfunmul(GEN ldata1, GEN ldata2, long bitprec)
     369             : {
     370          63 :   pari_sp ltop = avma;
     371             :   GEN k;
     372          63 :   long prec = nbits2prec(bitprec);
     373          63 :   ldata1 = ldata_newprec(lfunmisc_to_ldata_shallow(ldata1), prec);
     374          63 :   ldata2 = ldata_newprec(lfunmisc_to_ldata_shallow(ldata2), prec);
     375          63 :   k = ldata_get_k(ldata1);
     376          63 :   if (!gequal(ldata_get_k(ldata2),k))
     377           0 :     pari_err_OP("lfunmul [weight]",ldata1, ldata2);
     378          63 :   return gerepilecopy(ltop, lfunmul_k(ldata1, ldata2, k, bitprec));
     379             : }
     380             : 
     381             : static GEN
     382          56 : lfundivpoles(GEN ldata1, GEN ldata2, long bitprec)
     383             : {
     384             :   long i, j, l;
     385          56 :   GEN be2, k  = ldata_get_k(ldata1);
     386          56 :   GEN r1 = ldata_get_residue(ldata1);
     387          56 :   GEN r2 = ldata_get_residue(ldata2), r;
     388             : 
     389          56 :   if (r1 && !is_vec_t(typ(r1))) r1 = mkvec(mkvec2(k, r1));
     390          56 :   if (r2 && !is_vec_t(typ(r2))) r2 = mkvec(mkvec2(k, r2));
     391          56 :   if (!r1) return NULL;
     392          56 :   l = lg(r1); r = cgetg(l, t_VEC);
     393          56 :   be2 = r2? rtopoles(r2): NULL;
     394         112 :   for (i = j = 1; j < l; j++)
     395             :   {
     396          56 :     GEN z, v = gel(r1,j), be = gel(v,1), s1 = gel(v,2);
     397             :     long n;
     398          56 :     if (be2 && (n = RgV_isin(be2, be)))
     399             :     {
     400          42 :       GEN s2 = gmael(r2,n,2); /* s1,s2: polar parts */
     401          42 :       if (orderpole(s1) == orderpole(s2)) continue;
     402             :     }
     403          14 :     z = gdiv(lfun(ldata1,be,bitprec), lfun(ldata2,be,bitprec));
     404          14 :     if (valser(z) < 0) gel(r,i++) = mkvec2(be, z);
     405             :   }
     406          56 :   if (i == 1) return NULL;
     407          14 :   setlg(r, i); return r;
     408             : }
     409             : 
     410             : static GEN
     411          56 : lfunvgasub(GEN v01, GEN v2)
     412             : {
     413          56 :   GEN v1 = shallowcopy(v01), v;
     414          56 :   long l1 = lg(v1), l2 = lg(v2), j1, j2, j;
     415         119 :   for (j2 = 1; j2 < l2; j2++)
     416             :   {
     417          91 :     for (j1 = 1; j1 < l1; j1++)
     418          91 :       if (gel(v1,j1) && gequal(gel(v1,j1), gel(v2,j2)))
     419             :       {
     420          63 :         gel(v1,j1) = NULL; break;
     421             :       }
     422          63 :     if (j1 == l1) pari_err_OP("lfunvgasub", v1, v2);
     423             :   }
     424          56 :   v = cgetg(l1-l2+1, t_VEC);
     425         259 :   for (j1 = j = 1; j1 < l1; j1++)
     426         203 :     if (gel(v1, j1)) gel(v,j++) = gel(v1,j1);
     427          56 :   return v;
     428             : }
     429             : 
     430             : GEN
     431          56 : lfundiv(GEN ldata1, GEN ldata2, long bitprec)
     432             : {
     433          56 :   pari_sp ltop = avma;
     434             :   GEN k, r, N, v, eno, a1a2, b1b2, eno2;
     435          56 :   long prec = nbits2prec(bitprec);
     436          56 :   ldata1 = ldata_newprec(lfunmisc_to_ldata_shallow(ldata1), prec);
     437          56 :   ldata2 = ldata_newprec(lfunmisc_to_ldata_shallow(ldata2), prec);
     438          56 :   k = ldata_get_k(ldata1);
     439          56 :   if (!gequal(ldata_get_k(ldata2),k))
     440           0 :     pari_err_OP("lfundiv [weight]",ldata1, ldata2);
     441          56 :   N = gdiv(ldata_get_conductor(ldata1), ldata_get_conductor(ldata2));
     442          56 :   if (typ(N) != t_INT) pari_err_OP("lfundiv [conductor]",ldata1, ldata2);
     443          56 :   r = lfundivpoles(ldata1, ldata2, bitprec);
     444          56 :   a1a2 = lfunconvolinv(ldata_get_an(ldata1), ldata_get_an(ldata2));
     445          56 :   b1b2 = lfuncombdual(lfunconvolinv, ldata1, ldata2);
     446          56 :   eno2 = ldata_get_rootno(ldata2);
     447          56 :   eno = isintzero(eno2)? gen_0: gdiv(ldata_get_rootno(ldata1), eno2);
     448          56 :   v = lfunvgasub(ldata_get_gammavec(ldata1), ldata_get_gammavec(ldata2));
     449          56 :   return gerepilecopy(ltop,  mkvecn(r? 7: 6, a1a2, b1b2, v, k, N, eno, r));
     450             : }
     451             : 
     452             : static GEN
     453         245 : gamma_imagchi(GEN gam, GEN w)
     454             : {
     455         245 :   long i, j, k=1, l;
     456         245 :   GEN g = cgetg_copy(gam, &l);
     457         245 :   gam = shallowcopy(gam);
     458         735 :   for (i = l-1; i>=1; i--)
     459             :   {
     460         490 :     GEN al = gel(gam, i);
     461         490 :     if (al)
     462             :     {
     463         252 :       GEN N = gadd(w,gmul2n(real_i(al),1));
     464         252 :       if (gcmpgs(N,2) > 0)
     465             :       {
     466         238 :         GEN bl = gsubgs(al, 1);
     467         238 :         for (j=1; j < i; j++)
     468         238 :           if (gel(gam,j) && gequal(gel(gam,j), bl))
     469         238 :           { gel(gam,j) = NULL; break; }
     470         238 :         if (j==i) return NULL;
     471         238 :         gel(g, k++) = al;
     472         238 :         gel(g, k++) = bl;
     473          14 :       } else if (gequal0(N))
     474          14 :         gel(g, k++) = gaddgs(al, 1);
     475           0 :       else if (gequal1(N))
     476           0 :         gel(g, k++) = gsubgs(al, 1);
     477           0 :       else return NULL;
     478             :     }
     479             :   }
     480         245 :   return sort(g);
     481             : }
     482             : 
     483             : GEN
     484         889 : lfuntwist(GEN ldata1, GEN chi, long bitprec)
     485             : {
     486         889 :   pari_sp ltop = avma;
     487             :   GEN k, L, N, N1, N2, a, a1, a2, b, b1, b2, gam, gam1, gam2;
     488             :   GEN ldata2;
     489             :   long d1, t;
     490         889 :   long prec = nbits2prec(bitprec);
     491         889 :   ldata1 = ldata_newprec(lfunmisc_to_ldata_shallow(ldata1), prec);
     492         889 :   ldata2 = lfunmisc_to_ldata_shallow(chi);
     493         889 :   t = ldata_get_type(ldata2);
     494         889 :   a1 = ldata_get_an(ldata1);
     495         889 :   a2 = ldata_get_an(ldata2);
     496         889 :   if (t == t_LFUN_ZETA)
     497         427 :     return gerepilecopy(ltop, ldata1);
     498         462 :   if (t != t_LFUN_CHIZ && t != t_LFUN_KRONECKER &&
     499           7 :     ( t != t_LFUN_CHIGEN || nf_get_degree(bnr_get_nf(gmael(a2,2,1))) != 1))
     500           0 :     pari_err_TYPE("lfuntwist", chi);
     501         462 :   N1 = ldata_get_conductor(ldata1);
     502         462 :   N2 = ldata_get_conductor(ldata2);
     503         462 :   if (!gequal1(gcdii(N1, N2)))
     504           0 :     pari_err_IMPL("lfuntwist (conductors not coprime)");
     505         462 :   k = ldata_get_k(ldata1);
     506         462 :   d1 = ldata_get_degree(ldata1);
     507         462 :   N = gmul(N1, gpowgs(N2, d1));
     508         462 :   gam1 = ldata_get_gammavec(ldata1);
     509         462 :   gam2 = ldata_get_gammavec(ldata2);
     510         462 :   if (gequal0(gel(gam2, 1)))
     511         217 :     gam = gam1;
     512             :   else
     513         245 :     gam = gamma_imagchi(ldata_get_gammavec(ldata1), gaddgs(k,-1));
     514         462 :   if (!gam) pari_err_IMPL("lfuntwist (gammafactors)");
     515         462 :   b1 = ldata_get_dual(ldata1);
     516         462 :   b2 = ldata_get_dual(ldata2);
     517         462 :   a = tag(mkvec2(a1, a2), t_LFUN_TWIST);
     518         462 :   if (typ(b1)==t_INT)
     519         462 :     b = signe(b1) && signe(b2) ? gen_0: gen_1;
     520             :   else
     521           0 :     b = tag(mkvec2(b1,lfunconj(a2)), t_LFUN_TWIST);
     522         462 :   L = mkvecn(6, a, b, gam, k, N, gen_0);
     523         462 :   return gerepilecopy(ltop, L);
     524             : }
     525             : 
     526             : static GEN
     527         280 : lfundualpoles(GEN ldata, GEN reno)
     528             : {
     529             :   long l, j;
     530         280 :   GEN k = ldata_get_k(ldata);
     531         280 :   GEN r = gel(reno,2), eno = gel(reno,3), R;
     532         280 :   R = cgetg_copy(r, &l);
     533         854 :   for (j = 1; j < l; j++)
     534             :   {
     535         574 :     GEN b = gmael(r,j,1), e = gmael(r,j,2);
     536         574 :     long v = varn(e);
     537         574 :     GEN E = gsubst(gdiv(e, eno), v, gneg(pol_x(v)));
     538         574 :     gel(R,l-j) = mkvec2(gsub(k,b), E);
     539             :   }
     540         280 :   return R;
     541             : }
     542             : 
     543             : static GEN
     544         567 : ginvvec(GEN x)
     545             : {
     546         567 :   if (is_vec_t(typ(x)))
     547          42 :     pari_APPLY_same(ginv(gel(x,i)))
     548             :   else
     549         553 :     return ginv(x);
     550             : }
     551             : 
     552             : GEN
     553         630 : lfundual(GEN L, long bitprec)
     554             : {
     555         630 :   pari_sp av = avma;
     556         630 :   long prec = nbits2prec(bitprec);
     557         630 :   GEN ldata = ldata_newprec(lfunmisc_to_ldata_shallow(L), prec);
     558         630 :   GEN a = ldata_get_an(ldata), b = ldata_get_dual(ldata);
     559         630 :   GEN e = ldata_get_rootno(ldata);
     560         630 :   GEN ldual, ad, bd, ed, Rd = NULL;
     561         630 :   if (typ(b) == t_INT)
     562             :   {
     563         602 :     ad = equali1(b) ? lfunconj(a): a;
     564         602 :     bd = b;
     565             :   }
     566          28 :   else { ad = b; bd = a; }
     567         630 :   if (lg(ldata)==8)
     568             :   {
     569         280 :     GEN reno = lfunrootres(ldata, bitprec);
     570         280 :     e = gel(reno,3);
     571         280 :     Rd = lfundualpoles(ldata, reno);
     572             :   }
     573         630 :   ed = isintzero(e) ? e: ginvvec(e);
     574         630 :   ldual = mkvecn(Rd ? 7:6, ad, bd, gel(ldata,3), gel(ldata,4), gel(ldata,5), ed, Rd);
     575         630 :   return gerepilecopy(av, ldual);
     576             : }
     577             : 
     578             : static GEN
     579          98 : RgV_Rg_translate(GEN x, GEN s)
     580         259 : { pari_APPLY_same(gadd(gel(x,i),s)) }
     581             : 
     582             : static GEN
     583          28 : pole_translate(GEN x, GEN s, GEN Ns)
     584             : {
     585          28 :   x = shallowcopy(x);
     586          28 :   gel(x,1) = gadd(gel(x,1), s);
     587          28 :   if (Ns)
     588          28 :     gel(x,2) = gmul(gel(x,2), Ns);
     589          28 :   return x;
     590             : }
     591             : 
     592             : static GEN
     593          14 : poles_translate(GEN x, GEN s, GEN Ns)
     594          42 : { pari_APPLY_same(pole_translate(gel(x,i), s, Ns)) }
     595             : 
     596             : /* r / x + O(1) */
     597             : static GEN
     598         266 : simple_pole(GEN r)
     599             : {
     600             :   GEN S;
     601         266 :   if (isintzero(r)) return gen_0;
     602         217 :   S = deg1ser_shallow(gen_0, r, 1);
     603         217 :   setvalser(S, -1); return S;
     604             : }
     605             : 
     606             : GEN
     607          98 : lfunshift(GEN ldata, GEN s, long flag, long bitprec)
     608             : {
     609          98 :   pari_sp ltop = avma;
     610             :   GEN k, k1, L, N, a, b, gam, eps, res;
     611          98 :   long prec = nbits2prec(bitprec);
     612          98 :   if (!is_rational_t(typ(s))) pari_err_TYPE("lfunshift",s);
     613          98 :   ldata = ldata_newprec(lfunmisc_to_ldata_shallow(ldata), prec);
     614          98 :   a = ldata_get_an(ldata);
     615          98 :   b = ldata_get_dual(ldata);
     616          98 :   gam = RgV_Rg_translate(ldata_get_gammavec(ldata), gneg(s));
     617          98 :   k = gadd(ldata_get_k(ldata), gmul2n(s, 1));
     618          98 :   k1 = gadd(ldata_get_k1(ldata), s);
     619          98 :   N = ldata_get_conductor(ldata);
     620          98 :   eps = ldata_get_rootno(ldata);
     621          98 :   res = ldata_get_residue(ldata);
     622          98 :   a = tag(mkvec2(a, s), t_LFUN_SHIFT);
     623          98 :   if (typ(b) != t_INT)
     624           0 :     b = tag(mkvec2(b, s), t_LFUN_SHIFT);
     625          98 :   if (res)
     626          98 :     switch(typ(res))
     627             :     {
     628           0 :     case t_VEC:
     629           0 :       res = poles_translate(res, s, NULL);
     630           0 :       break;
     631          14 :     case t_COL:
     632          14 :       res = poles_translate(res, s, gpow(N, gmul2n(s, -1), prec));
     633          14 :       break;
     634          84 :     default:
     635          84 :       res = mkvec(mkvec2(gsub(k, s), simple_pole(res)));
     636             :     }
     637          98 :   L = mkvecn(res ? 7: 6, a, b, gam, mkvec2(k, k1), N, eps, res);
     638          98 :   if (flag) L = lfunmul_k(ldata, L, gsub(k, s), bitprec);
     639          98 :   return gerepilecopy(ltop, L);
     640             : }
     641             : 
     642             : /*****************************************************************/
     643             : /*  L-series from closure                                        */
     644             : /*****************************************************************/
     645             : static GEN
     646       58954 : localfactor(void *E, GEN p, long n)
     647             : {
     648       58954 :   GEN s = closure_callgen2((GEN)E, p, utoi(n));
     649       58954 :   return direuler_factor(s, n);
     650             : }
     651             : static GEN
     652        1925 : vecan_closure(GEN a, long L, long prec)
     653             : {
     654        1925 :   long ta = typ(a);
     655        1925 :   GEN gL, Sbad = NULL;
     656             : 
     657        1925 :   if (!L) return cgetg(1,t_VEC);
     658        1925 :   if (ta == t_VEC)
     659             :   {
     660        1008 :     long l = lg(a);
     661        1008 :     if (l == 1) pari_err_TYPE("vecan_closure", a);
     662        1008 :     ta = typ(gel(a,1));
     663             :     /* regular vector, return it */
     664        1008 :     if (ta != t_CLOSURE) return vecslice(a, 1, minss(L,l-1));
     665         119 :     if (l != 3) pari_err_TYPE("vecan_closure", a);
     666         119 :     Sbad = gel(a,2);
     667         119 :     if (typ(Sbad) != t_VEC) pari_err_TYPE("vecan_closure", a);
     668         112 :     a = gel(a,1);
     669             :   }
     670         917 :   else if (ta != t_CLOSURE) pari_err_TYPE("vecan_closure", a);
     671        1015 :   push_localprec(prec);
     672        1015 :   gL = stoi(L);
     673        1015 :   switch(closure_arity(a))
     674             :   {
     675         371 :     case 2:
     676         371 :       a = direuler_bad((void*)a, localfactor, gen_2, gL,gL, Sbad);
     677         336 :       break;
     678         637 :     case 1:
     679         637 :       a = closure_callgen1(a, gL);
     680         637 :       if (typ(a) != t_VEC) pari_err_TYPE("vecan_closure", a);
     681         630 :       break;
     682           7 :     default: pari_err_TYPE("vecan_closure [wrong arity]", a);
     683             :       a = NULL; /*LCOV_EXCL_LINE*/
     684             :   }
     685         966 :   pop_localprec(); return a;
     686             : }
     687             : 
     688             : static GEN
     689          70 : eulerf_closure(GEN a, GEN p, long prec)
     690             : {
     691          70 :   long ta = typ(a);
     692          70 :   GEN Sbad = NULL, f;
     693             : 
     694          70 :   if (ta == t_VEC)
     695             :   {
     696           0 :     long l = lg(a);
     697           0 :     if (l == 1) pari_err_TYPE("vecan_closure", a);
     698           0 :     ta = typ(gel(a,1));
     699             :     /* regular vector, return it */
     700           0 :     if (ta != t_CLOSURE) return NULL;
     701           0 :     if (l != 3) pari_err_TYPE("vecan_closure", a);
     702           0 :     Sbad = gel(a,2);
     703           0 :     if (typ(Sbad) != t_VEC) pari_err_TYPE("vecan_closure", a);
     704           0 :     a = gel(a,1);
     705             :   }
     706          70 :   else if (ta != t_CLOSURE) pari_err_TYPE("vecan_closure", a);
     707          70 :   push_localprec(prec);
     708          70 :   switch(closure_arity(a))
     709             :   {
     710          14 :     case 2:
     711          14 :       f = closure_callgen2(a, p, mkoo()); break;
     712          56 :     case 1:
     713          56 :       f = NULL; break;
     714           0 :     default:
     715           0 :       f = NULL; pari_err_TYPE("vecan_closure", a);
     716             :   }
     717          70 :   pop_localprec(); return f;
     718             : }
     719             : 
     720             : /*****************************************************************/
     721             : /*  L-series of Dirichlet characters.                            */
     722             : /*****************************************************************/
     723             : 
     724             : static GEN
     725        2020 : lfunzeta(void)
     726             : {
     727        2020 :   GEN zet = mkvecn(7, NULL, gen_0, NULL, gen_1, gen_1, gen_1, gen_1);
     728        2020 :   gel(zet,1) = tag(gen_1, t_LFUN_ZETA);
     729        2020 :   gel(zet,3) = mkvec(gen_0);
     730        2020 :   return zet;
     731             : }
     732             : 
     733             : static GEN
     734        1316 : vecan_Kronecker(GEN D, long n)
     735             : {
     736        1316 :   GEN v = cgetg(n+1, t_VECSMALL);
     737        1316 :   ulong Du = itou_or_0(D);
     738        1316 :   long i, id, d = Du ? minuu(Du, n): n;
     739       31549 :   for (i = 1; i <= d; i++) v[i] = krois(D,i);
     740      171059 :   for (id = i; i <= n; i++,id++) /* periodic mod d */
     741             :   {
     742      169743 :     if (id > d) id = 1;
     743      169743 :     gel(v, i) = gel(v, id);
     744             :   }
     745        1316 :   return v;
     746             : }
     747             : 
     748             : static GEN
     749        4484 : lfunchiquad(GEN D)
     750             : {
     751             :   GEN r;
     752        4484 :   D = coredisc(D);
     753        4484 :   if (equali1(D)) return lfunzeta();
     754        3717 :   if (!isfundamental(D)) pari_err_TYPE("lfunchiquad [not primitive]", D);
     755        3717 :   r = mkvecn(6, NULL, gen_0, NULL, gen_1, NULL, gen_1);
     756        3717 :   gel(r,1) = tag(icopy(D), t_LFUN_KRONECKER);
     757        3717 :   gel(r,3) = mkvec(signe(D) < 0? gen_1: gen_0);
     758        3717 :   gel(r,5) = mpabs(D);
     759        3717 :   return r;
     760             : }
     761             : 
     762             : /* Begin Hecke characters. Here a character is assumed to be given by a
     763             :    vector on the generators of the ray class group clgp of CL_m(K).
     764             :    If clgp = [h,[d1,...,dk],[g1,...,gk]] with dk|...|d2|d1, a character chi
     765             :    is given by [a1,a2,...,ak] such that chi(gi)=\zeta_di^ai. */
     766             : 
     767             : /* Value of CHI on x, coprime to bnr.mod */
     768             : static GEN
     769       97113 : chigeneval_i(GEN logx, GEN d, GEN nchi, GEN z, long prec)
     770             : {
     771       97113 :   pari_sp av = avma;
     772       97113 :   GEN e = FpV_dotproduct(nchi, logx, d);
     773       97113 :   if (!is_vec_t(typ(z)))
     774        1225 :     return gerepileupto(av, gpow(z, e, prec));
     775             :   else
     776             :   {
     777       95888 :     ulong i = itou(e);
     778       95888 :     set_avma(av); return gel(z, i+1);
     779             :   }
     780             : }
     781             : 
     782             : static GEN
     783       84885 : chigenevalvec(GEN logx, GEN nchi, GEN z, long prec, long multi)
     784             : {
     785       84885 :   GEN d = gel(nchi,1), x = gel(nchi, 2);
     786       84885 :   if (multi)
     787       35466 :     pari_APPLY_same(chigeneval_i(logx, d, gel(x,i), z, prec))
     788             :   else
     789       73266 :     return chigeneval_i(logx, d, x, z, prec);
     790             : }
     791             : 
     792             : /* return x + yz; y != 0; z = 0,1 "often"; x = 0 "often" */
     793             : static GEN
     794     1886766 : gaddmul(GEN x, GEN y, GEN z)
     795             : {
     796             :   pari_sp av;
     797     1886766 :   if (typ(z) == t_INT)
     798             :   {
     799     1683929 :     if (!signe(z)) return x;
     800       28338 :     if (equali1(z)) return gadd(x,y);
     801             :   }
     802      222787 :   if (isintzero(x)) return gmul(y,z);
     803      119931 :   av = avma;
     804      119931 :   return gerepileupto(av, gadd(x, gmul(y,z)));
     805             : }
     806             : 
     807             : static GEN
     808     1805691 : gaddmulvec(GEN x, GEN y, GEN z, long multi)
     809             : {
     810     1805691 :   if (multi)
     811      244835 :     pari_APPLY_same(gaddmul(gel(x,i),gel(y,i),gel(z,i)))
     812             :   else
     813     1723811 :     return gaddmul(x,y,z);
     814             : }
     815             : 
     816             : static GEN
     817        2664 : mkvchi(GEN chi, long n)
     818             : {
     819             :   GEN v;
     820        2664 :   if (lg(chi) > 1 && is_vec_t(typ(gel(chi,1))))
     821         480 :   {
     822         480 :     long d = lg(chi)-1;
     823         480 :     v = const_vec(n, zerovec(d));
     824         480 :     gel(v,1) = const_vec(d, gen_1);
     825             :   }
     826             :   else
     827        2184 :     v = vec_ei(n, 1);
     828        2664 :   return v;
     829             : }
     830             : 
     831             : static GEN
     832        1365 : vecan_chiZ(GEN an, long n, long prec)
     833             : {
     834             :   forprime_t iter;
     835        1365 :   GEN G = gel(an,1);
     836        1365 :   GEN nchi = gel(an,2), gord = gel(nchi,1), chi = gel(nchi,2), z;
     837        1365 :   GEN gp = cgetipos(3), v = mkvchi(chi, n);
     838        1365 :   GEN N = znstar_get_N(G);
     839        1365 :   long ord = itos_or_0(gord);
     840        1365 :   ulong Nu = itou_or_0(N);
     841        1365 :   long i, id, d = Nu ? minuu(Nu, n): n;
     842        1365 :   long multichi= (lg(chi) > 1 && is_vec_t(typ(gel(chi,1))));
     843             :   ulong p;
     844        1365 :   if (!multichi && ord && n > (ord>>4))
     845        1239 :   {
     846        1239 :     GEN w = ncharvecexpo(G, nchi);
     847        1239 :     z = grootsof1(ord, prec);
     848       22302 :     for (i = 1; i <= d; i++)
     849       21063 :       if (w[i] >= 0) gel(v, i) = gel(z, w[i]+1);
     850             :   }
     851             :   else
     852             :   {
     853         126 :     z = rootsof1_cx(gord, prec);
     854         126 :     u_forprime_init(&iter, 2, d);
     855         805 :     while ((p = u_forprime_next(&iter)))
     856             :     {
     857             :       GEN ch;
     858             :       ulong k;
     859         679 :       if (!umodiu(N,p)) continue;
     860         560 :       gp[2] = p;
     861         560 :       ch = chigenevalvec(znconreylog(G, gp), nchi, z, prec, multichi);
     862         560 :       gel(v, p)  = ch;
     863        1582 :       for (k = 2*p; k <= (ulong)d; k += p)
     864        1022 :         gel(v, k) = gaddmulvec(gel(v, k), ch, gel(v, k/p), multichi);
     865             :     }
     866             :   }
     867      272076 :   for (id = i = d+1; i <= n; i++,id++) /* periodic mod d */
     868             :   {
     869      270711 :     if (id > d) id = 1;
     870      270711 :     gel(v, i) = gel(v, id);
     871             :   }
     872        1365 :   return v;
     873             : }
     874             : 
     875             : static GEN
     876          42 : eulerf_chiZ(GEN an, GEN p, long prec)
     877             : {
     878          42 :   GEN G = gel(an,1);
     879          42 :   GEN nchi = gel(an,2), gord = gel(nchi,1), chi = gel(nchi,2);
     880          42 :   long multichi= (lg(chi) > 1 && is_vec_t(typ(gel(chi,1))));
     881          42 :   GEN z = rootsof1_cx(gord, prec);
     882          42 :   GEN N = znstar_get_N(G);
     883          42 :   GEN ch = dvdii(N,p) ? gen_0: chigenevalvec(znconreylog(G, p), nchi, z, prec, multichi);
     884          42 :   return mkrfrac(gen_1, deg1pol_shallow(gneg(ch), gen_1,0));
     885             : }
     886             : 
     887             : static GEN
     888        1299 : vecan_chigen(GEN an, long n, long prec)
     889             : {
     890             :   forprime_t iter;
     891        1299 :   GEN bnr = gel(an,1), nf = bnr_get_nf(bnr);
     892        1299 :   GEN nchi = gel(an,2), gord = gel(nchi,1), chi = gel(nchi,2), z;
     893        1299 :   GEN gp = cgetipos(3), v = mkvchi(chi, n);
     894        1299 :   GEN N = gel(bnr_get_mod(bnr), 1), NZ = gcoeff(N,1,1);
     895        1299 :   long ord = itos_or_0(gord);
     896        1299 :   long multichi= (lg(chi) > 1 && is_vec_t(typ(gel(chi,1))));
     897             :   ulong p;
     898             : 
     899        1299 :   if (ord && n > (ord>>4))
     900        1299 :     z = grootsof1(ord, prec);
     901             :   else
     902           0 :     z = rootsof1_cx(gord, prec);
     903             : 
     904        1299 :   if (nf_get_degree(nf) == 1)
     905             :   {
     906         900 :     ulong Nu = itou_or_0(NZ);
     907         900 :     long i, id, d = Nu ? minuu(Nu, n): n;
     908         900 :     u_forprime_init(&iter, 2, d);
     909        4456 :     while ((p = u_forprime_next(&iter)))
     910             :     {
     911             :       GEN ch;
     912             :       ulong k;
     913        3556 :       if (!umodiu(NZ,p)) continue;
     914        2635 :       gp[2] = p;
     915        2635 :       ch = chigenevalvec(isprincipalray(bnr,gp), nchi, z, prec, multichi);
     916        2635 :       gel(v, p)  = ch;
     917        7597 :       for (k = 2*p; k <= (ulong)d; k += p)
     918        4962 :         gel(v, k) = gaddmulvec(gel(v, k), ch, gel(v, k/p), multichi);
     919             :     }
     920       11102 :     for (id = i = d+1; i <= n; i++,id++) /* periodic mod d */
     921             :     {
     922       10202 :       if (id > d) id = 1;
     923       10202 :       gel(v, i) = gel(v, id);
     924             :     }
     925             :   }
     926             :   else
     927             :   {
     928         399 :     GEN BOUND = stoi(n);
     929         399 :     u_forprime_init(&iter, 2, n);
     930       82369 :     while ((p = u_forprime_next(&iter)))
     931             :     {
     932             :       GEN L;
     933             :       long j;
     934       81970 :       int check = !umodiu(NZ,p);
     935       81970 :       gp[2] = p;
     936       81970 :       L = idealprimedec_limit_norm(nf, gp, BOUND);
     937      163828 :       for (j = 1; j < lg(L); j++)
     938             :       {
     939       81858 :         GEN pr = gel(L, j), ch;
     940             :         ulong k, q;
     941       81858 :         if (check && idealval(nf, N, pr)) continue;
     942       81613 :         ch = chigenevalvec(isprincipalray(bnr,pr), nchi, z, prec, multichi);
     943       81613 :         q = upr_norm(pr);
     944       81613 :         gel(v, q) = gadd(gel(v, q), ch);
     945     1881320 :         for (k = 2*q; k <= (ulong)n; k += q)
     946     1799707 :           gel(v, k) = gaddmulvec(gel(v, k), ch, gel(v, k/q), multichi);
     947             :       }
     948             :     }
     949             :   }
     950        1299 :   return v;
     951             : }
     952             : 
     953             : static GEN
     954          28 : eulerf_chigen(GEN an, GEN p, long prec)
     955             : {
     956          28 :   GEN bnr = gel(an,1), nf = bnr_get_nf(bnr);
     957          28 :   GEN nchi = gel(an,2), gord = gel(nchi,1), chi = gel(nchi,2), z;
     958          28 :   GEN N = gel(bnr_get_mod(bnr), 1), NZ = gcoeff(N,1,1), f;
     959          28 :   long multichi= (lg(chi) > 1 && is_vec_t(typ(gel(chi,1))));
     960             : 
     961          28 :   z = rootsof1_cx(gord, prec);
     962          28 :   if (nf_get_degree(nf) == 1)
     963             :   {
     964             :     GEN ch;
     965           0 :     if (dvdii(NZ,p)) ch = gen_0;
     966             :     else
     967             :     {
     968           0 :       ch = chigenevalvec(isprincipalray(bnr,p), nchi, z, prec, multichi);
     969           0 :       if (typ(ch)==t_VEC) return NULL;
     970             :     }
     971           0 :     f = deg1pol_shallow(gneg(ch), gen_1, 0);
     972             :   }
     973             :   else
     974             :   {
     975          28 :     int check = dvdii(NZ,p);
     976          28 :     GEN L = idealprimedec(nf, p);
     977          28 :     long j, lL = lg(L);
     978          28 :     f = pol_1(0);
     979          49 :     for (j = 1; j < lL; j++)
     980             :     {
     981          35 :       GEN pr = gel(L, j), ch;
     982          35 :       if (check && idealval(nf, N, pr)) ch = gen_0;
     983             :       else
     984          35 :       ch = chigenevalvec(isprincipalray(bnr,pr), nchi, z, prec, multichi);
     985          35 :       if (typ(ch)==t_VEC) return NULL;
     986          21 :       f = gmul(f, gsub(gen_1, monomial(ch, pr_get_f(pr), 0)));
     987             :     }
     988             :   }
     989          14 :   return mkrfrac(gen_1,f);
     990             : }
     991             : 
     992             : static GEN
     993        4438 : vec01(long r1, long r2)
     994             : {
     995        4438 :   long d = r1+r2, i;
     996        4438 :   GEN v = cgetg(d+1,t_VEC);
     997       12453 :   for (i = 1; i <= r1; i++) gel(v,i) = gen_0;
     998        7070 :   for (     ; i <= d;  i++) gel(v,i) = gen_1;
     999        4438 :   return v;
    1000             : }
    1001             : 
    1002             : /* true nf or t_POL */
    1003             : static GEN
    1004        1218 : lfunzetak_i(GEN T)
    1005             : {
    1006             :   GEN Vga, N;
    1007             :   long r1, r2;
    1008        1218 :   if (typ(T) == t_POL)
    1009             :   {
    1010         637 :     T = nfinit0(T, nf_NOLLL, DEFAULTPREC);
    1011         637 :     if (lg(T) == 3) T = gel(T,1); /* [nf,change of var] */
    1012             :   }
    1013        1218 :   if (nf_get_degree(T) == 1) return lfunzeta();
    1014        1218 :   nf_get_sign(T,&r1,&r2); Vga = vec01(r1+r2,r2);
    1015        1218 :   N = absi_shallow(nf_get_disc(T));
    1016        1218 :   return mkvecn(7, tag(T,t_LFUN_NF), gen_0, Vga, gen_1, N, gen_1, gen_0);
    1017             : }
    1018             : /* truen nf or t_POL */
    1019             : static GEN
    1020         805 : lfunzetak(GEN T)
    1021         805 : { pari_sp av = avma; return gerepilecopy(av, lfunzetak_i(T)); }
    1022             : 
    1023             : /* v = vector of normalized characters of order dividing o; renormalize
    1024             :  * so that all have same apparent order o */
    1025             : static GEN
    1026         224 : char_renormalize(GEN v, GEN o)
    1027             : {
    1028             :   long i, l;
    1029         224 :   GEN w = cgetg_copy(v, &l);
    1030         833 :   for (i = 1; i < l; i++)
    1031             :   {
    1032         609 :     GEN C = gel(v,i), oc = gel(C,1), c = gel(C,2);
    1033         609 :     if (!equalii(o, oc)) c = gmul(c, diviiexact(o, oc));
    1034         609 :     gel(w,i) = c;
    1035             :   }
    1036         224 :   return w;
    1037             : }
    1038             : /* G is a bid of nftyp typ_BIDZ */
    1039             : static GEN
    1040        1841 : lfunchiZ(GEN G, GEN CHI)
    1041             : {
    1042        1841 :   pari_sp av = avma;
    1043        1841 :   GEN sig = NULL, N = bid_get_ideal(G), nchi, r;
    1044             :   int real;
    1045             :   long s;
    1046             : 
    1047        1841 :   if (typ(N) != t_INT) pari_err_TYPE("lfunchiZ", G);
    1048        1841 :   if (typ(CHI) == t_VEC && !RgV_is_ZV(CHI))
    1049          21 :   {
    1050          42 :     GEN C, G0 = G, o = gen_1;
    1051          42 :     long i, l = lg(CHI);
    1052          42 :     nchi = cgetg(l, t_VEC);
    1053          42 :     N = znconreyconductor(G, gel(CHI,1), &C);
    1054          35 :     if (typ(N) != t_INT) G = znstar0(N, 1);
    1055          35 :     s = zncharisodd(G, C);
    1056          91 :     for (i = 1; i < l; i++)
    1057             :     {
    1058          70 :       if (i > 1)
    1059             :       {
    1060          35 :         if (!gequal(N, znconreyconductor(G0, gel(CHI,i), &C))
    1061          28 :             || zncharisodd(G, C) != s)
    1062          14 :           pari_err_TYPE("lfuncreate [different conductors]", CHI);
    1063             :       }
    1064          56 :       C = znconreylog_normalize(G, C);
    1065          56 :       o = lcmii(o, gel(C,1)); /* lcm with charorder */
    1066          56 :       gel(nchi,i) = C;
    1067             :     }
    1068          21 :     nchi = mkvec2(o, char_renormalize(nchi, o));
    1069          21 :     if (typ(N) != t_INT) N = gel(N,1);
    1070             :   }
    1071             :   else
    1072             :   {
    1073        1799 :     N = znconreyconductor(G, CHI, &CHI);
    1074        1799 :     if (typ(N) != t_INT)
    1075             :     {
    1076           7 :       if (equali1(gel(N,1))) { set_avma(av); return lfunzeta(); }
    1077           0 :       G = znstar0(N, 1);
    1078           0 :       N = gel(N,1);
    1079             :     }
    1080             :     /* CHI now primitive on G */
    1081        1792 :     switch(itou_or_0(zncharorder(G, CHI)))
    1082             :     {
    1083         427 :       case 1: set_avma(av); return lfunzeta();
    1084         672 :       case 2: if (zncharisodd(G,CHI)) N = negi(N);
    1085         672 :               return gerepileupto(av, lfunchiquad(N));
    1086             :     }
    1087         693 :     nchi = znconreylog_normalize(G, CHI);
    1088         693 :     s = zncharisodd(G, CHI);
    1089             :   }
    1090         714 :   sig = mkvec(s? gen_1: gen_0);
    1091         714 :   real = abscmpiu(gel(nchi,1), 2) <= 0;
    1092         714 :   r = mkvecn(6, tag(mkvec2(G,nchi), t_LFUN_CHIZ),
    1093             :                 real? gen_0: gen_1, sig, gen_1, N, gen_0);
    1094         714 :   return gerepilecopy(av, r);
    1095             : }
    1096             : 
    1097             : static GEN
    1098        1309 : lfunchigen(GEN bnr, GEN CHI)
    1099             : {
    1100        1309 :   pari_sp av = avma;
    1101             :   GEN N, sig, Ldchi, nf, nchi, NN;
    1102             :   long r1, r2, n1;
    1103             :   int real;
    1104             : 
    1105        1309 :   if (typ(CHI) == t_VEC && !RgV_is_ZV(CHI))
    1106         203 :   {
    1107         210 :     long map, i, l = lg(CHI);
    1108         210 :     GEN bnr0 = bnr, D, chi = gel(CHI,1), o = gen_1;
    1109         210 :     nchi = cgetg(l, t_VEC);
    1110         210 :     bnr_char_sanitize(&bnr, &chi);
    1111         210 :     D = cyc_normalize(bnr_get_cyc(bnr));
    1112         210 :     N = bnr_get_mod(bnr);
    1113         210 :     map = (bnr != bnr0);
    1114         784 :     for (i = 1; i < l; i++)
    1115             :     {
    1116         581 :       if (i > 1)
    1117             :       {
    1118         371 :         chi = gel(CHI,i);
    1119         371 :         if (!map)
    1120             :         {
    1121         350 :           if (!bnrisconductor(bnr, chi))
    1122           7 :             pari_err_TYPE("lfuncreate [different conductors]", CHI);
    1123             :         }
    1124             :         else
    1125             :         {
    1126          21 :           if (!gequal(bnrconductor_raw(bnr0, chi), N))
    1127           0 :             pari_err_TYPE("lfuncreate [different conductors]", CHI);
    1128          21 :           chi = bnrchar_primitive_raw(bnr0, bnr, chi);
    1129             :         }
    1130             :       }
    1131         574 :       chi = char_normalize(chi, D);
    1132         574 :       o = lcmii(o, gel(chi,1)); /* lcm with charorder */
    1133         574 :       gel(nchi,i) = chi;
    1134             :     }
    1135         203 :     nchi = mkvec2(o, char_renormalize(nchi, o));
    1136             :   }
    1137             :   else
    1138             :   {
    1139        1099 :     bnr_char_sanitize(&bnr, &CHI);
    1140        1099 :     nchi = NULL; /* now CHI is primitive wrt bnr */
    1141             :   }
    1142             : 
    1143        1302 :   N = bnr_get_mod(bnr);
    1144        1302 :   nf = bnr_get_nf(bnr);
    1145        1302 :   n1 = lg(vec01_to_indices(gel(N,2))) - 1; /* vecsum(N[2]) */
    1146        1302 :   N = gel(N,1);
    1147        1302 :   NN = mulii(idealnorm(nf, N), absi_shallow(nf_get_disc(nf)));
    1148        1302 :   if (!nchi)
    1149             :   {
    1150        1099 :     if (equali1(NN)) { set_avma(av); return lfunzeta(); }
    1151         658 :     if (ZV_equal0(CHI)) return gerepilecopy(av, lfunzetak_i(bnr_get_nf(bnr)));
    1152         581 :     nchi = char_normalize(CHI, cyc_normalize(bnr_get_cyc(bnr)));
    1153             :   }
    1154         784 :   real = abscmpiu(gel(nchi,1), 2) <= 0;
    1155         784 :   nf_get_sign(nf, &r1, &r2);
    1156         784 :   sig = vec01(r1+r2-n1, r2+n1);
    1157         784 :   Ldchi = mkvecn(6, tag(mkvec2(bnr, nchi), t_LFUN_CHIGEN),
    1158             :                     real? gen_0: gen_1, sig, gen_1, NN, gen_0);
    1159         784 :   return gerepilecopy(av, Ldchi);
    1160             : }
    1161             : 
    1162             : /* Find all characters of clgp whose kernel contain group given by HNF H.
    1163             :  * Set *pcnj[i] to the conductor */
    1164             : static GEN
    1165         518 : chigenkerfind(GEN bnr, GEN H, GEN *pcnj)
    1166             : {
    1167         518 :   GEN res, cnj, L = bnrchar(bnr, H, NULL);
    1168         518 :   long i, k, l = lg(L);
    1169             : 
    1170         518 :   res = cgetg(l, t_VEC);
    1171         518 :   *pcnj = cnj = cgetg(l, t_VEC);
    1172        1911 :   for (i = k = 1; i < l; i++)
    1173             :   {
    1174        1393 :     GEN chi = gel(L,i);
    1175        1393 :     gel(res, k) = chi;
    1176        1393 :     gel(cnj, k) = ZV_equal0(chi)? gen_0: bnrconductor_raw(bnr, chi);
    1177        1393 :     k++;
    1178             :   }
    1179         518 :   setlg(cnj, k);
    1180         518 :   setlg(res, k); return res;
    1181             : }
    1182             : 
    1183             : static GEN
    1184         518 : vec_classes(GEN A, GEN F)
    1185             : {
    1186         518 :   GEN w = vec_equiv(F);
    1187         518 :   long i, l = lg(w);
    1188         518 :   GEN V = cgetg(l, t_VEC);
    1189        1575 :   for (i = 1; i < l; i++) gel(V,i) = vecpermute(A,gel(w,i));
    1190         518 :   return V;
    1191             : }
    1192             : 
    1193             : static GEN
    1194      990451 : abelrel_pfactor(GEN bnr, GEN pr, GEN U, GEN D, GEN h)
    1195             : {
    1196      990451 :   GEN v = bnrisprincipalmod(bnr, pr, h, 0);
    1197      990451 :   GEN E = ZV_ZV_mod(ZM_ZC_mul(U, v), D);
    1198      990451 :   ulong o = itou(charorder(D, E)), f = pr_get_f(pr);
    1199      990451 :   return gpowgs(gsub(gen_1, monomial(gen_1, f * o, 0)), itou(h) / o);
    1200             : }
    1201             : 
    1202             : static GEN
    1203      687925 : abelrel_factor(GEN bnr, GEN C, GEN p, GEN mod, GEN U, GEN D, GEN h)
    1204             : {
    1205      687925 :   GEN nf = bnr_get_nf(bnr), F = pol_1(0), prid = idealprimedec(nf,p);
    1206      687925 :   GEN mod2 = shallowcopy(mod);
    1207      687925 :   long i, l = lg(prid);
    1208     1678376 :   for (i = 1; i < l; i++)
    1209             :   {
    1210      990451 :     GEN pr = gel(prid, i), Fpr;
    1211      990451 :     long v = idealval(nf,mod,pr);
    1212      990451 :     if (v > 0)
    1213             :     {
    1214             :       GEN bnr2, C2, U2, D2, h2;
    1215         161 :       gel(mod2, 1) = idealdivpowprime(nf, gel(mod, 1), pr, utoi(v));
    1216         161 :       bnr2 = bnrinitmod(bnr, mod2, 0, h);
    1217         161 :       C2 = bnrmap(bnrmap(bnr, bnr2), C);
    1218         161 :       D2 = ZM_snfall_i(C2, &U2, NULL, 1);
    1219         161 :       h2 = ZV_prod(D2);
    1220         161 :       Fpr = abelrel_pfactor(bnr2, pr, U2, D2, h2);
    1221             :     }
    1222             :     else
    1223      990290 :       Fpr = abelrel_pfactor(bnr, pr, U, D, h);
    1224      990451 :     F = ZX_mul(F, Fpr);
    1225             :   }
    1226      687925 :   return gcopy(mkrfrac(gen_1, F));
    1227             : }
    1228             : 
    1229             : static GEN
    1230          42 : eulerf_abelrel(GEN an, GEN p)
    1231             : {
    1232          42 :   GEN bnr = gel(an,1), C = gel(an,2), mod = gel(an,3);
    1233          42 :   GEN U, D = ZM_snfall_i(C, &U, NULL, 1), h = ZV_prod(D);
    1234          42 :   return abelrel_factor(bnr, C, p, mod, U, D, h);
    1235             : }
    1236             : 
    1237             : struct direuler_abelrel
    1238             : {
    1239             :   GEN bnr, C, mod, U, D, h;
    1240             : };
    1241             : 
    1242             : static GEN
    1243      687883 : _direuler_abelrel(void *E, GEN p)
    1244             : {
    1245      687883 :   struct direuler_abelrel *s = (struct direuler_abelrel*) E;
    1246      687883 :   return abelrel_factor(s->bnr, s->C, p, s->mod, s->U, s->D, s->h);
    1247             : }
    1248             : 
    1249             : static GEN
    1250         168 : vecan_abelrel(GEN an, long N)
    1251             : {
    1252             :   struct direuler_abelrel s;
    1253         168 :   s.bnr = gel(an,1);
    1254         168 :   s.C   = gel(an,2);
    1255         168 :   s.mod = gel(an,3);
    1256         168 :   s.D = ZM_snfall_i(s.C, &s.U, NULL, 1);
    1257         168 :   s.h = ZV_prod(s.D);
    1258         168 :   return direuler((void*)&s, _direuler_abelrel, gen_1, stoi(N), NULL);
    1259             : }
    1260             : 
    1261             : static GEN
    1262         539 : lfunabelrel_i(GEN bnr, GEN H, GEN mod)
    1263             : {
    1264         539 :   GEN NrD = bnrdisc(bnr, H, 0), N = absi_shallow(gel(NrD,3));
    1265         539 :   long n = itos(gel(NrD,1)), r1 = itos(gel(NrD,2)), r2 = (n-r1)>>1;
    1266         539 :   if (!mod) mod = bnrconductor(bnr, H, 0);
    1267         539 :   return mkvecn(7, tag(mkvec3(bnr,H,mod),t_LFUN_ABELREL),
    1268             :                    gen_0, vec01(r1+r2, r2), gen_1, N, gen_1, gen_0);
    1269             : }
    1270             : static GEN
    1271          21 : lfunabelrel(GEN bnr, GEN H, GEN mod)
    1272          21 : { pari_sp av = avma; return gerepilecopy(av, lfunabelrel_i(bnr, H, mod)); }
    1273             : 
    1274             : GEN
    1275         518 : lfunabelianrelinit(GEN bnr, GEN H, GEN dom, long der, long bitprec)
    1276             : {
    1277             :   GEN X, cnj, M, D,C ;
    1278             :   long l, i;
    1279         518 :   C = chigenkerfind(bnr, H, &cnj);
    1280         518 :   C = vec_classes (C, cnj);
    1281         518 :   X = cgetg_copy(C,&l);
    1282        1575 :   for (i = 1; i < l; ++i)
    1283             :   {
    1284        1057 :     GEN chi = gel(C,i);
    1285        1057 :     GEN L = lfunchigen(bnr, lg(chi)==2 ? gel(chi,1): chi);
    1286        1057 :     gel(X,i) = lfuninit(L, dom, der, bitprec);
    1287             :   }
    1288         518 :   M = mkvec3(X, const_vecsmall(l-1, 1), const_vecsmall(l-1, 0));
    1289         518 :   D = mkvec2(dom, mkvecsmall2(der, bitprec));
    1290         518 :   return lfuninit_make(t_LDESC_PRODUCT, lfunabelrel_i(bnr, H, NULL), M, D);
    1291             : }
    1292             : 
    1293             : /*****************************************************************/
    1294             : /*                 Dedekind zeta functions                       */
    1295             : /*****************************************************************/
    1296             : /* true nf */
    1297             : static GEN
    1298        2079 : dirzetak0(GEN nf, ulong N)
    1299             : {
    1300        2079 :   GEN vect, c, c2, T = nf_get_pol(nf), index = nf_get_index(nf);
    1301        2079 :   pari_sp av = avma, av2;
    1302        2079 :   const ulong SQRTN = usqrt(N);
    1303             :   ulong i, p, lx;
    1304        2079 :   long court[] = {evaltyp(t_INT)|_evallg(3), evalsigne(1)|evallgefint(3),0};
    1305             :   forprime_t S;
    1306             : 
    1307        2079 :   c  = cgetalloc(N+1, t_VECSMALL);
    1308        2079 :   c2 = cgetalloc(N+1, t_VECSMALL);
    1309     2568503 :   c2[1] = c[1] = 1; for (i=2; i<=N; i++) c[i] = 0;
    1310        2079 :   u_forprime_init(&S, 2, N); av2 = avma;
    1311      334327 :   while ( (p = u_forprime_next(&S)) )
    1312             :   {
    1313      332248 :     set_avma(av2);
    1314      332248 :     if (umodiu(index, p)) /* p does not divide index */
    1315      331891 :       vect = gel(Flx_degfact(ZX_to_Flx(T,p), p),1);
    1316             :     else
    1317             :     {
    1318         357 :       court[2] = p;
    1319         357 :       vect = idealprimedec_degrees(nf,court);
    1320             :     }
    1321      332248 :     lx = lg(vect);
    1322      332248 :     if (p <= SQRTN)
    1323       34160 :       for (i=1; i<lx; i++)
    1324             :       {
    1325       22743 :         ulong qn, q = upowuu(p, vect[i]); /* Norm P[i] */
    1326       22743 :         if (!q || q > N) break;
    1327       20188 :         memcpy(c2 + 2, c + 2, (N-1)*sizeof(long));
    1328             :         /* c2[i] <- c[i] + sum_{k = 1}^{v_q(i)} c[i/q^k] for all i <= N */
    1329       41559 :         for (qn = q; qn <= N; qn *= q)
    1330             :         {
    1331       41559 :           ulong k0 = N/qn, k, k2; /* k2 = k*qn */
    1332     3600261 :           for (k = k0, k2 = k*qn; k > 0; k--, k2 -=qn) c2[k2] += c[k];
    1333       41559 :           if (q > k0) break; /* <=> q*qn > N */
    1334             :         }
    1335       20188 :         swap(c, c2);
    1336             :       }
    1337             :     else /* p > sqrt(N): simpler */
    1338      628817 :       for (i=1; i<lx; i++)
    1339             :       {
    1340             :         ulong k, k2; /* k2 = k*p */
    1341      556500 :         if (vect[i] > 1) break;
    1342             :         /* c2[i] <- c[i] + sum_{k = 1}^{v_q(i)} c[i/q^k] for all i <= N */
    1343     1828477 :         for (k = N/p, k2 = k*p; k > 0; k--, k2 -= p) c[k2] += c[k];
    1344             :       }
    1345             :   }
    1346        2079 :   set_avma(av);
    1347        2079 :   pari_free(c2); return c;
    1348             : }
    1349             : 
    1350             : static GEN
    1351         168 : eulerf_zetak(GEN nf, GEN p)
    1352             : {
    1353         168 :   GEN v, f = pol_1(0);
    1354             :   long i, l;
    1355         168 :   if (dvdii(nf_get_index(nf), p)) /* p does not divide index */
    1356           7 :     v = idealprimedec_degrees(nf,p);
    1357             :   else
    1358         161 :     v = gel(FpX_degfact(nf_get_pol(nf), p), 1);
    1359         168 :   l = lg(v);
    1360         406 :   for (i = 1; i < l; i++) f = ZX_sub(f, RgX_shift_shallow(f, v[i]));
    1361         168 :   retmkrfrac(gen_1, ZX_copy(f));
    1362             : }
    1363             : 
    1364             : GEN
    1365        2079 : dirzetak(GEN nf, GEN b)
    1366             : {
    1367             :   GEN z, c;
    1368             :   long n;
    1369             : 
    1370        2079 :   if (typ(b) != t_INT) pari_err_TYPE("dirzetak",b);
    1371        2079 :   if (signe(b) <= 0) return cgetg(1,t_VEC);
    1372        2079 :   nf = checknf(nf);
    1373        2079 :   n = itou_or_0(b); if (!n) pari_err_OVERFLOW("dirzetak");
    1374        2079 :   c = dirzetak0(nf, n);
    1375        2079 :   z = vecsmall_to_vec(c); pari_free(c); return z;
    1376             : }
    1377             : 
    1378             : static GEN
    1379         630 : linit_get_mat(GEN linit)
    1380             : {
    1381         630 :   if (linit_get_type(linit)==t_LDESC_PRODUCT)
    1382         154 :     return lfunprod_get_fact(linit_get_tech(linit));
    1383             :   else
    1384         476 :     return mkvec3(mkvec(linit), mkvecsmall(1), mkvecsmall(0));
    1385             : }
    1386             : 
    1387             : static GEN
    1388         315 : lfunproduct(GEN ldata, GEN linit1, GEN linit2, GEN domain)
    1389             : {
    1390         315 :   GEN M1 = linit_get_mat(linit1);
    1391         315 :   GEN M2 = linit_get_mat(linit2);
    1392         315 :   GEN M3 = mkvec3(shallowconcat(gel(M1, 1), gel(M2, 1)),
    1393         315 :                   vecsmall_concat(gel(M1, 2), gel(M2, 2)),
    1394         315 :                   vecsmall_concat(gel(M1, 3), gel(M2, 3)));
    1395         315 :   return lfuninit_make(t_LDESC_PRODUCT, ldata, M3, domain);
    1396             : }
    1397             : static GEN lfunzetakinit_artin(GEN nf, GEN gal, GEN dom, long der, long bit);
    1398             : /* true nf */
    1399             : static GEN
    1400         315 : lfunzetakinit_quotient(GEN nf, GEN polk, GEN dom, long der, long bitprec)
    1401             : {
    1402             :   GEN ak, an, nfk, Vga, ldata, N, Lk, LKk, domain;
    1403             :   long r1k, r2k, r1, r2;
    1404             : 
    1405         315 :   nf_get_sign(nf,&r1,&r2);
    1406         315 :   nfk = nfinit(polk, nbits2prec(bitprec));
    1407         315 :   Lk = lfunzetakinit(nfk, dom, der, bitprec); /* zeta_k */
    1408         315 :   nf_get_sign(nfk,&r1k,&r2k);
    1409         315 :   Vga = vec01((r1+r2) - (r1k+r2k), r2-r2k);
    1410         315 :   N = absi_shallow(diviiexact(nf_get_disc(nf), nf_get_disc(nfk)));
    1411         315 :   ak = nf_get_degree(nf)==1 ? tag(gen_1, t_LFUN_ZETA): tag(nfk, t_LFUN_NF);
    1412         315 :   an = tag(mkvec2(tag(nf,t_LFUN_NF), ak), t_LFUN_DIV);
    1413         315 :   ldata = mkvecn(6, an, gen_0, Vga, gen_1, N, gen_1);
    1414         315 :   LKk = lfuninit(ldata, dom, der, bitprec); /* zeta_K/zeta_k */
    1415         315 :   domain = mkvec2(dom, mkvecsmall2(der, bitprec));
    1416         315 :   return lfunproduct(lfunzetak_i(nf), Lk, LKk, domain);
    1417             : }
    1418             : /* true nf */
    1419             : GEN
    1420         924 : lfunzetakinit(GEN nf, GEN dom, long der, long bitprec)
    1421             : {
    1422         924 :   long n, d = nf_get_degree(nf);
    1423         924 :   GEN L, Q, R, T = nf_get_pol(nf);
    1424         924 :   if (d == 1) return lfuninit(lfunzeta(), dom, der, bitprec);
    1425         763 :   if (d > 2)
    1426             :   {
    1427         427 :     GEN G = galoisinit(nf, NULL);
    1428         427 :     if (isintzero(G))
    1429             :     { /* not Galois */
    1430         315 :       GEN S = nfsubfields(nf, 0); n = lg(S)-1;
    1431         315 :       return lfunzetakinit_quotient(nf, gmael(S,n-1,1), dom, der, bitprec);
    1432             :     }
    1433         112 :     if (!group_isabelian(galois_group(G))) /* Galois, not Abelian */
    1434          21 :       return lfunzetakinit_artin(nf, G, dom, der, bitprec);
    1435             :   }
    1436             :   /* Abelian over Q */
    1437         427 :   Q = Buchall(pol_x(1), 0, nbits2prec(bitprec));
    1438         427 :   T = shallowcopy(T); setvarn(T,0);
    1439         427 :   R = rnfconductor0(Q, T, 1);
    1440         427 :   L = lfunabelianrelinit(gel(R,2), gel(R,3), dom, der, bitprec);
    1441         427 :   delete_var(); return L;
    1442             : }
    1443             : 
    1444             : /***************************************************************/
    1445             : /*             Elliptic Curves and Modular Forms               */
    1446             : /***************************************************************/
    1447             : 
    1448             : static GEN
    1449         203 : lfunellnf(GEN e)
    1450             : {
    1451         203 :   pari_sp av = avma;
    1452         203 :   GEN ldata = cgetg(7, t_VEC), nf = ellnf_get_nf(e);
    1453         203 :   GEN N = gel(ellglobalred(e), 1);
    1454         203 :   long n = nf_get_degree(nf);
    1455         203 :   gel(ldata, 1) = tag(e, t_LFUN_ELL);
    1456         203 :   gel(ldata, 2) = gen_0;
    1457         203 :   gel(ldata, 3) = vec01(n, n);
    1458         203 :   gel(ldata, 4) = gen_2;
    1459         203 :   gel(ldata, 5) = mulii(idealnorm(nf,N), sqri(nf_get_disc(nf)));
    1460         203 :   gel(ldata, 6) = stoi(ellrootno_global(e));
    1461         203 :   return gerepilecopy(av, ldata);
    1462             : }
    1463             : 
    1464             : static GEN
    1465        1708 : lfunellQ(GEN e)
    1466             : {
    1467        1708 :   pari_sp av = avma;
    1468        1708 :   GEN ldata = cgetg(7, t_VEC);
    1469        1708 :   gel(ldata, 1) = tag(ellanal_globalred(e, NULL), t_LFUN_ELL);
    1470        1708 :   gel(ldata, 2) = gen_0;
    1471        1708 :   gel(ldata, 3) = mkvec2(gen_0, gen_1);
    1472        1708 :   gel(ldata, 4) = gen_2;
    1473        1708 :   gel(ldata, 5) = ellQ_get_N(e);
    1474        1708 :   gel(ldata, 6) = stoi(ellrootno_global(e));
    1475        1708 :   return gerepilecopy(av, ldata); /* ellanal_globalred not gerepile-safe */
    1476             : }
    1477             : 
    1478             : static GEN
    1479        1911 : lfunell(GEN e)
    1480             : {
    1481        1911 :   long t = ell_get_type(e);
    1482        1911 :   switch(t)
    1483             :   {
    1484        1708 :     case t_ELL_Q: return lfunellQ(e);
    1485         203 :     case t_ELL_NF:return lfunellnf(e);
    1486             :   }
    1487           0 :   pari_err_TYPE("lfun",e);
    1488             :   return NULL; /*LCOV_EXCL_LINE*/
    1489             : }
    1490             : 
    1491             : static GEN
    1492         140 : ellsympow_gamma(long m)
    1493             : {
    1494         140 :   GEN V = cgetg(m+2, t_VEC);
    1495         140 :   long i = 1, j;
    1496         140 :   if (!odd(m)) gel(V, i++) = stoi(-2*(m>>2));
    1497         364 :   for (j = (m+1)>>1; j > 0; i+=2, j--)
    1498             :   {
    1499         224 :     gel(V,i)   = stoi(1-j);
    1500         224 :     gel(V,i+1) = stoi(1-j+1);
    1501             :   }
    1502         140 :   return V;
    1503             : }
    1504             : 
    1505             : static GEN
    1506       86720 : ellsympow_trace(GEN p, GEN t, long m)
    1507             : {
    1508       86720 :   long k, n = m >> 1;
    1509       86720 :   GEN tp = gpowers0(sqri(t), n, odd(m)? t: NULL);
    1510       86864 :   GEN pp = gen_1, b = gen_1, r = gel(tp,n+1);
    1511      246153 :   for(k=1; k<=n; k++)
    1512             :   {
    1513             :     GEN s;
    1514      159600 :     pp = mulii(pp, p);
    1515      159430 :     b  = diviuexact(muliu(b, (m-(2*k-1))*(m-(2*k-2))), k*(m-(k-1)));
    1516      158798 :     s = mulii(mulii(b, gel(tp,1+n-k)), pp);
    1517      159153 :     r = odd(k) ? subii(r, s): addii(r, s);
    1518             :   }
    1519       86553 :   return r;
    1520             : }
    1521             : 
    1522             : static GEN
    1523        3129 : ellsympow_abelian(GEN p, GEN ap, long m, long o)
    1524             : {
    1525        3129 :   pari_sp av = avma;
    1526        3129 :   long i, M, n = (m+1)>>1;
    1527             :   GEN pk, tv, pn, pm, F, v;
    1528        3129 :   if (!odd(o))
    1529             :   {
    1530           0 :     if (odd(m)) return pol_1(0);
    1531           0 :     M = m >> 1; o >>= 1;
    1532             :   }
    1533             :   else
    1534        3129 :     M = m * ((o+1) >> 1);
    1535        3129 :   pk = gpowers(p,n); pn = gel(pk,n+1);
    1536        3129 :   tv = cgetg(m+2,t_VEC);
    1537        3129 :   gel(tv, 1) = gen_2;
    1538        3129 :   gel(tv, 2) = ap;
    1539       10668 :   for (i = 3; i <= m+1; i++)
    1540        7539 :     gel(tv,i) = subii(mulii(ap,gel(tv,i-1)), mulii(p,gel(tv,i-2)));
    1541        3129 :   pm = odd(m)? mulii(gel(pk,n), pn): sqri(pn); /* cheap p^m */
    1542        3129 :   F = deg2pol_shallow(pm, gen_0, gen_1, 0);
    1543        3129 :   v = odd(m) ? pol_1(0): deg1pol_shallow(negi(pn), gen_1, 0);
    1544        9450 :   for (i = M % o; i < n; i += o) /* o | m-2*i */
    1545             :   {
    1546        6321 :     gel(F,3) = negi(mulii(gel(tv,m-2*i+1), gel(pk,i+1)));
    1547        6321 :     v = ZX_mul(v, F);
    1548             :   }
    1549        3129 :   return gerepilecopy(av, v);
    1550             : }
    1551             : 
    1552             : static GEN
    1553       89832 : ellsympow(GEN E, ulong m, GEN p, long n)
    1554             : {
    1555       89832 :   pari_sp av = avma;
    1556       89832 :   GEN ap = ellap(E, p);
    1557       89797 :   if (n <= 2)
    1558             :   {
    1559       86698 :     GEN t = ellsympow_trace(p, ap, m);
    1560       86549 :     return deg1pol_shallow(t, gen_1, 0);
    1561             :   }
    1562             :   else
    1563        3099 :     return gerepileupto(av, RgXn_inv_i(ellsympow_abelian(p, ap, m, 1), n));
    1564             : }
    1565             : 
    1566             : GEN
    1567        5650 : direllsympow_worker(GEN P, ulong X, GEN E, ulong m)
    1568             : {
    1569        5650 :   pari_sp av = avma;
    1570        5650 :   long i, l = lg(P);
    1571        5650 :   GEN W = cgetg(l, t_VEC);
    1572       95482 :   for(i = 1; i < l; i++)
    1573             :   {
    1574       89826 :     ulong p = uel(P,i);
    1575       89826 :     long d = ulogint(X, p) + 1; /* minimal d such that p^d > X */
    1576       89828 :     gel(W,i) = ellsympow(E, m, utoi(uel(P,i)), d);
    1577             :   }
    1578        5656 :   return gerepilecopy(av, mkvec2(P,W));
    1579             : }
    1580             : 
    1581             : static GEN
    1582          56 : eulerf_bad(GEN bad, GEN p)
    1583             : {
    1584          56 :   long i, l = lg(bad);
    1585         112 :   for (i = 1; i < l; i++)
    1586          56 :     if (equalii(gmael(bad,i,1), p))
    1587           0 :       return gmael(bad,i,2);
    1588          56 :   return NULL;
    1589             : }
    1590             : 
    1591             : static GEN
    1592         343 : vecan_ellsympow(GEN an, long n)
    1593             : {
    1594         343 :   GEN nn = utoi(n), crvm = gel(an,1), bad = gel(an,2);
    1595         343 :   GEN worker = snm_closure(is_entry("_direllsympow_worker"), crvm);
    1596         343 :   return pardireuler(worker, gen_2, nn, nn, bad);
    1597             : }
    1598             : 
    1599             : static GEN
    1600          28 : eulerf_ellsympow(GEN an, GEN p)
    1601             : {
    1602          28 :   GEN crvm = gel(an,1), bad = gel(an,2), E = gel(crvm,1);
    1603          28 :   GEN f = eulerf_bad(bad, p);
    1604          28 :   if (f) return f;
    1605          28 :   retmkrfrac(gen_1,ellsympow_abelian(p, ellap(E, p), itos(gel(crvm,2)), 1));
    1606             : }
    1607             : 
    1608             : static long
    1609         196 : ellsympow_betam(long o, long m)
    1610             : {
    1611         196 :   const long c3[]={3, -1, 1};
    1612         196 :   const long c12[]={6, -2, 2, 0, 4, -4};
    1613         196 :   const long c24[]={12, -2, -4, 6, 4, -10};
    1614         196 :   if (!odd(o) && odd(m)) return 0;
    1615         161 :   switch(o)
    1616             :   {
    1617           0 :     case 1:  return m+1;
    1618          14 :     case 2:  return m+1;
    1619          84 :     case 3:  case 6: return (m+c3[m%3])/3;
    1620           0 :     case 4:  return m%4 == 0 ? (m+2)/2: m/2;
    1621          21 :     case 8:  return m%4 == 0 ? (m+4)/4: (m-2)/4;
    1622          35 :     case 12: return (m+c12[(m%12)/2])/6;
    1623           7 :     case 24: return (m+c24[(m%12)/2])/12;
    1624             :   }
    1625           0 :   return 0;
    1626             : }
    1627             : 
    1628             : static long
    1629          98 : ellsympow_epsm(long o, long m) { return m + 1 - ellsympow_betam(o, m); }
    1630             : 
    1631             : static GEN
    1632          98 : ellsympow_multred(GEN E, GEN p, long m, long vN, long *cnd, long *w)
    1633             : {
    1634          98 :   if (vN == 1 || !odd(m))
    1635             :   {
    1636          98 :     GEN s = (odd(m) && signe(ellap(E,p)) < 0)? gen_1: gen_m1;
    1637          98 :     *cnd = m;
    1638          98 :     *w = odd(m)? ellrootno(E, p): 1;
    1639          98 :     return deg1pol_shallow(s, gen_1, 0);
    1640             :   }
    1641             :   else
    1642             :   {
    1643           0 :     *cnd = equaliu(p,2)? ((m+1)>>1) * vN: m+1;
    1644           0 :     *w = (m & 3) == 1? ellrootno(E, p): 1;
    1645           0 :     return pol_1(0);
    1646             :   }
    1647             : }
    1648             : 
    1649             : static GEN
    1650          98 : ellsympow_nonabelian(GEN p, long m, long bet)
    1651             : {
    1652          98 :  GEN q = powiu(p, m >> 1), q2 = sqri(q), F;
    1653          98 :  if (odd(m))
    1654             :  {
    1655          35 :    q2 = mulii(q2, p); /* p^m */
    1656          35 :    return gpowgs(deg2pol_shallow(q2, gen_0, gen_1, 0), bet>>1);
    1657             :  }
    1658          63 :  togglesign_safe(&q2);
    1659          63 :  F = gpowgs(deg2pol_shallow(q2, gen_0, gen_1, 0), bet>>1);
    1660          63 :  if (!odd(bet)) return F;
    1661          28 :  if (m%4 != 2) togglesign_safe(&q);
    1662          28 :  return gmul(F, deg1pol_shallow(q, gen_1, 0));
    1663             : }
    1664             : 
    1665             : static long
    1666           0 : safe_Z_pvalrem(GEN n, GEN p, GEN *pr)
    1667           0 : { return signe(n)==0? -1: Z_pvalrem(n, p, pr); }
    1668             : 
    1669             : static GEN
    1670           0 : c4c6_ap(GEN c4, GEN c6, GEN p)
    1671             : {
    1672           0 :   GEN N = Fp_ellcard(Fp_muls(c4, -27, p), Fp_muls(c6, -54, p), p);
    1673           0 :   return subii(addiu(p, 1), N);
    1674             : }
    1675             : 
    1676             : static GEN
    1677           0 : ellsympow_abelian_twist(GEN E, GEN p, long m, long o)
    1678             : {
    1679           0 :   GEN ap, c4t, c6t, c4 = ell_get_c4(E), c6 = ell_get_c6(E);
    1680           0 :   long v4 = safe_Z_pvalrem(c4, p, &c4t);
    1681           0 :   long v6 = safe_Z_pvalrem(c6, p, &c6t);
    1682           0 :   if (v6>=0 && (v4==-1 || 3*v4>=2*v6)) c6 = c6t;
    1683           0 :   if (v4>=0 && (v6==-1 || 3*v4<=2*v6)) c4 = c4t;
    1684           0 :   ap = c4c6_ap(c4, c6, p);
    1685           0 :   return ellsympow_abelian(p, ap, m, o);
    1686             : }
    1687             : 
    1688             : static GEN
    1689           0 : ellsympow_goodred(GEN E, GEN p, long m, long *cnd, long *w)
    1690             : {
    1691           0 :   long o = 12/cgcd(12, Z_pval(ell_get_disc(E), p));
    1692           0 :   long bet = ellsympow_betam(o, m);
    1693           0 :   long eps = m + 1 - bet;
    1694           0 :   *w = odd(m) && odd(eps>>1) ? ellrootno(E,p): 1;
    1695           0 :   *cnd = eps;
    1696           0 :   if (umodiu(p, o) == 1)
    1697           0 :     return ellsympow_abelian_twist(E, p, m, o);
    1698             :   else
    1699           0 :     return ellsympow_nonabelian(p, m, bet);
    1700             : }
    1701             : 
    1702             : static long
    1703          70 : ellsympow_inertia3(GEN E, long vN)
    1704             : {
    1705          70 :   long vD = Z_lval(ell_get_disc(E), 3);
    1706          70 :   if (vN==2) return vD%2==0 ? 2: 4;
    1707          70 :   if (vN==4) return vD%4==0 ? 3: 6;
    1708          70 :   if (vN==3 || vN==5) return 12;
    1709           0 :   return 0;
    1710             : }
    1711             : 
    1712             : static long
    1713          70 : ellsympow_deltam3(long o, long m, long vN)
    1714             : {
    1715          70 :   if (o==3 || o==6) return ellsympow_epsm(3, m);
    1716          70 :   if (o==12 && vN ==3) return (ellsympow_epsm(3, m))/2;
    1717           0 :   if (o==12 && vN ==5) return (ellsympow_epsm(3, m))*3/2;
    1718           0 :   return 0;
    1719             : }
    1720             : 
    1721             : static long
    1722           0 : ellsympow_isabelian3(GEN E)
    1723             : {
    1724           0 :   ulong c4 = umodiu(ell_get_c4(E),81), c6 = umodiu(ell_get_c6(E), 243);
    1725           0 :   return (c4 == 27 || (c4%27==9 && (c6==108 || c6==135)));
    1726             : }
    1727             : 
    1728             : static long
    1729          35 : ellsympow_rootno3(GEN E, GEN p, long o, long m)
    1730             : {
    1731          35 :   const long  w6p[]={1,-1,-1,-1,1,1};
    1732          35 :   const long  w6n[]={-1,1,-1,1,-1,1};
    1733          35 :   const long w12p[]={1,1,-1,1,1,1};
    1734          35 :   const long w12n[]={-1,-1,-1,-1,-1,1};
    1735          35 :   long w = ellrootno(E, p), mm = (m%12)>>1;
    1736          35 :   switch(o)
    1737             :   {
    1738           0 :     case 2: return m%4== 1 ? -1: 1;
    1739           0 :     case 6:  return w == 1 ? w6p[mm]: w6n[mm];
    1740          35 :     case 12: return w == 1 ? w12p[mm]: w12n[mm];
    1741           0 :     default: return 1;
    1742             :   }
    1743             : }
    1744             : 
    1745             : static GEN
    1746          70 : ellsympow_goodred3(GEN E, GEN F, GEN p, long m, long vN, long *cnd, long *w)
    1747             : {
    1748          70 :   long o = ellsympow_inertia3(E, vN);
    1749          70 :   long bet = ellsympow_betam(o, m);
    1750          70 :   *cnd = m + 1 - bet + ellsympow_deltam3(o, m, vN);
    1751          70 :   *w = odd(m)? ellsympow_rootno3(E, p, o, m): 1;
    1752          70 :   if (o==1 || o==2)
    1753           0 :     return ellsympow_abelian(p, ellap(F, p), m, o);
    1754          70 :   if ((o==3 || o==6) && ellsympow_isabelian3(F))
    1755           0 :     return ellsympow_abelian(p, p, m, o);
    1756             :   else
    1757          70 :     return ellsympow_nonabelian(p, m, bet);
    1758             : }
    1759             : 
    1760             : static long
    1761          28 : ellsympow_inertia2(GEN F, long vN)
    1762             : {
    1763          28 :   long vM = itos(gel(elllocalred(F, gen_2),1));
    1764          28 :   GEN c6 = ell_get_c6(F);
    1765          28 :   long v6 = signe(c6) ? vali(c6): 24;
    1766          28 :   if (vM==0) return vN==0 ? 1: 2;
    1767          28 :   if (vM==2) return vN==2 ? 3: 6;
    1768          14 :   if (vM==5) return 8;
    1769           7 :   if (vM==8) return v6>=9? 8: 4;
    1770           7 :   if (vM==3 || vN==7) return 24;
    1771           0 :   return 0;
    1772             : }
    1773             : 
    1774             : static long
    1775          28 : ellsympow_deltam2(long o, long m, long vN)
    1776             : {
    1777          28 :   if ((o==2 || o==6) && vN==4) return ellsympow_epsm(2, m);
    1778          28 :   if ((o==2 || o==6) && vN==6) return 2*ellsympow_epsm(2, m);
    1779          28 :   if (o==4) return 2*ellsympow_epsm(4, m)+ellsympow_epsm(2, m);
    1780          28 :   if (o==8 && vN==5) return ellsympow_epsm(8, m)+ellsympow_epsm(2, m)/2;
    1781          21 :   if (o==8 && vN==6) return ellsympow_epsm(8, m)+ellsympow_epsm(2, m);
    1782          21 :   if (o==8 && vN==8) return ellsympow_epsm(8, m)+ellsympow_epsm(4, m)+ellsympow_epsm(2, m);
    1783          21 :   if (o==24 && vN==3) return (2*ellsympow_epsm(8, m)+ellsympow_epsm(2, m))/6;
    1784          14 :   if (o==24 && vN==4) return (ellsympow_epsm(8, m)+ellsympow_epsm(2, m)*2)/3;
    1785          14 :   if (o==24 && vN==6) return (ellsympow_epsm(8, m)+ellsympow_epsm(2, m)*5)/3;
    1786          14 :   if (o==24 && vN==7) return (ellsympow_epsm(8, m)*10+ellsympow_epsm(2, m)*5)/6;
    1787          14 :   return 0;
    1788             : }
    1789             : 
    1790             : static long
    1791           0 : ellsympow_isabelian2(GEN F)
    1792           0 : { return umodi2n(ell_get_c4(F),7) == 96; }
    1793             : 
    1794             : static long
    1795           0 : ellsympow_rootno2(GEN E, long vN, long m, long bet)
    1796             : {
    1797           0 :   long eps2 = (m + 1 - bet)>>1;
    1798           0 :   long eta = odd(vN) && m%8==3 ? -1 : 1;
    1799           0 :   long w2 = odd(eps2) ? ellrootno(E, gen_2): 1;
    1800           0 :   return eta == w2 ? 1 : -1;
    1801             : }
    1802             : 
    1803             : static GEN
    1804          28 : ellsympow_goodred2(GEN E, GEN F, GEN p, long m, long vN, long *cnd, long *w)
    1805             : {
    1806          28 :   long o = ellsympow_inertia2(F, vN);
    1807          28 :   long bet = ellsympow_betam(o, m);
    1808          28 :   *cnd = m + 1 - bet + ellsympow_deltam2(o, m, vN);
    1809          28 :   *w = odd(m) ? ellsympow_rootno2(E, vN, m, bet): 1;
    1810          28 :   if (o==1 || o==2)
    1811           0 :     return ellsympow_abelian(p, ellap(F, p), m, o);
    1812          28 :   if (o==4 && ellsympow_isabelian2(F))
    1813           0 :     return ellsympow_abelian(p, p, m, o);
    1814             :   else
    1815          28 :     return ellsympow_nonabelian(p, m, bet);
    1816             : }
    1817             : 
    1818             : static GEN
    1819         189 : ellminimaldotwist(GEN E, GEN *pD)
    1820             : {
    1821         189 :   GEN D = ellminimaltwistcond(E), Et = elltwist(E, D), Etmin;
    1822         189 :   if (pD) *pD = D;
    1823         189 :   Etmin = ellminimalmodel(Et, NULL);
    1824         189 :   obj_free(Et); return Etmin;
    1825             : }
    1826             : 
    1827             : /* Based on
    1828             : Symmetric powers of elliptic curve L-functions,
    1829             : Phil Martin and Mark Watkins, ANTS VII
    1830             : <http://magma.maths.usyd.edu.au/users/watkins/papers/antsVII.pdf>
    1831             : with thanks to Mark Watkins. BA20180402
    1832             : */
    1833             : static GEN
    1834         140 : lfunellsympow(GEN e, ulong m)
    1835             : {
    1836         140 :   pari_sp av = avma;
    1837             :   GEN B, N, Nfa, pr, ex, ld, bad, ejd, et, pole;
    1838         140 :   long i, l, mero, w = (m&7)==1 || (m&7)==3 ? -1: 1;
    1839         140 :   checkell_Q(e);
    1840         140 :   e = ellminimalmodel(e, NULL);
    1841         140 :   ejd = Q_denom(ell_get_j(e));
    1842         140 :   mero = m==0 || (m%4==0 && ellQ_get_CM(e)<0);
    1843         140 :   ellQ_get_Nfa(e, &N, &Nfa);
    1844         140 :   pr = gel(Nfa,1);
    1845         140 :   ex = gel(Nfa,2); l = lg(pr);
    1846         140 :   if (ugcd(umodiu(N,6), 6) == 1)
    1847          21 :     et = NULL;
    1848             :   else
    1849         119 :     et = ellminimaldotwist(e, NULL);
    1850         140 :   B = gen_1;
    1851         140 :   bad = cgetg(l, t_VEC);
    1852         336 :   for (i=1; i<l; i++)
    1853             :   {
    1854         196 :     long vN = itos(gel(ex,i));
    1855         196 :     GEN p = gel(pr,i), eul;
    1856             :     long cnd, wp;
    1857         196 :     if (dvdii(ejd, p))
    1858          98 :       eul = ellsympow_multred(e, p, m, vN, &cnd, &wp);
    1859          98 :     else if (equaliu(p, 2))
    1860          28 :       eul = ellsympow_goodred2(e, et, p, m, vN, &cnd, &wp);
    1861          70 :     else if (equaliu(p, 3))
    1862          70 :       eul = ellsympow_goodred3(e, et, p, m, vN, &cnd, &wp);
    1863             :     else
    1864           0 :       eul = ellsympow_goodred(e, p, m, &cnd, &wp);
    1865         196 :     gel(bad, i) = mkvec2(p, ginv(eul));
    1866         196 :     B = mulii(B, powiu(p,cnd));
    1867         196 :     w *= wp;
    1868             :   }
    1869         140 :   pole = mero ? mkvec(mkvec2(stoi(1+(m>>1)),gen_0)): NULL;
    1870         280 :   ld = mkvecn(mero? 7: 6, tag(mkvec2(mkvec2(e,utoi(m)),bad), t_LFUN_SYMPOW_ELL),
    1871         140 :         gen_0, ellsympow_gamma(m), stoi(m+1), B, stoi(w), pole);
    1872         140 :   if (et) obj_free(et);
    1873         140 :   return gerepilecopy(av, ld);
    1874             : }
    1875             : 
    1876             : GEN
    1877          70 : lfunsympow(GEN ldata, ulong m)
    1878             : {
    1879          70 :   ldata = lfunmisc_to_ldata_shallow(ldata);
    1880          70 :   if (ldata_get_type(ldata) != t_LFUN_ELL)
    1881           0 :     pari_err_IMPL("lfunsympow");
    1882          70 :   return lfunellsympow(gel(ldata_get_an(ldata), 2), m);
    1883             : }
    1884             : 
    1885             : static GEN
    1886          28 : lfunmfspec_i(GEN lmisc, long bit)
    1887             : {
    1888             :   GEN linit, ldataf, v, ve, vo, om, op, B, dom;
    1889             :   long k, k2, j;
    1890             : 
    1891          28 :   ldataf = lfunmisc_to_ldata_shallow(lmisc);
    1892          28 :   if (!gequal(ldata_get_gammavec(ldataf), mkvec2(gen_0,gen_1)))
    1893           0 :     pari_err_TYPE("lfunmfspec", lmisc);
    1894          28 :   k = gtos(ldata_get_k(ldataf));
    1895          28 :   if (k == 1) return mkvec2(cgetg(1, t_VEC), gen_1);
    1896          21 :   dom = mkvec3(dbltor(k/2.), dbltor((k-2)/2.), gen_0);
    1897          21 :   if (is_linit(lmisc) && linit_get_type(lmisc) == t_LDESC_INIT
    1898           0 :       && sdomain_isincl((double)k, dom, lfun_get_dom(linit_get_tech(lmisc))))
    1899           0 :     linit = lmisc;
    1900             :   else
    1901          21 :     linit = lfuninit(ldataf, dom, 0, bit);
    1902          21 :   B = int2n(bit/4);
    1903          21 :   v = cgetg(k, t_VEC);
    1904         168 :   for (j = 1; j < k; j++) gel(v,j) = lfunlambda(linit, utoi(j), bit);
    1905          21 :   om = gel(v,1);
    1906          21 :   if (odd(k)) return mkvec2(bestappr(gdiv(v, om), B), om);
    1907             : 
    1908           7 :   k2 = k/2;
    1909           7 :   ve = cgetg(k2, t_VEC);
    1910           7 :   vo = cgetg(k2+1, t_VEC);
    1911           7 :   gel(vo,1) = om;
    1912          42 :   for (j = 1; j < k2; j++)
    1913             :   {
    1914          35 :     gel(ve,j) = gel(v,2*j);
    1915          35 :     gel(vo,j+1) = gel(v,2*j+1);
    1916             :   }
    1917           7 :   if (k2 == 1) { om = gen_1;    op = gel(v,1); }
    1918           7 :   else         { om = gel(v,2); op = gel(v,3); }
    1919           7 :   if (maxss(gexpo(imag_i(om)), gexpo(imag_i(op))) > -bit/2)
    1920           0 :     pari_err_TYPE("lfunmfspec", lmisc);
    1921           7 :   ve = gdiv(ve, om);
    1922           7 :   vo = gdiv(vo, op);
    1923           7 :   return mkvec4(bestappr(ve,B), bestappr(vo,B), om, op);
    1924             : }
    1925             : GEN
    1926          28 : lfunmfspec(GEN lmisc, long bit)
    1927             : {
    1928          28 :   pari_sp av = avma;
    1929          28 :   return gerepilecopy(av, lfunmfspec_i(lmisc, bit));
    1930             : }
    1931             : 
    1932             : static long
    1933          28 : ellsymsq_bad2(GEN c4, GEN c6, long e)
    1934             : {
    1935          28 :   switch (e)
    1936             :   {
    1937          14 :     case 2: return 1;
    1938           7 :     case 3: return 0;
    1939           7 :     case 5: return 0;
    1940           0 :     case 7: return 0;
    1941           0 :     case 8:
    1942           0 :       if (!umodi2n(c6,9)) return 0;
    1943           0 :       return umodi2n(c4,7)==32 ? 1 : -1;
    1944           0 :     default: return 0;
    1945             :   }
    1946             : }
    1947             : static long
    1948          14 : ellsymsq_bad3(GEN c4, GEN c6, long e)
    1949             : {
    1950             :   long c6_243, c4_81;
    1951          14 :   switch (e)
    1952             :   {
    1953           0 :     case 2: return 1;
    1954          14 :     case 3: return 0;
    1955           0 :     case 5: return 0;
    1956           0 :     case 4:
    1957           0 :       c4_81 = umodiu(c4,81);
    1958           0 :       if (c4_81 == 27) return -1;
    1959           0 :       if (c4_81%27 != 9) return 1;
    1960           0 :       c6_243 = umodiu(c6,243);
    1961           0 :       return (c6_243==108 || c6_243==135)? -1: 1;
    1962           0 :     default: return 0;
    1963             :   }
    1964             : }
    1965             : static int
    1966           0 : c4c6_testp(GEN c4, GEN c6, GEN p)
    1967           0 : { GEN p2 = sqri(p); return (dvdii(c6,p2) && !dvdii(c4,p2)); }
    1968             : /* assume e = v_p(N) >= 2 */
    1969             : static long
    1970          42 : ellsymsq_badp(GEN c4, GEN c6, GEN p, long e)
    1971             : {
    1972          42 :   if (absequaliu(p, 2)) return ellsymsq_bad2(c4, c6, e);
    1973          14 :   if (absequaliu(p, 3)) return ellsymsq_bad3(c4, c6, e);
    1974           0 :   switch(umodiu(p, 12UL))
    1975             :   {
    1976           0 :     case 1: return -1;
    1977           0 :     case 5: return c4c6_testp(c4,c6,p)? -1: 1;
    1978           0 :     case 7: return c4c6_testp(c4,c6,p)?  1:-1;
    1979           0 :     default:return 1; /* p%12 = 11 */
    1980             :   }
    1981             : }
    1982             : static GEN
    1983          70 : lfunellsymsqmintwist(GEN e)
    1984             : {
    1985          70 :   pari_sp av = avma;
    1986             :   GEN N, Nfa, P, E, V, c4, c6, ld;
    1987             :   long i, l, k;
    1988          70 :   checkell_Q(e);
    1989          70 :   e = ellminimalmodel(e, NULL);
    1990          70 :   ellQ_get_Nfa(e, &N, &Nfa);
    1991          70 :   c4 = ell_get_c4(e);
    1992          70 :   c6 = ell_get_c6(e);
    1993          70 :   P = gel(Nfa,1); l = lg(P);
    1994          70 :   E = gel(Nfa,2);
    1995          70 :   V = cgetg(l, t_VEC);
    1996         196 :   for (i=k=1; i<l; i++)
    1997             :   {
    1998         126 :     GEN p = gel(P,i);
    1999         126 :     long a, e = itos(gel(E,i));
    2000         126 :     if (e == 1) continue;
    2001          42 :     a = ellsymsq_badp(c4, c6, p, e);
    2002          42 :     gel(V,k++) = mkvec2(p, stoi(a));
    2003             :   }
    2004          70 :   setlg(V, k);
    2005          70 :   ld = lfunellsympow(e, 2);
    2006          70 :   return gerepilecopy(av, mkvec2(ld, V));
    2007             : }
    2008             : 
    2009             : static GEN
    2010          70 : mfpeters(GEN ldata2, GEN fudge, GEN N, long k, long bitprec)
    2011             : {
    2012          70 :   GEN t, L = real_i(lfun(ldata2, stoi(k), bitprec));
    2013          70 :   long prec = nbits2prec(bitprec);
    2014          70 :   t = powrs(mppi(prec), k+1); shiftr_inplace(t, 2*k-1); /* Pi/2 * (4Pi)^k */
    2015          70 :   return gmul(gdiv(gmul(mulii(N,mpfact(k-1)), fudge), t), L);
    2016             : }
    2017             : 
    2018             : /* Assume E to be twist-minimal */
    2019             : static GEN
    2020          70 : lfunellmfpetersmintwist(GEN E, long bitprec)
    2021             : {
    2022          70 :   pari_sp av = avma;
    2023          70 :   GEN symsq, veceuler, N = ellQ_get_N(E), fudge = gen_1;
    2024          70 :   long j, k = 2;
    2025          70 :   symsq = lfunellsymsqmintwist(E);
    2026          70 :   veceuler = gel(symsq,2);
    2027         112 :   for (j = 1; j < lg(veceuler); j++)
    2028             :   {
    2029          42 :     GEN v = gel(veceuler,j), p = gel(v,1), q = powis(p,1-k);
    2030          42 :     long s = signe(gel(v,2));
    2031          42 :     if (s) fudge = gmul(fudge, s==1 ? gaddsg(1, q): gsubsg(1, q));
    2032             :   }
    2033          70 :   return gerepileupto(av, mfpeters(gel(symsq,1),fudge,N,k,bitprec));
    2034             : }
    2035             : 
    2036             : /* From Christophe Delaunay, http://delaunay.perso.math.cnrs.fr/these.pdf */
    2037             : static GEN
    2038          70 : elldiscfix(GEN E, GEN Et, GEN D)
    2039             : {
    2040          70 :   GEN N = ellQ_get_N(E), Nt = ellQ_get_N(Et);
    2041          70 :   GEN P = gel(absZ_factor(D), 1);
    2042          70 :   GEN f = gen_1;
    2043          70 :   long i, l = lg(P);
    2044         133 :   for (i=1; i < l; i++)
    2045             :   {
    2046          63 :     GEN r, p = gel(P,i);
    2047          63 :     long v = Z_pval(N, p), vt = Z_pval(Nt, p);
    2048          63 :     if (v <= vt) continue;
    2049             :     /* v > vt */
    2050          49 :     if (absequaliu(p, 2))
    2051             :     {
    2052          28 :       if (vt == 0 && v >= 4)
    2053           0 :         r = shifti(subsi(9, sqri(ellap(Et, p))), v-3);  /* 9=(2+1)^2 */
    2054          28 :       else if (vt == 1)
    2055           7 :         r = gmul2n(utoipos(3), v-3);  /* not in Z if v=2 */
    2056          21 :       else if (vt >= 2)
    2057          21 :         r = int2n(v-vt);
    2058             :       else
    2059           0 :         r = gen_1; /* vt = 0, 1 <= v <= 3 */
    2060             :     }
    2061          21 :     else if (vt >= 1)
    2062          14 :       r = gdiv(subiu(sqri(p), 1), p);
    2063             :     else
    2064           7 :       r = gdiv(mulii(subiu(p, 1), subii(sqri(addiu(p, 1)), sqri(ellap(Et, p)))), p);
    2065          49 :     f = gmul(f, r);
    2066             :   }
    2067          70 :   return f;
    2068             : }
    2069             : 
    2070             : GEN
    2071          70 : lfunellmfpeters(GEN E, long bitprec)
    2072             : {
    2073          70 :   pari_sp ltop = avma;
    2074          70 :   GEN D, Et = ellminimaldotwist(E, &D);
    2075          70 :   GEN nor = lfunellmfpetersmintwist(Et, bitprec);
    2076          70 :   GEN nor2 = gmul(nor, elldiscfix(E, Et, D));
    2077          70 :   obj_free(Et); return gerepileupto(ltop, nor2);
    2078             : }
    2079             : 
    2080             : /*************************************************************/
    2081             : /*               Genus 2 curves                              */
    2082             : /*************************************************************/
    2083             : 
    2084             : static void
    2085      233611 : Flv_diffnext(GEN d, ulong p)
    2086             : {
    2087      233611 :   long j, n = lg(d)-1;
    2088     1635277 :   for(j = n; j>=2; j--)
    2089     1401666 :     uel(d,j) = Fl_add(uel(d,j), uel(d,j-1), p);
    2090      233611 : }
    2091             : 
    2092             : static GEN
    2093        1995 : Flx_difftable(GEN P, ulong p)
    2094             : {
    2095        1995 :   long i, n = degpol(P);
    2096        1995 :   GEN V = cgetg(n+2, t_VECSMALL);
    2097        1995 :   uel(V, n+1) = Flx_constant(P);
    2098       13965 :   for(i = n; i >= 1; i--)
    2099             :   {
    2100       11970 :     P = Flx_diff1(P, p);
    2101       11970 :     uel(V, i) = Flx_constant(P);
    2102             :   }
    2103        1995 :   return V;
    2104             : }
    2105             : 
    2106             : static long
    2107        1995 : Flx_genus2trace_naive(GEN H, ulong p)
    2108             : {
    2109        1995 :   pari_sp av = avma;
    2110             :   ulong i, j;
    2111        1995 :   long a, n = degpol(H);
    2112        1995 :   GEN k = const_vecsmall(p, -1), d;
    2113        1995 :   k[1] = 0;
    2114      117803 :   for (i=1, j=1; i < p; i += 2, j = Fl_add(j, i, p))
    2115      115808 :     k[j+1] = 1;
    2116        1995 :   a = n == 5 ? 0: k[1+Flx_lead(H)];
    2117        1995 :   d = Flx_difftable(H, p);
    2118      235606 :   for (i=0; i < p; i++)
    2119             :   {
    2120      233611 :     a += k[1+uel(d,n+1)];
    2121      233611 :     Flv_diffnext(d, p);
    2122             :   }
    2123        1995 :   set_avma(av);
    2124        1995 :   return a;
    2125             : }
    2126             : 
    2127             : static GEN
    2128        2156 : dirgenus2(GEN Q, GEN p, long n)
    2129             : {
    2130        2156 :   pari_sp av = avma;
    2131             :   GEN f;
    2132        2156 :   if (n > 2)
    2133         161 :     f = RgX_recip(hyperellcharpoly(gmul(Q,gmodulo(gen_1, p))));
    2134             :   else
    2135             :   {
    2136        1995 :     ulong pp = itou(p);
    2137        1995 :     GEN Qp = ZX_to_Flx(Q, pp);
    2138        1995 :     long t = Flx_genus2trace_naive(Qp, pp);
    2139        1995 :     f = deg1pol_shallow(stoi(t), gen_1, 0);
    2140             :   }
    2141        2156 :   return gerepileupto(av, RgXn_inv_i(f, n));
    2142             : }
    2143             : 
    2144             : GEN
    2145         875 : dirgenus2_worker(GEN P, ulong X, GEN Q)
    2146             : {
    2147         875 :   pari_sp av = avma;
    2148         875 :   long i, l = lg(P);
    2149         875 :   GEN V = cgetg(l, t_VEC);
    2150        3031 :   for(i = 1; i < l; i++)
    2151             :   {
    2152        2156 :     ulong p = uel(P,i);
    2153        2156 :     long d = ulogint(X, p) + 1; /* minimal d such that p^d > X */
    2154        2156 :     gel(V,i) = dirgenus2(Q, utoi(uel(P,i)), d);
    2155             :   }
    2156         875 :   return gerepilecopy(av, mkvec2(P,V));
    2157             : }
    2158             : 
    2159             : static GEN
    2160         196 : vecan_genus2(GEN an, long L)
    2161             : {
    2162         196 :   GEN Q = gel(an,1), bad = gel(an, 2);
    2163         196 :   GEN worker = snm_closure(is_entry("_dirgenus2_worker"), mkvec(Q));
    2164         196 :   return pardireuler(worker, gen_2, stoi(L), NULL, bad);
    2165             : }
    2166             : 
    2167             : static GEN
    2168           0 : eulerf_genus2(GEN an, GEN p)
    2169             : {
    2170           0 :   GEN Q = gel(an,1), bad = gel(an, 2);
    2171           0 :   GEN f = eulerf_bad(bad, p);
    2172           0 :   if (f) return f;
    2173           0 :   f = RgX_recip(hyperellcharpoly(gmul(Q,gmodulo(gen_1, p))));
    2174           0 :   return mkrfrac(gen_1,f);
    2175             : }
    2176             : 
    2177             : static GEN
    2178          49 : genus2_redmodel(GEN P, GEN p)
    2179             : {
    2180          49 :   GEN M = FpX_factor(P, p);
    2181          49 :   GEN F = gel(M,1), E = gel(M,2);
    2182          49 :   long i, k, r = lg(F);
    2183          49 :   GEN U = scalarpol(leading_coeff(P), varn(P));
    2184          49 :   GEN G = cgetg(r, t_COL);
    2185         161 :   for (i=1, k=0; i<r; i++)
    2186             :   {
    2187         112 :     if (E[i]>1)
    2188          56 :       gel(G,++k) = gel(F,i);
    2189         112 :     if (odd(E[i]))
    2190          77 :       U = FpX_mul(U, gel(F,i), p);
    2191             :   }
    2192          49 :   setlg(G,++k);
    2193          49 :   return mkvec2(G,U);
    2194             : }
    2195             : 
    2196             : static GEN
    2197         308 : oneminusxd(long d)
    2198             : {
    2199         308 :   return gsub(gen_1, pol_xn(d, 0));
    2200             : }
    2201             : 
    2202             : static GEN
    2203          21 : ellfromeqncharpoly(GEN P, GEN Q, GEN p)
    2204             : {
    2205             :   long v;
    2206             :   GEN E, F, t, y;
    2207          21 :   v = fetch_var();
    2208          21 :   y = pol_x(v);
    2209          21 :   F = gsub(gadd(ZX_sqr(y), gmul(y, Q)), P);
    2210          21 :   E = ellinit(ellfromeqn(F), p, DEFAULTPREC);
    2211          21 :   delete_var();
    2212          21 :   t = ellap(E, p);
    2213          21 :   obj_free(E);
    2214          21 :   return mkpoln(3, gen_1, negi(t), p);
    2215             : }
    2216             : 
    2217             : /* Assume P has semistable reduction at p */
    2218             : static GEN
    2219          49 : genus2_eulerfact_semistable(GEN P, GEN p)
    2220             : {
    2221          49 :   GEN Pp = FpX_red(P, p);
    2222          49 :   GEN GU = genus2_redmodel(Pp, p);
    2223          49 :   long d = 6-degpol(Pp), v = d/2, w = odd(d);
    2224             :   GEN abe, tor;
    2225          49 :   GEN ki, kp = pol_1(0), kq = pol_1(0);
    2226          49 :   GEN F = gel(GU,1), Q = gel(GU,2);
    2227          49 :   long dQ = degpol(Q), lF = lg(F)-1;
    2228             : 
    2229           0 :   abe = dQ >= 5 ? RgX_recip(hyperellcharpoly(gmul(Q,gmodulo(gen_1,p))))
    2230          98 :       : dQ >= 3 ? RgX_recip(ellfromeqncharpoly(Q,gen_0,p))
    2231          49 :                 : pol_1(0);
    2232          42 :   ki = dQ != 0 ? oneminusxd(1)
    2233          56 :               : Fp_issquare(gel(Q,2),p) ? ZX_sqr(oneminusxd(1))
    2234           7 :                                         : oneminusxd(2);
    2235          49 :   if (lF)
    2236             :   {
    2237             :     long i;
    2238          98 :     for(i=1; i <= lF; i++)
    2239             :     {
    2240          56 :       GEN Fi = gel(F, i);
    2241          56 :       long d = degpol(Fi);
    2242          56 :       GEN e = FpX_rem(Q, Fi, p);
    2243          91 :       GEN kqf = lgpol(e)==0 ? oneminusxd(d):
    2244          70 :                 FpXQ_issquare(e, Fi, p) ? ZX_sqr(oneminusxd(d))
    2245          35 :                                         : oneminusxd(2*d);
    2246          56 :       kp = gmul(kp, oneminusxd(d));
    2247          56 :       kq = gmul(kq, kqf);
    2248             :     }
    2249             :   }
    2250          49 :   if (v)
    2251             :   {
    2252           7 :     GEN kqoo = w==1 ? oneminusxd(1):
    2253           0 :                Fp_issquare(leading_coeff(Q), p)? ZX_sqr(oneminusxd(1))
    2254           0 :                                               : oneminusxd(2);
    2255           7 :     kp = gmul(kp, oneminusxd(1));
    2256           7 :     kq = gmul(kq, kqoo);
    2257             :   }
    2258          49 :   tor = RgX_div(ZX_mul(oneminusxd(1), kq), ZX_mul(ki, kp));
    2259          49 :   return ginv( ZX_mul(abe, tor) );
    2260             : }
    2261             : 
    2262             : /* See algo57. if inf=0, ignore point at infinity */
    2263             : static GEN
    2264          42 : algo57bis(GEN F, long g, GEN p, long inf)
    2265             : {
    2266          42 :   pari_sp av = avma;
    2267          42 :   GEN vl = cgetg(3,t_VEC);
    2268          42 :   long nl = 1;
    2269          42 :   long ep = ZX_pval(F,p);
    2270          42 :   GEN Fe = FpX_red(ep ? ZX_Z_divexact(F,p): F, p);
    2271          42 :   if (inf && degpol(Fe) <= g+1+ep)
    2272             :   {
    2273           0 :     GEN Fi = ZX_unscale(RgXn_recip_shallow(F,2*g+3), p);
    2274           0 :     long lambda = ZX_pval(Fi,p);
    2275           0 :     if (lambda > g)
    2276             :     {
    2277           0 :       GEN ppr = powiu(p,lambda>>1);
    2278           0 :       gel(vl,nl++) = ZX_Z_divexact(Fi,sqri(ppr));
    2279             :     }
    2280             :   }
    2281             :   {
    2282          42 :     GEN R = FpX_roots_mult(Fe, g+1, p);
    2283          42 :     long j, lR = lg(R);
    2284          63 :     for (j = 1; j<lR; j++)
    2285             :     {
    2286          21 :       GEN c = gel(R,j);
    2287          21 :       GEN Fi = ZX_affine(F,p,c);
    2288          21 :       long lambda = ZX_pval(Fi,p);
    2289          21 :       if (lambda > g)
    2290             :       {
    2291           0 :         GEN ppr = powiu(p,lambda>>1);
    2292           0 :         gel(vl,nl++) = ZX_Z_divexact(Fi,sqri(ppr));
    2293             :       }
    2294             :     }
    2295             :   }
    2296          42 :   setlg(vl, nl);
    2297          42 :   return gerepilecopy(av,vl);
    2298             : }
    2299             : 
    2300             : static GEN
    2301          42 : list_minimalmodels(GEN F, long g, GEN p)
    2302             : {
    2303          42 :   GEN R, W = algo57bis(F, g, p, 1);
    2304          42 :   long i, l = lg(W);
    2305          42 :   if (l==1) return mkvec(F);
    2306           0 :   R = cgetg(3, t_VEC);
    2307           0 :   gel(R,2) = F;
    2308           0 :   for(i = 1; i<l; i++)
    2309             :   {
    2310           0 :     GEN G = gel(W,i);
    2311             :     while(1)
    2312           0 :     {
    2313           0 :       GEN Wi = algo57bis(G, g, p, 0);
    2314           0 :       if (lg(Wi)==1) break;
    2315           0 :       G = gel(Wi,1);
    2316             :     }
    2317           0 :     gel(R,i) = G;
    2318             :   }
    2319           0 :   return R;
    2320             : }
    2321             : 
    2322             : static GEN
    2323          49 : genus2_eulerfact(GEN P, GEN p)
    2324             : {
    2325             :   GEN W;
    2326          49 :   if (ZX_pval(P, p) > 0) return genus2_eulerfact_semistable(P,p);
    2327          42 :   W = list_minimalmodels(P, 2, p);
    2328          42 :   if (lg(W) < 3) return genus2_eulerfact_semistable(P,p);
    2329           0 :   return gmul(genus2_eulerfact_semistable(gel(W,1),p),
    2330           0 :               genus2_eulerfact_semistable(gel(W,2),p));
    2331             : }
    2332             : 
    2333             : static GEN
    2334          28 : F2x_genus2_find_trans(GEN P, GEN Q, GEN F)
    2335             : {
    2336          28 :   pari_sp av = avma;
    2337          28 :   long i, d = F2x_degree(F), v = P[1];
    2338             :   GEN M, C, V;
    2339          28 :   M = cgetg(d+1, t_MAT);
    2340          84 :   for (i=1; i<=d; i++)
    2341             :   {
    2342          56 :     GEN Mi = F2x_rem(F2x_add(F2x_shift(Q,i-1), monomial_F2x(2*i-2,v)), F);
    2343          56 :     gel(M,i) = F2x_to_F2v(Mi, d);
    2344             :   }
    2345          28 :   C = F2x_to_F2v(F2x_rem(P, F), d);
    2346          28 :   V = F2m_F2c_invimage(M, C);
    2347          28 :   return gerepileuptoleaf(av, F2v_to_F2x(V, v));
    2348             : }
    2349             : 
    2350             : static GEN
    2351          35 : F2x_genus2_trans(GEN P, GEN Q, GEN H)
    2352             : {
    2353          35 :   return F2x_add(P,F2x_add(F2x_mul(H,Q), F2x_sqr(H)));
    2354             : }
    2355             : 
    2356             : static GEN
    2357          42 : F2x_genus_redoo(GEN P, GEN Q, long k)
    2358             : {
    2359          42 :   if (F2x_degree(P)==2*k)
    2360             :   {
    2361          14 :     long c = F2x_coeff(P,2*k-1), dQ = F2x_degree(Q);
    2362          14 :     if ((dQ==k-1 && c==1) || (dQ<k-1 && c==0))
    2363           7 :      return F2x_genus2_trans(P, Q, monomial_F2x(k, P[1]));
    2364             :   }
    2365          35 :   return P;
    2366             : }
    2367             : 
    2368             : static GEN
    2369          35 : F2x_pseudodisc(GEN P, GEN Q)
    2370             : {
    2371          35 :   GEN dP = F2x_deriv(P), dQ = F2x_deriv(Q);
    2372          35 :   return F2x_gcd(Q, F2x_add(F2x_mul(P, F2x_sqr(dQ)), F2x_sqr(dP)));
    2373             : }
    2374             : 
    2375             : static GEN
    2376          14 : F2x_genus_red(GEN P, GEN Q)
    2377             : {
    2378             :   long dP, dQ;
    2379             :   GEN F, FF;
    2380          14 :   P = F2x_genus_redoo(P, Q, 3);
    2381          14 :   P = F2x_genus_redoo(P, Q, 2);
    2382          14 :   P = F2x_genus_redoo(P, Q, 1);
    2383          14 :   dP = F2x_degree(P);
    2384          14 :   dQ = F2x_degree(Q);
    2385          14 :   FF = F = F2x_pseudodisc(P,Q);
    2386          35 :   while(F2x_degree(F)>0)
    2387             :   {
    2388          21 :     GEN M = gel(F2x_factor(F),1);
    2389          21 :     long i, l = lg(M);
    2390          49 :     for(i=1; i<l; i++)
    2391             :     {
    2392          28 :       GEN R = F2x_sqr(gel(M,i));
    2393          28 :       GEN H = F2x_genus2_find_trans(P, Q, R);
    2394          28 :       P = F2x_div(F2x_genus2_trans(P, Q, H), R);
    2395          28 :       Q = F2x_div(Q, gel(M,i));
    2396             :     }
    2397          21 :     F = F2x_pseudodisc(P, Q);
    2398             :   }
    2399          14 :   return mkvec4(P,Q,FF,mkvecsmall2(dP,dQ));
    2400             : }
    2401             : 
    2402             : /* Number of solutions of x^2+b*x+c */
    2403             : static long
    2404          21 : F2xqX_quad_nbroots(GEN b, GEN c, GEN T)
    2405             : {
    2406          21 :   if (lgpol(b) > 0)
    2407             :   {
    2408          14 :     GEN d = F2xq_div(c, F2xq_sqr(b, T), T);
    2409          14 :     return F2xq_trace(d, T)? 0: 2;
    2410             :   }
    2411             :   else
    2412           7 :     return 1;
    2413             : }
    2414             : 
    2415             : static GEN
    2416          14 : genus2_eulerfact2(GEN PQ)
    2417             : {
    2418          14 :   GEN V = F2x_genus_red(ZX_to_F2x(gel(PQ, 1)), ZX_to_F2x(gel(PQ, 2)));
    2419          14 :   GEN P = gel(V, 1), Q = gel(V, 2);
    2420          14 :   GEN F = gel(V, 3), v = gel(V, 4);
    2421             :   GEN abe, tor;
    2422          14 :   GEN ki, kp = pol_1(0), kq = pol_1(0);
    2423          14 :   long dP = F2x_degree(P), dQ = F2x_degree(Q), d = maxss(dP, 2*dQ);
    2424          14 :   if (!lgpol(F)) return pol_1(0);
    2425          21 :   ki = dQ!=0 || dP>0 ? oneminusxd(1):
    2426           7 :       dP==-1 ? ZX_sqr(oneminusxd(1)): oneminusxd(2);
    2427          28 :   abe = d>=5? RgX_recip(hyperellcharpoly(gmul(PQ,gmodulss(1,2)))):
    2428          14 :         d>=3? RgX_recip(ellfromeqncharpoly(F2x_to_ZX(P), F2x_to_ZX(Q), gen_2)):
    2429          14 :         pol_1(0);
    2430          14 :   if (lgpol(F))
    2431             :   {
    2432          14 :     GEN M = gel(F2x_factor(F), 1);
    2433          14 :     long i, lF = lg(M)-1;
    2434          35 :     for(i=1; i <= lF; i++)
    2435             :     {
    2436          21 :       GEN Fi = gel(M, i);
    2437          21 :       long d = F2x_degree(Fi);
    2438          21 :       long nb  = F2xqX_quad_nbroots(F2x_rem(Q, Fi), F2x_rem(P, Fi), Fi);
    2439          35 :       GEN kqf = nb==1 ? oneminusxd(d):
    2440           0 :                 nb==2 ? ZX_sqr(oneminusxd(d))
    2441          14 :                       : oneminusxd(2*d);
    2442          21 :       kp = gmul(kp, oneminusxd(d));
    2443          21 :       kq = gmul(kq, kqf);
    2444             :     }
    2445             :   }
    2446          14 :   if (maxss(v[1],2*v[2])<5)
    2447             :   {
    2448          14 :     GEN kqoo = v[1]>2*v[2] ? oneminusxd(1):
    2449           0 :                v[1]<2*v[2] ? ZX_sqr(oneminusxd(1))
    2450           7 :                            : oneminusxd(2);
    2451           7 :     kp = gmul(kp, oneminusxd(1));
    2452           7 :     kq = gmul(kq, kqoo);
    2453             :   }
    2454          14 :   tor = RgX_div(ZX_mul(oneminusxd(1),kq), ZX_mul(ki, kp));
    2455          14 :   return ginv( ZX_mul(abe, tor) );
    2456             : }
    2457             : 
    2458             : GEN
    2459          35 : lfungenus2(GEN G)
    2460             : {
    2461          35 :   pari_sp ltop = avma;
    2462             :   GEN Ldata;
    2463          35 :   GEN gr = genus2red(G, NULL);
    2464          35 :   GEN N  = gel(gr, 1), M = gel(gr, 2), PQ = gel(gr, 3), L = gel(gr, 4);
    2465          35 :   GEN e, F = gadd(gsqr(gel(PQ, 2)), gmul2n(gel(PQ, 1), 2));
    2466          35 :   long i, lL = lg(L), ram2;
    2467          35 :   ram2 = absequaliu(gmael(M,1,1),2);
    2468          35 :   if (ram2 && equalis(gmael(M,2,1),-1))
    2469          14 :     pari_warn(warner,"unknown valuation of conductor at 2");
    2470          35 :   e = cgetg(lL+(ram2?0:1), t_VEC);
    2471          56 :   gel(e,1) = mkvec2(gen_2, ram2 ? genus2_eulerfact2(PQ)
    2472          21 :            : ginv( RgX_recip(hyperellcharpoly(gmul(PQ,gmodulss(1,2))))) );
    2473          84 :   for(i = ram2? 2: 1; i < lL; i++)
    2474             :   {
    2475          49 :     GEN Li = gel(L, i);
    2476          49 :     GEN p = gel(Li, 1);
    2477          49 :     gel(e, ram2 ? i: i+1) = mkvec2(p, genus2_eulerfact(F,p));
    2478             :   }
    2479          35 :   Ldata = mkvecn(6, tag(mkvec2(F,e), t_LFUN_GENUS2),
    2480             :       gen_0, mkvec4(gen_0, gen_0, gen_1, gen_1), gen_2, N, gen_0);
    2481          35 :   return gerepilecopy(ltop, Ldata);
    2482             : }
    2483             : 
    2484             : /*************************************************************/
    2485             : /*                        ETA QUOTIENTS                      */
    2486             : /* An eta quotient is a matrix with 2 columns [m, r_m] with  */
    2487             : /* m >= 1 representing f(\tau)=\prod_m\eta(m\tau)^{r_m}.     */
    2488             : /*************************************************************/
    2489             : 
    2490             : /* eta(x^v) + O(x^L) */
    2491             : GEN
    2492        1222 : eta_ZXn(long v, long L)
    2493             : {
    2494        1222 :   long n, k = 0, v2 = 2*v, bn = v, cn = 0;
    2495             :   GEN P;
    2496        1222 :   if (!L) return zeropol(0);
    2497        1222 :   P = cgetg(L+2,t_POL); P[1] = evalsigne(1);
    2498       72543 :   for(n = 0; n < L; n++) gel(P,n+2) = gen_0;
    2499        1222 :   for(n = 0;; n++, bn += v2, cn += v)
    2500        3000 :   { /* k = v * (3*n-1) * n / 2; bn = v * (2*n+1); cn = v * n */
    2501             :     long k2;
    2502        4222 :     gel(P, k+2) = odd(n)? gen_m1: gen_1;
    2503        4222 :     k2 = k+cn; if (k2 >= L) break;
    2504        3770 :     k = k2;
    2505             :     /* k = v * (3*n+1) * n / 2 */;
    2506        3770 :     gel(P, k+2) = odd(n)? gen_m1: gen_1;
    2507        3770 :     k2 = k+bn; if (k2 >= L) break;
    2508        3000 :     k = k2;
    2509             :   }
    2510        1222 :   setlg(P, k+3); return P;
    2511             : }
    2512             : GEN
    2513         322 : eta_product_ZXn(GEN eta, long L)
    2514             : {
    2515         322 :   pari_sp av = avma;
    2516         322 :   GEN P = NULL, D = gel(eta,1), R = gel(eta,2);
    2517         322 :   long i, l = lg(D);
    2518        1148 :   for (i = 1; i < l; ++i)
    2519             :   {
    2520         826 :     GEN Q = eta_ZXn(D[i], L);
    2521         826 :     long r = R[i];
    2522         826 :     if (r < 0) { Q = RgXn_inv_i(Q, L); r = -r; }
    2523         826 :     if (r != 1) Q = RgXn_powu_i(Q, r, L);
    2524         826 :     P = P? ZXn_mul(P, Q, L): Q;
    2525         826 :     if (gc_needed(av,1) && i > 1)
    2526             :     {
    2527           0 :       if (DEBUGMEM>1) pari_warn(warnmem,"eta_product_ZXn");
    2528           0 :       P = gerepilecopy(av, P);
    2529             :     }
    2530             :   }
    2531         322 :   return P;
    2532             : }
    2533             : static GEN
    2534         147 : vecan_eta(GEN an, long L)
    2535             : {
    2536         147 :   long v = itos(gel(an, 3));
    2537             :   GEN t;
    2538         147 :   if (v > L) return zerovec(L);
    2539         140 :   t = eta_product_ZXn(an, L - v);
    2540         140 :   if (v) t = RgX_shift_shallow(t, v);
    2541         140 :   return RgX_to_RgV(t, L);
    2542             : }
    2543             : /* return 1 if cuspidal, 0 if holomorphic, -1 otherwise */
    2544             : static int
    2545         231 : etacuspidal(GEN N, GEN k, GEN B, GEN R, GEN NB)
    2546             : {
    2547         231 :   long i, j, lD, l, cusp = 1;
    2548         231 :   pari_sp av = avma;
    2549             :   GEN D;
    2550         231 :   if (gsigne(k) < 0) return -1;
    2551         224 :   D = divisors(N); lD = lg(D); l = lg(B);
    2552        1505 :   for (i = 1; i < lD; i++)
    2553             :   {
    2554        1281 :     GEN t = gen_0, d = gel(D,i);
    2555             :     long s;
    2556        3997 :     for (j = 1; j < l; j++)
    2557        2716 :       t = addii(t, mulii(gel(NB,j), mulii(gel(R,j), sqri(gcdii(d, gel(B,j))))));
    2558        1281 :     s = signe(t);
    2559        1281 :     if (s < 0) return -1;
    2560        1281 :     if (!s) cusp = 0;
    2561             :   }
    2562         224 :   return gc_bool(av, cusp);
    2563             : }
    2564             : /* u | 24, level N = u*N0, N0 = lcm(B), NB[i] = N0/B[i] */
    2565             : static int
    2566          49 : etaselfdual(GEN B, GEN R, GEN NB, ulong u)
    2567             : {
    2568          49 :   pari_sp av = avma;
    2569          49 :   long i, l = lg(B);
    2570         161 :   for (i = 1; i < l; i++)
    2571             :   {
    2572         112 :     long j = ZV_search(B, muliu(gel(NB,i), u)); /* search for N / B[i] */
    2573         112 :     set_avma(av); if (!j || !equalii(gel(R,i),gel(R,j))) return 0;
    2574             :   }
    2575          49 :   return 1;
    2576             : }
    2577             : /* return Nebentypus of eta quotient, k2 = 2*k integral */
    2578             : static GEN
    2579         203 : etachar(GEN B, GEN R, GEN k2)
    2580             : {
    2581         203 :   long i, l = lg(B);
    2582         203 :   GEN P = gen_1;
    2583         546 :   for (i = 1; i < l; ++i) if (mpodd(gel(R,i))) P = mulii(P, gel(B,i));
    2584         203 :   switch(Mod4(k2))
    2585             :   {
    2586         133 :     case 0: break;
    2587          42 :     case 2:  P = negi(P); break;
    2588          28 :     default: P = shifti(P, 1); break;
    2589             :   }
    2590         203 :   return coredisc(P);
    2591             : }
    2592             : /* Return 0 if not on gamma_0(N). Sets conductor, modular weight, character,
    2593             :  * canonical matrix, v_q(eta), sd = 1 iff self-dual, cusp = 1 iff cuspidal
    2594             :  * [0 if holomorphic at all cusps, else -1] */
    2595             : long
    2596         259 : etaquotype(GEN *peta, GEN *pN, GEN *pk, GEN *CHI, long *pv, long *sd,
    2597             :            long *cusp)
    2598             : {
    2599         259 :   GEN B, R, S, T, N, NB, eta = *peta;
    2600             :   long l, i, u, S24;
    2601             : 
    2602         259 :   if (lg(eta) != 3) pari_err_TYPE("lfunetaquo", eta);
    2603         259 :   switch(typ(eta))
    2604             :   {
    2605          77 :     case t_VEC: eta = mkmat2(mkcol(gel(eta,1)), mkcol(gel(eta,2))); break;
    2606         182 :     case t_MAT: break;
    2607           0 :     default: pari_err_TYPE("lfunetaquo", eta);
    2608             :   }
    2609         259 :   if (!RgV_is_ZVpos(gel(eta,1)) || !RgV_is_ZV(gel(eta,2)))
    2610           0 :     pari_err_TYPE("lfunetaquo", eta);
    2611         259 :   *peta = eta = famat_reduce(eta);
    2612         259 :   B = gel(eta,1); l = lg(B); /* sorted in increasing order */
    2613         259 :   R = gel(eta,2);
    2614         259 :   N = ZV_lcm(B); NB = cgetg(l, t_VEC);
    2615         721 :   for (i = 1; i < l; i++) gel(NB,i) = diviiexact(N, gel(B,i));
    2616         259 :   S = gen_0; T = gen_0; u = 0;
    2617         721 :   for (i = 1; i < l; ++i)
    2618             :   {
    2619         462 :     GEN b = gel(B,i), r = gel(R,i);
    2620         462 :     S = addii(S, mulii(b, r));
    2621         462 :     T = addii(T, r);
    2622         462 :     u += umodiu(r,24) * umodiu(gel(NB,i), 24);
    2623             :   }
    2624         259 :   S = divis_rem(S, 24, &S24);
    2625         259 :   if (S24) return 0; /* nonintegral valuation at oo */
    2626         252 :   u = 24 / ugcd(24, u % 24);
    2627         252 :   *pN = muliu(N, u); /* level */
    2628         252 :   *pk = gmul2n(T,-1); /* weight */
    2629         252 :   *pv = itos(S); /* valuation */
    2630         252 :   if (cusp) *cusp = etacuspidal(*pN, *pk, B, R, NB);
    2631         252 :   if (sd) *sd = etaselfdual(B, R, NB, u);
    2632         252 :   if (CHI) *CHI = etachar(B, R, T);
    2633         252 :   return 1;
    2634             : }
    2635             : 
    2636             : GEN
    2637          49 : lfunetaquo(GEN eta0)
    2638             : {
    2639          49 :   pari_sp ltop = avma;
    2640          49 :   GEN Ldata, N, BR, k, eta = eta0;
    2641             :   long v, sd, cusp;
    2642          49 :   if (!etaquotype(&eta, &N, &k, NULL, &v, &sd, &cusp))
    2643           0 :     pari_err_TYPE("lfunetaquo", eta0);
    2644          49 :   if (!cusp) pari_err_IMPL("noncuspidal eta quotient");
    2645          49 :   if (!sd) pari_err_IMPL("non self-dual eta quotient");
    2646          49 :   if (typ(k) != t_INT) pari_err_TYPE("lfunetaquo [nonintegral weight]", eta0);
    2647          49 :   BR = mkvec3(ZV_to_zv(gel(eta,1)), ZV_to_zv(gel(eta,2)), stoi(v - 1));
    2648          49 :   Ldata = mkvecn(6, tag(BR,t_LFUN_ETA), gen_0, mkvec2(gen_0,gen_1), k,N, gen_1);
    2649          49 :   return gerepilecopy(ltop, Ldata);
    2650             : }
    2651             : 
    2652             : static GEN
    2653         399 : vecan_qf(GEN Q, long L)
    2654             : {
    2655         399 :   GEN v, w = qfrep0(Q, utoi(L), 1);
    2656             :   long i;
    2657         399 :   v = cgetg(L+1, t_VEC);
    2658       26698 :   for (i = 1; i <= L; i++) gel(v,i) = utoi(2 * w[i]);
    2659         399 :   return v;
    2660             : }
    2661             : 
    2662             : long
    2663         336 : qfiseven(GEN M)
    2664             : {
    2665         336 :   long i, l = lg(M);
    2666         784 :   for (i=1; i<l; i++)
    2667         679 :     if (mpodd(gcoeff(M,i,i))) return 0;
    2668         105 :   return 1;
    2669             : }
    2670             : 
    2671             : GEN
    2672          91 : lfunqf(GEN M, long prec)
    2673             : {
    2674          91 :   pari_sp ltop = avma;
    2675             :   long n;
    2676             :   GEN k, D, d, Mi, Ldata, poles, eno, dual;
    2677             : 
    2678          91 :   if (typ(M) != t_MAT) pari_err_TYPE("lfunqf", M);
    2679          91 :   if (!RgM_is_ZM(M))   pari_err_TYPE("lfunqf [not integral]", M);
    2680          91 :   n = lg(M)-1;
    2681          91 :   k = uutoQ(n,2);
    2682          91 :   M = Q_primpart(M);
    2683          91 :   Mi = ZM_inv(M, &d); /* d M^(-1) */
    2684          91 :   if (!qfiseven(M)) { M = gmul2n(M, 1); d = shifti(d,1); }
    2685          91 :   if (!qfiseven(Mi)){ Mi= gmul2n(Mi,1); d = shifti(d,1); }
    2686             :   /* det(Mi) = d^n/det(M), D^2 = det(Mi)/det(M) */
    2687          91 :   D = gdiv(gpow(d,k,prec), ZM_det(M));
    2688          91 :   if (!issquareall(D, &eno)) eno = gsqrt(D, prec);
    2689          91 :   dual = gequal1(D) ? gen_0: tag(Mi, t_LFUN_QF);
    2690          91 :   poles = mkcol2(mkvec2(k, simple_pole(gmul2n(eno,1))),
    2691             :                  mkvec2(gen_0, simple_pole(gen_m2)));
    2692          91 :   Ldata = mkvecn(7, tag(M, t_LFUN_QF), dual,
    2693             :        mkvec2(gen_0, gen_1), k, d, eno, poles);
    2694          91 :   return gerepilecopy(ltop, Ldata);
    2695             : }
    2696             : 
    2697             : /********************************************************************/
    2698             : /**  Artin L function, based on a GP script by Charlotte Euvrard   **/
    2699             : /********************************************************************/
    2700             : 
    2701             : static GEN
    2702         119 : artin_charfromgens(GEN G, GEN M)
    2703             : {
    2704         119 :   GEN R, V, ord = gal_get_orders(G), grp = gal_get_group(G);
    2705         119 :   long i, j, k, n = lg(ord)-1, m = lg(grp)-1;
    2706             : 
    2707         119 :   if (lg(M)-1 != n) pari_err_DIM("lfunartin");
    2708         119 :   R = cgetg(m+1, t_VEC);
    2709         119 :   gel(R, 1) = matid(lg(gel(M, 1))-1);
    2710         357 :   for (i = 1, k = 1; i <= n; ++i)
    2711             :   {
    2712         238 :     long c = k*(ord[i] - 1);
    2713         238 :     gel(R, ++k) = gel(M, i);
    2714        1043 :     for (j = 2; j <= c; ++j) gel(R, ++k) = gmul(gel(R,j), gel(M,i));
    2715             :   }
    2716         119 :   V = cgetg(m+1, t_VEC);
    2717        1281 :   for (i = 1; i <= m; i++) gel(V, gel(grp,i)[1]) = gtrace(gel(R,i));
    2718         119 :   return V;
    2719             : }
    2720             : 
    2721             : /* TODO move somewhere else? */
    2722             : GEN
    2723         280 : galois_get_conj(GEN G)
    2724             : {
    2725         280 :   GEN grp = gal_get_group(G);
    2726         280 :   long i, k, r = lg(grp)-1;
    2727         280 :   GEN b = zero_F2v(r);
    2728         959 :   for (k = 2; k <= r; ++k)
    2729             :   {
    2730         959 :     GEN g = gel(grp,k);
    2731         959 :     if (!F2v_coeff(b,g[1]) && g[g[1]]==1)
    2732             :     {
    2733         392 :       pari_sp av = avma;
    2734         392 :       GEN F = galoisfixedfield(G, g, 1, -1);
    2735         392 :       if (ZX_sturmpart(F, NULL) > 0) { set_avma(av); return g; }
    2736        1456 :       for (i = 1; i<=r; i++)
    2737             :       {
    2738        1344 :         GEN h = gel(grp, i);
    2739        1344 :         long t = h[1];
    2740        5264 :         while (h[t]!=1) t = h[t];
    2741        1344 :         F2v_set(b, h[g[t]]);
    2742             :       }
    2743         112 :       set_avma(av);
    2744             :     }
    2745             :   }
    2746           0 :   pari_err_BUG("galois_get_conj");
    2747             :   return NULL;/*LCOV_EXCL_LINE*/
    2748             : }
    2749             : 
    2750        7700 : static GEN  cyclotoi(GEN v) { return simplify_shallow(lift_shallow(v)); }
    2751        2891 : static long cyclotos(GEN v) { return gtos(cyclotoi(v)); }
    2752        2821 : static long char_dim(GEN ch) { return cyclotos(gel(ch,1)); }
    2753             : 
    2754             : static GEN
    2755        1379 : artin_gamma(GEN N, GEN G, GEN ch)
    2756             : {
    2757        1379 :   long a, t, d = char_dim(ch);
    2758        1379 :   if (nf_get_r2(N) == 0) return vec01(d, 0);
    2759          70 :   a = galois_get_conj(G)[1];
    2760          70 :   t = cyclotos(gel(ch,a));
    2761          70 :   return vec01((d+t) / 2, (d-t) / 2);
    2762             : }
    2763             : 
    2764             : static long
    2765        3213 : artin_dim(GEN ind, GEN ch)
    2766             : {
    2767        3213 :   long n = lg(ch)-1;
    2768        3213 :   GEN elts = group_elts(ind, n);
    2769        3213 :   long i, d = lg(elts)-1;
    2770        3213 :   GEN s = gen_0;
    2771       18123 :   for(i=1; i<=d; i++)
    2772       14910 :     s = gadd(s, gel(ch, gel(elts,i)[1]));
    2773        3213 :   return gtos(gdivgu(cyclotoi(s), d));
    2774             : }
    2775             : 
    2776             : static GEN
    2777         623 : artin_ind(GEN elts, GEN ch, GEN p)
    2778             : {
    2779         623 :   long i, d = lg(elts)-1;
    2780         623 :   GEN s = gen_0;
    2781        2149 :   for(i=1; i<=d; i++)
    2782        1526 :     s = gadd(s, gel(ch, gmul(gel(elts,i),p)[1]));
    2783         623 :   return gdivgu(s, d);
    2784             : }
    2785             : 
    2786             : static GEN
    2787        2282 : artin_ram(GEN nf, GEN gal, GEN aut, GEN pr, GEN ramg, GEN ch, long d)
    2788             : {
    2789        2282 :   pari_sp av = avma;
    2790             :   long i, v, n;
    2791             :   GEN p, q, V, elts;
    2792        2282 :   if (d==0) return pol_1(0);
    2793         616 :   n = degpol(gal_get_pol(gal));
    2794         616 :   q = p = idealramfrobenius_aut(nf, gal, pr, ramg, aut);
    2795         616 :   elts = group_elts(gel(ramg,2), n);
    2796         616 :   v = fetch_var_higher();
    2797         616 :   V = cgetg(d+2, t_POL);
    2798         616 :   V[1] = evalsigne(1)|evalvarn(v);
    2799        1239 :   for(i=1; i<=d; i++)
    2800             :   {
    2801         623 :     gel(V,i+1) = artin_ind(elts, ch, q);
    2802         623 :     q = gmul(q, p);
    2803             :   }
    2804         616 :   delete_var();
    2805         616 :   V = RgXn_expint(RgX_neg(V),d+1);
    2806         616 :   setvarn(V,0); return gerepileupto(av, ginv(V));
    2807             : }
    2808             : 
    2809             : /* N true nf; [Artin conductor, vec of [p, Lp]] */
    2810             : static GEN
    2811        1379 : artin_badprimes(GEN N, GEN G, GEN aut, GEN ch)
    2812             : {
    2813        1379 :   pari_sp av = avma;
    2814        1379 :   long i, d = char_dim(ch);
    2815        1379 :   GEN P = gel(absZ_factor(nf_get_disc(N)), 1);
    2816        1379 :   long lP = lg(P);
    2817        1379 :   GEN B = cgetg(lP, t_VEC), C = cgetg(lP, t_VEC);
    2818             : 
    2819        3661 :   for (i = 1; i < lP; ++i)
    2820             :   {
    2821        2282 :     GEN p = gel(P, i), pr = idealprimedec_galois(N, p);
    2822        2282 :     GEN J = idealramgroups_aut(N, G, pr, aut);
    2823        2282 :     GEN G0 = gel(J,2); /* inertia group */
    2824        2282 :     long lJ = lg(J);
    2825        2282 :     long sdec = artin_dim(G0, ch);
    2826        2282 :     long ndec = group_order(G0);
    2827        2282 :     long j, v = ndec * (d - sdec);
    2828        3213 :     for (j = 3; j < lJ; ++j)
    2829             :     {
    2830         931 :       GEN Jj = gel(J, j);
    2831         931 :       long s = artin_dim(Jj, ch);
    2832         931 :       v += group_order(Jj) * (d - s);
    2833             :     }
    2834        2282 :     gel(C, i) = powiu(p, v/ndec);
    2835        2282 :     gel(B, i) = mkvec2(p, artin_ram(N, G, aut, pr, J, ch, sdec));
    2836             :   }
    2837        1379 :   return gerepilecopy(av, mkvec2(ZV_prod(C), B));
    2838             : }
    2839             : 
    2840             : /* p does not divide nf.index */
    2841             : static GEN
    2842       52402 : idealfrobenius_easy(GEN nf, GEN gal, GEN aut, GEN T, GEN p)
    2843             : {
    2844       52402 :   long i, l = lg(aut), f = degpol(T);
    2845       52402 :   GEN D, Dzk, DzkT, DXp, grp = gal_get_group(gal);
    2846       52402 :   pari_sp av = avma;
    2847       52402 :   if (f==1) return gel(grp,1);
    2848       50596 :   Dzk = nf_get_zkprimpart(nf);
    2849       50595 :   D = modii(nf_get_zkden(nf), p);
    2850       50592 :   DzkT = RgV_to_RgM(FqV_red(Dzk, T, p), f);
    2851       50593 :   DXp = RgX_to_RgC(FpX_Frobenius(T, p), f);
    2852       50587 :   if (!equali1(D)) DXp = FpC_Fp_mul(DXp, D, p);
    2853      332150 :   for(i=1; i < l; i++)
    2854             :   {
    2855      332134 :     GEN g = gel(grp,i);
    2856      332134 :     if (perm_orderu(g) == (ulong)f)
    2857             :     {
    2858      170259 :       GEN A = FpM_FpC_mul(DzkT, gel(aut,g[1]), p);
    2859      170262 :       if (ZV_equal(A, DXp)) {set_avma(av); return g; }
    2860             :     }
    2861             :   }
    2862             :   return NULL; /* LCOV_EXCL_LINE */
    2863             : }
    2864             : /* true nf; p divides nf.index, pr/p unramified */
    2865             : static GEN
    2866        1596 : idealfrobenius_hard(GEN nf, GEN gal, GEN aut, GEN pr)
    2867             : {
    2868        1596 :   long i, l = lg(aut), f = pr_get_f(pr);
    2869        1596 :   GEN modpr, p, T, X, Xp, pi, grp = gal_get_group(gal);
    2870        1596 :   pari_sp av = avma;
    2871        1596 :   if (f==1) return gel(grp,1);
    2872        1344 :   pi = pr_get_gen(pr);
    2873        1344 :   modpr = zkmodprinit(nf, pr);
    2874        1344 :   p = modpr_get_p(modpr);
    2875        1344 :   T = modpr_get_T(modpr);
    2876        1344 :   X = modpr_genFq(modpr);
    2877        1344 :   Xp = FpX_Frobenius(T, p);
    2878        9188 :   for (i = 1; i < l; i++)
    2879             :   {
    2880        9188 :     GEN g = gel(grp,i);
    2881        9188 :     if (perm_orderu(g) == (ulong)f)
    2882             :     {
    2883        4372 :       GEN S = gel(aut,g[1]);
    2884        4372 :       GEN A = nf_to_Fq(nf, zk_galoisapplymod(nf,X,S,p), modpr);
    2885             :       /* sigma(X) = X^p (mod pr) and sigma(pi) in pr */
    2886        5828 :       if (ZX_equal(A, Xp) && (f == nf_get_degree(nf) ||
    2887        2800 :           ZC_prdvd(zk_galoisapplymod(nf,pi,S,p),pr))) { set_avma(av); return g; }
    2888             :     }
    2889             :   }
    2890             :   return NULL; /* LCOV_EXCL_LINE */
    2891             : }
    2892             : 
    2893             : /* true nf */
    2894             : static GEN
    2895       53990 : dirartin(GEN nf, GEN G, GEN V, GEN aut, GEN p, long n)
    2896             : {
    2897       53990 :   pari_sp av = avma;
    2898             :   GEN pr, frob;
    2899             :   /* pick one maximal ideal in the conjugacy class above p */
    2900       53990 :   GEN T = nf_get_pol(nf);
    2901       53991 :   if (!dvdii(nf_get_index(nf), p))
    2902             :   { /* simple case */
    2903       52395 :     GEN F = FpX_factor(T, p), P = gmael(F,1,1);
    2904       52402 :     frob = idealfrobenius_easy(nf, G, aut, P, p);
    2905             :   }
    2906             :   else
    2907             :   {
    2908        1596 :     pr = idealprimedec_galois(nf,p);
    2909        1596 :     frob = idealfrobenius_hard(nf, G, aut, pr);
    2910             :   }
    2911       53997 :   set_avma(av); return n ? RgXn_inv(gel(V, frob[1]), n): gel(V, frob[1]);
    2912             : }
    2913             : 
    2914             : GEN
    2915       15665 : dirartin_worker(GEN P, ulong X, GEN nf, GEN G, GEN V, GEN aut)
    2916             : {
    2917       15665 :   pari_sp av = avma;
    2918       15665 :   long i, l = lg(P);
    2919       15665 :   GEN W = cgetg(l, t_VEC);
    2920       69631 :   for(i = 1; i < l; i++)
    2921             :   {
    2922       53965 :     ulong p = uel(P,i);
    2923       53965 :     long d = ulogint(X, p) + 1; /* minimal d such that p^d > X */
    2924       53963 :     gel(W,i) = dirartin(nf, G, V, aut, utoi(uel(P,i)), d);
    2925             :   }
    2926       15666 :   return gerepilecopy(av, mkvec2(P,W));
    2927             : }
    2928             : 
    2929             : static GEN
    2930        2947 : vecan_artin(GEN an, long L, long prec)
    2931             : {
    2932        2947 :   GEN A, Sbad = gel(an,5);
    2933        2947 :   long n = itos(gel(an,6)), isreal = lg(an)<8 ? 0: !itos(gel(an,7));
    2934        2947 :   GEN worker = snm_closure(is_entry("_dirartin_worker"), vecslice(an,1,4));
    2935        2947 :   A = lift_shallow(pardireuler(worker, gen_2, stoi(L), NULL, Sbad));
    2936        2947 :   A = RgXV_RgV_eval(A, grootsof1(n, prec));
    2937        2947 :   if (isreal) A = real_i(A);
    2938        2947 :   return A;
    2939             : }
    2940             : 
    2941             : static GEN
    2942          28 : eulerf_artin(GEN an, GEN p, long prec)
    2943             : {
    2944          28 :   GEN nf = gel(an,1), G = gel(an,2), V = gel(an,3), aut = gel(an,4);
    2945          28 :   GEN Sbad = gel(an,5);
    2946          28 :   long n = itos(gel(an,6)), isreal = lg(an)<8 ? 0: !itos(gel(an,7));
    2947          28 :   GEN f = eulerf_bad(Sbad, p);
    2948          28 :   if (!f) f = mkrfrac(gen_1,dirartin(nf, G, V, aut, p, 0));
    2949          28 :   f = gsubst(liftpol(f),1, rootsof1u_cx(n, prec));
    2950          28 :   if (isreal) f = real_i(f);
    2951          28 :   return f;
    2952             : }
    2953             : 
    2954             : static GEN
    2955        2856 : char_expand(GEN conj, GEN ch)
    2956             : {
    2957        2856 :   long i, l = lg(conj);
    2958        2856 :   GEN V = cgetg(l, t_COL);
    2959       31409 :   for (i=1; i<l; i++) gel(V,i) = gel(ch, conj[i]);
    2960        2856 :   return V;
    2961             : }
    2962             : 
    2963             : static GEN
    2964        1596 : handle_zeta(long n, GEN ch, long *m)
    2965             : {
    2966             :   GEN c;
    2967        1596 :   long t, i, l = lg(ch);
    2968        1596 :   GEN dim = cyclotoi(vecsum(ch));
    2969        1596 :   if (typ(dim) != t_INT)
    2970           0 :     pari_err_DOMAIN("lfunartin","chi","is not a", strtoGENstr("character"), ch);
    2971        1596 :   t = itos(dim);
    2972        1596 :   if (t < 0 || t % n)
    2973           0 :     pari_err_DOMAIN("lfunartin","chi","is not a", strtoGENstr("character"), ch);
    2974        1596 :   if (t == 0) { *m = 0; return ch; }
    2975         224 :   *m = t / n;
    2976         224 :   c = cgetg(l, t_COL);
    2977        2065 :   for (i=1; i<l; i++)
    2978        1841 :     gel(c,i) = gsubgs(gel(ch,i), *m);
    2979         224 :   return c;
    2980             : }
    2981             : 
    2982             : static int
    2983        6496 : cyclo_is_real(GEN v, GEN ix)
    2984             : {
    2985        6496 :   pari_sp av = avma;
    2986        6496 :   GEN w = poleval(lift_shallow(v), ix);
    2987        6496 :   return gc_bool(av, gequal(w, v));
    2988             : }
    2989             : 
    2990             : static int
    2991        1379 : char_is_real(GEN ch, GEN mod)
    2992             : {
    2993        1379 :   long i, l = lg(ch);
    2994        1379 :   GEN ix = QXQ_inv(pol_x(varn(mod)), mod);
    2995        7014 :   for (i=1; i<l; i++)
    2996        6496 :     if (!cyclo_is_real(gel(ch,i), ix)) return 0;
    2997         518 :   return 1;
    2998             : }
    2999             : 
    3000             : GEN
    3001        1610 : lfunartin(GEN nf, GEN gal, GEN ch, long o, long bitprec)
    3002             : {
    3003        1610 :   pari_sp av = avma;
    3004        1610 :   GEN bc, V, aut, mod, Ldata = NULL, chx, cc, conj, repr;
    3005             :   long tmult, var;
    3006        1610 :   nf = checknf(nf);
    3007        1610 :   checkgal(gal);
    3008        1610 :   var = gvar(ch);
    3009        1610 :   if (var == 0) pari_err_PRIORITY("lfunartin",ch,"=",0);
    3010        1610 :   if (var < 0) var = 1;
    3011        1610 :   if (!is_vec_t(typ(ch))) pari_err_TYPE("lfunartin", ch);
    3012        1610 :   cc = group_to_cc(gal);
    3013        1610 :   conj = gel(cc,2);
    3014        1610 :   repr = gel(cc,3);
    3015        1610 :   mod = mkpolmod(gen_1, polcyclo(o, var));
    3016        1610 :   if (lg(ch)>1 && typ(gel(ch,1))==t_MAT)
    3017         119 :     chx = artin_charfromgens(gal, gmul(ch,mod));
    3018             :   else
    3019             :   {
    3020        1491 :     if (lg(repr) != lg(ch)) pari_err_DIM("lfunartin");
    3021        1477 :     chx = char_expand(conj, gmul(ch,mod));
    3022             :   }
    3023        1596 :   chx = handle_zeta(nf_get_degree(nf), chx, &tmult);
    3024        1596 :   ch = shallowextract(chx, repr);
    3025        1596 :   if (!gequal0(chx))
    3026             :   {
    3027        1379 :     GEN real = char_is_real(chx, gel(mod,1))? gen_0: gen_1;
    3028        1379 :     aut = nfgaloispermtobasis(nf, gal);
    3029        1379 :     V = gmul(char_expand(conj, galoischarpoly(gal, ch, o)), mod);
    3030        1379 :     bc = artin_badprimes(nf, gal, aut, chx);
    3031        2758 :     Ldata = mkvecn(6,
    3032        1379 :       tag(mkcoln(7, nf, gal, V, aut, gel(bc, 2), stoi(o), real), t_LFUN_ARTIN),
    3033        1379 :       real, artin_gamma(nf, gal, chx), gen_1, gel(bc,1), gen_0);
    3034             :   }
    3035        1596 :   if (tmult==0 && Ldata==NULL) pari_err_TYPE("lfunartin",ch);
    3036        1596 :   if (tmult)
    3037             :   {
    3038             :     long i;
    3039         224 :     if (Ldata==NULL) { Ldata = lfunzeta(); tmult--; }
    3040         231 :     for(i=1; i<=tmult; i++)
    3041           7 :       Ldata = lfunmul(Ldata, gen_1, bitprec);
    3042             :   }
    3043        1596 :   return gerepilecopy(av, Ldata);
    3044             : }
    3045             : 
    3046             : /* true nf */
    3047             : static GEN
    3048          21 : lfunzetakinit_artin(GEN nf, GEN gal, GEN dom, long der, long bitprec)
    3049             : {
    3050          21 :   GEN F, E, M, domain, To = galoischartable(gal), T = gel(To, 1);
    3051          21 :   long i, o = itos(gel(To, 2)), l = lg(T);
    3052          21 :   F = cgetg(l, t_VEC);
    3053          21 :   E = cgetg(l, t_VECSMALL);
    3054          84 :   for (i = 1; i < l; ++i)
    3055             :   {
    3056          63 :     GEN L = lfunartin(nf, gal, gel(T,i), o, bitprec);
    3057          63 :     gel(F, i) = lfuninit(L, dom, der, bitprec);
    3058          63 :     E[i] = char_dim(gel(T,i));
    3059             :   }
    3060          21 :   domain = mkvec2(dom, mkvecsmall2(der, bitprec));
    3061          21 :   M = mkvec3(F, E, zero_zv(l-1));
    3062          21 :   return lfuninit_make(t_LDESC_PRODUCT, lfunzetak_i(nf), M, domain);
    3063             : }
    3064             : 
    3065             : /********************************************************************/
    3066             : /**                    High-level Constructors                     **/
    3067             : /********************************************************************/
    3068             : enum { t_LFUNMISC_POL, t_LFUNMISC_CHIQUAD, t_LFUNMISC_CHICONREY,
    3069             :        t_LFUNMISC_CHIGEN, t_LFUNMISC_ELLINIT, t_LFUNMISC_ETAQUO,
    3070             :        t_LFUNMISC_GCHAR, t_LFUNMISC_ABELREL };
    3071             : static long
    3072        8873 : lfundatatype(GEN data)
    3073             : {
    3074        8873 :   switch(typ(data))
    3075             :   {
    3076        3812 :     case t_INT: return t_LFUNMISC_CHIQUAD;
    3077         217 :     case t_INTMOD: return t_LFUNMISC_CHICONREY;
    3078         637 :     case t_POL: return t_LFUNMISC_POL;
    3079        4207 :     case t_VEC:
    3080        4207 :       switch(lg(data))
    3081             :       {
    3082        1911 :         case 17: return t_LFUNMISC_ELLINIT;
    3083           0 :         case 10: return t_LFUNMISC_POL;
    3084        2296 :         case 3:
    3085        2296 :           if (typ(gel(data,1)) != t_VEC) break;
    3086        2296 :           return is_gchar_group(gel(data,1))  ? t_LFUNMISC_GCHAR
    3087        2296 :                     : typ(gel(data,2))==t_MAT ? t_LFUNMISC_ABELREL
    3088             :                                               : t_LFUNMISC_CHIGEN;
    3089             :       }
    3090           0 :       break;
    3091             :   }
    3092           0 :   return -1;
    3093             : }
    3094             : static GEN
    3095       90912 : lfunmisc_to_ldata_i(GEN ldata, long shallow)
    3096             : {
    3097             :   GEN x;
    3098       90912 :   if (is_linit(ldata)) ldata = linit_get_ldata(ldata);
    3099       90912 :   if (is_ldata(ldata) && is_tagged(ldata))
    3100             :   {
    3101       81871 :     if (!shallow) ldata = gcopy(ldata);
    3102       81871 :     checkldata(ldata); return ldata;
    3103             :   }
    3104        9041 :   x = checknf_i(ldata); if (x) return lfunzetak(x);
    3105        8873 :   switch (lfundatatype(ldata))
    3106             :   {
    3107         637 :     case t_LFUNMISC_POL: return lfunzetak(ldata);
    3108        3812 :     case t_LFUNMISC_CHIQUAD: return lfunchiquad(ldata);
    3109         217 :     case t_LFUNMISC_CHICONREY:
    3110             :     {
    3111         217 :       GEN G = znstar0(gel(ldata,1), 1);
    3112         217 :       return lfunchiZ(G, gel(ldata,2));
    3113             :     }
    3114        1883 :     case t_LFUNMISC_CHIGEN:
    3115             :     {
    3116        1883 :       GEN G = gel(ldata,1), chi = gel(ldata,2);
    3117        1883 :       switch(nftyp(G))
    3118             :       {
    3119        1624 :         case typ_BIDZ: return lfunchiZ(G, chi);
    3120         252 :         case typ_BNR: return lfunchigen(G, chi);
    3121             :       }
    3122             :     }
    3123           7 :     break;
    3124         392 :     case t_LFUNMISC_GCHAR: return lfungchar(gel(ldata,1), gel(ldata,2));
    3125          21 :     case t_LFUNMISC_ABELREL:
    3126          21 :       return lfunabelrel(gel(ldata,1), gel(ldata,2),
    3127          21 :                          lg(ldata)==3? NULL: gel(ldata,3));
    3128        1911 :     case t_LFUNMISC_ELLINIT: return lfunell(ldata);
    3129             :   }
    3130           7 :   if (shallow != 2) pari_err_TYPE("lfunmisc_to_ldata",ldata);
    3131           0 :   return NULL;
    3132             : }
    3133             : 
    3134             : GEN
    3135        1372 : lfunmisc_to_ldata(GEN ldata)
    3136        1372 : { return lfunmisc_to_ldata_i(ldata, 0); }
    3137             : 
    3138             : GEN
    3139       75369 : lfunmisc_to_ldata_shallow(GEN ldata)
    3140       75369 : { return lfunmisc_to_ldata_i(ldata, 1); }
    3141             : 
    3142             : GEN
    3143       14171 : lfunmisc_to_ldata_shallow_i(GEN ldata)
    3144       14171 : { return lfunmisc_to_ldata_i(ldata, 2); }
    3145             : 
    3146             : /********************************************************************/
    3147             : /**                    High-level an expansion                     **/
    3148             : /********************************************************************/
    3149             : /* van is the output of ldata_get_an: return a_1,...a_L at precision prec */
    3150             : GEN
    3151       20344 : ldata_vecan(GEN van, long L, long prec)
    3152             : {
    3153       20344 :   GEN an = gel(van, 2);
    3154       20344 :   long t = mael(van,1,1);
    3155             :   pari_timer ti;
    3156       20344 :   if (DEBUGLEVEL >= 1)
    3157           0 :     err_printf("Lfun: computing %ld coeffs, prec %ld, type %ld\n", L, prec, t);
    3158       20344 :   if (DEBUGLEVEL >= 2) timer_start(&ti);
    3159       20344 :   if (L < 0) L = 0;
    3160       20344 :   switch (t)
    3161             :   {
    3162             :     long n;
    3163        1925 :     case t_LFUN_GENERIC:
    3164        1925 :       an = vecan_closure(an, L, prec);
    3165        1855 :       n = lg(an)-1;
    3166        1855 :       if (n < L)
    3167             :       {
    3168          14 :         pari_warn(warner, "#an = %ld < %ld, results may be imprecise", n, L);
    3169          14 :         an = shallowconcat(an, zerovec(L-n));
    3170             :       }
    3171        1855 :       break;
    3172           0 :     case t_LFUN_CLOSURE0:
    3173             :       pari_err_BUG("ldata_vecan: please call ldata_newprec");/*LCOV_EXCL_LINE*/
    3174        2658 :     case t_LFUN_ZETA: an = const_vecsmall(L, 1); break;
    3175        2072 :     case t_LFUN_NF:  an = dirzetak(an, stoi(L)); break;
    3176        1974 :     case t_LFUN_ELL:
    3177        1974 :       an = (ell_get_type(an) == t_ELL_Q) ? ellanQ_zv(an, L): ellan(an, L);
    3178        1974 :       break;
    3179        1316 :     case t_LFUN_KRONECKER: an = vecan_Kronecker(an, L); break;
    3180         168 :     case t_LFUN_ABELREL: an = vecan_abelrel(an, L); break;
    3181        1365 :     case t_LFUN_CHIZ: an = vecan_chiZ(an, L, prec); break;
    3182        1299 :     case t_LFUN_CHIGEN: an = vecan_chigen(an, L, prec); break;
    3183         693 :     case t_LFUN_HECKE: an = vecan_gchar(an, L, prec); break;
    3184        2947 :     case t_LFUN_ARTIN: an = vecan_artin(an, L, prec); break;
    3185         147 :     case t_LFUN_ETA: an = vecan_eta(an, L); break;
    3186         399 :     case t_LFUN_QF: an = vecan_qf(an, L); break;
    3187         616 :     case t_LFUN_DIV: an = vecan_div(an, L, prec); break;
    3188         308 :     case t_LFUN_MUL: an = vecan_mul(an, L, prec); break;
    3189         126 :     case t_LFUN_CONJ: an = vecan_conj(an, L, prec); break;
    3190         343 :     case t_LFUN_SYMPOW_ELL: an = vecan_ellsympow(an, L); break;
    3191         196 :     case t_LFUN_GENUS2: an = vecan_genus2(an, L); break;
    3192         168 :     case t_LFUN_HGM:
    3193         168 :       an = hgmcoefs(gel(an,1), gel(an,2), L); break;
    3194         406 :     case t_LFUN_MFCLOS:
    3195             :     {
    3196         406 :       GEN F = gel(an,1), E = gel(an,2), c = gel(an,3);
    3197         406 :       an = mfcoefs(F,L,1) + 1; /* skip a_0 */
    3198         406 :       an[0] = evaltyp(t_VEC)|_evallg(L+1);
    3199         406 :       an = mfvecembed(E, an);
    3200         406 :       if (!isint1(c)) an = RgV_Rg_mul(an,c);
    3201         406 :       break;
    3202             :     }
    3203         581 :     case t_LFUN_TWIST: an = vecan_twist(an, L, prec); break;
    3204         637 :     case t_LFUN_SHIFT: an = vecan_shift(an, L, prec); break;
    3205           0 :     default: pari_err_TYPE("ldata_vecan", van);
    3206             :   }
    3207       20274 :   if (DEBUGLEVEL >= 2) timer_printf(&ti, "ldata_vecan");
    3208       20274 :   return an;
    3209             : }
    3210             : 
    3211             : /* shallow */
    3212             : GEN
    3213       21401 : ldata_newprec(GEN ldata, long prec)
    3214             : {
    3215       21401 :   GEN van = ldata_get_an(ldata), an = gel(van, 2);
    3216       21401 :   long t = mael(van,1,1);
    3217       21401 :   switch (t)
    3218             :   {
    3219         154 :     case t_LFUN_CLOSURE0: return closure2ldata(an, prec);
    3220         994 :     case t_LFUN_HECKE:
    3221             :     {
    3222         994 :       GEN gc = gel(an, 1), chiw = gel(an, 2);
    3223         994 :       gc = gcharnewprec(gc, prec);
    3224         994 :       return gchari_lfun(gc, chiw, gen_0); /* chi in internal format */
    3225             :     }
    3226         329 :     case t_LFUN_QF:
    3227             :     {
    3228         329 :       GEN eno = ldata_get_rootno(ldata);
    3229         329 :       if (typ(eno)==t_REAL && realprec(eno) < prec) return lfunqf(an, prec);
    3230         273 :       break;
    3231             :     }
    3232             :   }
    3233       20197 :   return ldata;
    3234             : }
    3235             : 
    3236             : GEN
    3237         854 : ldata_eulerf(GEN van, GEN p, long prec)
    3238             : {
    3239         854 :   GEN an = gel(van, 2), f = gen_0;
    3240         854 :   long t = mael(van,1,1);
    3241         854 :   switch (t)
    3242             :   {
    3243          70 :     case t_LFUN_GENERIC:
    3244          70 :       f = eulerf_closure(an, p, prec); break;
    3245           0 :     case t_LFUN_CLOSURE0:
    3246             :       pari_err_BUG("ldata_vecan: please call ldata_newprec");/*LCOV_EXCL_LINE*/
    3247          70 :     case t_LFUN_ZETA: f = mkrfrac(gen_1,deg1pol(gen_m1, gen_1,0)); break;
    3248         168 :     case t_LFUN_NF:  f = eulerf_zetak(an, p); break;
    3249          70 :     case t_LFUN_ELL: f = elleulerf(an, p); break;
    3250          70 :     case t_LFUN_KRONECKER:
    3251          70 :       f = mkrfrac(gen_1, deg1pol_shallow(stoi(-kronecker(an, p)), gen_1, 0)); break;
    3252          42 :     case t_LFUN_ABELREL: f = eulerf_abelrel(an, p); break;
    3253          42 :     case t_LFUN_CHIZ: f = eulerf_chiZ(an, p, prec); break;
    3254          28 :     case t_LFUN_CHIGEN: f = eulerf_chigen(an, p, prec); break;
    3255          14 :     case t_LFUN_HECKE: f = eulerf_gchar(an, p, prec); break;
    3256          28 :     case t_LFUN_ARTIN: f = eulerf_artin(an, p, prec); break;
    3257          14 :     case t_LFUN_DIV: f = eulerf_div(an, p, prec); break;
    3258          28 :     case t_LFUN_MUL: f = eulerf_mul(an, p, prec); break;
    3259           0 :     case t_LFUN_CONJ: f = eulerf_conj(an, p, prec); break;
    3260          28 :     case t_LFUN_SYMPOW_ELL: f = eulerf_ellsympow(an, p); break;
    3261           0 :     case t_LFUN_GENUS2: f = eulerf_genus2(an, p); break;
    3262          14 :     case t_LFUN_TWIST: f = eulerf_twist(an, p, prec); break;
    3263          42 :     case t_LFUN_SHIFT: f = eulerf_shift(an, p, prec); break;
    3264          84 :     case t_LFUN_HGM: f = eulerf_hgm(an, p); break;
    3265          42 :     default: f = NULL; break;
    3266             :   }
    3267         854 :   if (!f) pari_err_DOMAIN("lfuneuler", "L", "Euler product", strtoGENstr("unknown"), an);
    3268         742 :   return f;
    3269             : }
    3270             : 
    3271             : GEN
    3272         707 : lfuneuler(GEN ldata, GEN p, long prec)
    3273             : {
    3274         707 :   pari_sp av = avma;
    3275         707 :   if (typ(p)!=t_INT || signe(p)<=0) pari_err_TYPE("lfuneuler", p);
    3276         700 :   ldata = ldata_newprec(lfunmisc_to_ldata_shallow(ldata), prec);
    3277         700 :   return gerepilecopy(av, ldata_eulerf(ldata_get_an(ldata), p, prec));
    3278             : }

Generated by: LCOV version 1.14