Code coverage tests

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

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

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

LCOV - code coverage report
Current view: top level - basemath - FF.c (source / functions) Hit Total Coverage
Test: PARI/GP v2.10.0 lcov report (development 22296-eb24562) Lines: 1068 1128 94.7 %
Date: 2018-04-19 06:16:12 Functions: 129 135 95.6 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* Copyright (C) 2000-2003  The PARI group.
       2             : 
       3             : This file is part of the PARI/GP package.
       4             : 
       5             : PARI/GP is free software; you can redistribute it and/or modify it under the
       6             : terms of the GNU General Public License as published by the Free Software
       7             : Foundation. It is distributed in the hope that it will be useful, but WITHOUT
       8             : ANY WARRANTY WHATSOEVER.
       9             : 
      10             : Check the License for details. You should have received a copy of it, along
      11             : with the package; see the file 'COPYING'. If not, write to the Free Software
      12             : Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
      13             : 
      14             : #include "pari.h"
      15             : #include "paripriv.h"
      16             : 
      17             : /*************************************************************************/
      18             : /**                                                                     **/
      19             : /**                   Routines for handling FFELT                       **/
      20             : /**                                                                     **/
      21             : /*************************************************************************/
      22             : 
      23             : /*************************************************************************/
      24             : /**                                                                     **/
      25             : /**                   Low-level constructors                            **/
      26             : /**                                                                     **/
      27             : /*************************************************************************/
      28             : 
      29             : INLINE void
      30    28205808 : _getFF(GEN x, GEN *T, GEN *p, ulong *pp)
      31             : {
      32    28205808 :   *T=gel(x,3);
      33    28205808 :   *p=gel(x,4);
      34    28205808 :   *pp=(*p)[2];
      35    28205808 : }
      36             : 
      37             : INLINE GEN
      38    26737390 : _initFF(GEN x, GEN *T, GEN *p, ulong *pp)
      39             : {
      40    26737390 :   _getFF(x,T,p,pp);
      41    26737390 :   return cgetg(5,t_FFELT);
      42             : }
      43             : 
      44             : INLINE void
      45    19289812 : _checkFF(GEN x, GEN y, const char *s)
      46    19289812 : { if (!FF_samefield(x,y)) pari_err_OP(s,x,y); }
      47             : 
      48             : INLINE GEN
      49    26520588 : _mkFF(GEN x, GEN z, GEN r)
      50             : {
      51    26520588 :   z[1]=x[1];
      52    26520588 :   gel(z,2)=r;
      53    26520588 :   gel(z,3)=gcopy(gel(x,3));
      54    26520592 :   gel(z,4)=icopy(gel(x,4));
      55    26520592 :   return z;
      56             : }
      57             : 
      58             : INLINE GEN
      59     3031862 : _mkFF_i(GEN x, GEN z, GEN r)
      60             : {
      61     3031862 :   z[1]=x[1];
      62     3031862 :   gel(z,2)=r;
      63     3031862 :   gel(z,3)=gel(x,3);
      64     3031862 :   gel(z,4)=gel(x,4);
      65     3031862 :   return z;
      66             : }
      67             : 
      68             : INLINE GEN
      69     2815051 : mkFF_i(GEN x, GEN r)
      70             : {
      71     2815051 :   GEN z = cgetg(5,t_FFELT);
      72     2815051 :   return _mkFF_i(x,z,r);
      73             : }
      74             : 
      75             : /*************************************************************************/
      76             : /**                                                                     **/
      77             : /**                   medium-level constructors                         **/
      78             : /**                                                                     **/
      79             : /*************************************************************************/
      80             : 
      81             : static GEN
      82      429310 : Z_to_raw(GEN x, GEN ff)
      83             : {
      84             :   ulong pp;
      85             :   GEN T, p;
      86      429310 :   _getFF(ff,&T,&p,&pp);
      87      429310 :   switch(ff[1])
      88             :   {
      89             :   case t_FF_FpXQ:
      90       10241 :     return scalarpol(x, varn(T));
      91             :   case t_FF_F2xq:
      92      201453 :     return Z_to_F2x(x,varn(T));
      93             :   default:
      94      217616 :     return Z_to_Flx(x,pp,T[1]);
      95             :   }
      96             : }
      97             : 
      98             : static GEN
      99     1791026 : Rg_to_raw(GEN x, GEN ff)
     100             : {
     101     1791026 :   long tx = typ(x);
     102     1791026 :   switch(tx)
     103             :   {
     104             :   case t_INT: case t_FRAC: case t_PADIC: case t_INTMOD:
     105      429310 :     return Z_to_raw(Rg_to_Fp(x, FF_p_i(ff)), ff);
     106             :   case t_FFELT:
     107     1361716 :     if (!FF_samefield(x,ff))
     108           0 :       pari_err_MODULUS("Rg_to_raw",x,ff);
     109     1361716 :     return gel(x,2);
     110             :   }
     111           0 :   pari_err_TYPE("Rg_to_raw",x);
     112             :   return NULL; /* LCOV_EXCL_LINE */
     113             : }
     114             : 
     115             : static GEN
     116      315912 : FFX_to_raw(GEN x, GEN ff)
     117             : {
     118             :   long i, lx;
     119      315912 :   GEN y = cgetg_copy(x,&lx);
     120      315912 :   y[1] = x[1];
     121     1842562 :   for(i=2; i<lx; i++)
     122     1526650 :     gel(y, i) = Rg_to_raw(gel(x, i), ff);
     123      315912 :   switch (ff[1])
     124             :   {
     125             :   case t_FF_FpXQ:
     126        4700 :     return FpXX_renormalize(y, lx);
     127             :   case t_FF_F2xq:
     128      136842 :     return F2xX_renormalize(y, lx);
     129             :   default:
     130      174370 :     return FlxX_renormalize(y, lx);
     131             :   }
     132             : }
     133             : 
     134             : static GEN
     135       28308 : FFC_to_raw(GEN x, GEN ff)
     136       28308 : { pari_APPLY_same(Rg_to_raw(gel(x, i), ff)) }
     137             : 
     138             : static GEN
     139        8932 : FFM_to_raw(GEN x, GEN ff)
     140        8932 : { pari_APPLY_same(FFC_to_raw(gel(x, i), ff)) }
     141             : 
     142             : /* in place */
     143             : static GEN
     144      632731 : rawFq_to_FF(GEN x, GEN ff)
     145             : {
     146      632731 :   return mkFF_i(ff, typ(x)==t_INT ? scalarpol(x, varn(gel(ff,3))): x);
     147             : }
     148             : 
     149             : /* in place */
     150             : static GEN
     151      105809 : raw_to_FFX(GEN x, GEN ff)
     152             : {
     153      105809 :   long i, lx = lg(x);
     154      105809 :   for (i=2; i<lx; i++) gel(x,i) = rawFq_to_FF(gel(x,i), ff);
     155      105809 :   return x;
     156             : }
     157             : 
     158             : /* in place */
     159             : static GEN
     160      115794 : raw_to_FFC(GEN x, GEN ff)
     161             : {
     162      115794 :   long i, lx = lg(x);
     163      115794 :   for (i=1; i<lx; i++) gel(x,i) = mkFF_i(ff, gel(x,i));
     164      115794 :   return x;
     165             : }
     166             : 
     167             : /* in place */
     168             : static GEN
     169        4298 : raw_to_FFM(GEN x, GEN ff)
     170             : {
     171        4298 :   long i, lx = lg(x);
     172        4298 :   for (i=1; i<lx; i++) gel(x,i) = raw_to_FFC(gel(x,i), ff);
     173        4298 :   return x;
     174             : }
     175             : 
     176             : GEN
     177      131761 : Fq_to_FF(GEN x, GEN ff)
     178             : {
     179             :   ulong pp;
     180      131761 :   GEN r, T, p, z=_initFF(ff,&T,&p,&pp);
     181      131761 :   int is_int = typ(x)==t_INT;
     182      131761 :   switch(ff[1])
     183             :   {
     184             :   case t_FF_FpXQ:
     185        6944 :     r= is_int ? scalarpol(x, varn(T)): x;
     186        6944 :     break;
     187             :   case t_FF_F2xq:
     188       45150 :     r= is_int ? Z_to_F2x(x,T[1]): ZX_to_F2x(x);
     189       45150 :     break;
     190             :   default:
     191       79667 :     r= is_int ? Z_to_Flx(x,pp,T[1]): ZX_to_Flx(x,pp);
     192             :   }
     193      131761 :   setvarn(r, varn(T)); /* paranoia */
     194      131761 :   return _mkFF_i(ff,z,r);
     195             : }
     196             : 
     197             : /*************************************************************************/
     198             : /**                                                                     **/
     199             : /**                   Public functions                                  **/
     200             : /**                                                                     **/
     201             : /*************************************************************************/
     202             : 
     203             : /* Return true if x and y are defined in the same field */
     204             : 
     205             : static int
     206    22038996 : FF_samechar(GEN x, GEN y)
     207             : {
     208    22038996 :   return x[1] == y[1] && equalii(gel(x,4),gel(y,4));
     209             : }
     210             : 
     211             : int
     212    22038996 : FF_samefield(GEN x, GEN y)
     213             : {
     214    22038996 :   return FF_samechar(x, y) && gidentical(gel(x,3),gel(y,3));
     215             : }
     216             : 
     217             : int
     218       53991 : FF_equal(GEN x, GEN y)
     219       53991 : { return FF_samefield(x,y) && gidentical(gel(x,2),gel(y,2)); }
     220             : 
     221             : int
     222     8929335 : FF_equal0(GEN x)
     223             : {
     224     8929335 :   return lgpol(gel(x,2))==0;
     225             : }
     226             : 
     227             : int
     228       15680 : FF_equal1(GEN x)
     229             : {
     230       15680 :   GEN A = gel(x,2);
     231       15680 :   switch(x[1])
     232             :   {
     233             :   case t_FF_FpXQ:
     234        2003 :     return degpol(A)==0 && gequal1(gel(A,2));
     235             :   default:
     236       13677 :     return degpol(A)==0 && A[2]==1;
     237             :   }
     238             : }
     239             : 
     240             : static int
     241           0 : Fp_cmp_1(GEN x, GEN p)
     242             : {
     243           0 :   pari_sp av = avma;
     244           0 :   int b = equalii(x, addis(p,-1));
     245           0 :   avma = av; return b;
     246             : }
     247             : 
     248             : int
     249          42 : FF_equalm1(GEN x)
     250             : {
     251             :   ulong pp;
     252          42 :   GEN T, p, y = gel(x,2);
     253          42 :   _getFF(x,&T,&p,&pp);
     254          42 :   switch(x[1])
     255             :   {
     256             :   case t_FF_FpXQ:
     257           0 :     return (degpol(y) == 0 && Fp_cmp_1(gel(y,2), p));
     258             :   default:
     259          42 :     return (degpol(y) == 0 && uel(y,2) == pp-1);
     260             :   }
     261             : }
     262             : 
     263             : GEN
     264        5898 : FF_zero(GEN x)
     265             : {
     266             :   ulong pp;
     267        5898 :   GEN r, T, p, z=_initFF(x,&T,&p,&pp);
     268        5898 :   switch(x[1])
     269             :   {
     270             :   case t_FF_FpXQ:
     271         308 :     r=zeropol(varn(T));
     272         308 :     break;
     273             :   case t_FF_F2xq:
     274        1474 :     r=zero_F2x(T[1]);
     275        1474 :     break;
     276             :   default:
     277        4116 :     r=zero_Flx(T[1]);
     278             :   }
     279        5898 :   return _mkFF(x,z,r);
     280             : }
     281             : 
     282             : GEN
     283       16443 : FF_1(GEN x)
     284             : {
     285             :   ulong pp;
     286       16443 :   GEN r, T, p, z=_initFF(x,&T,&p,&pp);
     287       16443 :   switch(x[1])
     288             :   {
     289             :   case t_FF_FpXQ:
     290         104 :     r=pol_1(varn(T));
     291         104 :     break;
     292             :   case t_FF_F2xq:
     293        9282 :     r=pol1_F2x(T[1]);
     294        9282 :     break;
     295             :   default:
     296        7057 :     r=pol1_Flx(T[1]);
     297             :   }
     298       16443 :   return _mkFF(x,z,r);
     299             : }
     300             : 
     301             : GEN
     302         469 : FF_gen(GEN x)
     303             : {
     304             :   ulong pp;
     305         469 :   GEN r, T, p, z=_initFF(x,&T,&p,&pp);
     306         469 :   switch(x[1])
     307             :   {
     308             :   case t_FF_FpXQ:
     309         154 :     r = pol_x(varn(T));
     310         154 :     if (degpol(T)==1) r = FpX_rem(r, T, p);
     311         154 :     break;
     312             :   case t_FF_F2xq:
     313         154 :     r = polx_F2x(T[1]);
     314         154 :     if (F2x_degree(T)==1) r = F2x_rem(r, T);
     315         154 :     break;
     316             :   default:
     317         161 :     r = polx_Flx(T[1]);
     318         161 :     if (degpol(T)==1) r = Flx_rem(r, T, pp);
     319             :   }
     320         469 :   return _mkFF(x,z,r);
     321             : }
     322             : GEN
     323       54481 : FF_q(GEN x)
     324             : {
     325             :   ulong pp;
     326             :   GEN T, p;
     327       54481 :   _getFF(x,&T,&p,&pp);
     328       54481 :   switch(x[1])
     329             :   {
     330             :   case t_FF_FpXQ:
     331        1681 :     return powiu(p, degpol(T));
     332             :     break;
     333             :   case t_FF_F2xq:
     334        7028 :     return int2n(F2x_degree(T));
     335             :     break;
     336             :   default:
     337       45772 :     return powuu(pp,degpol(T));
     338             :   }
     339             : }
     340             : 
     341             : GEN
     342          56 : FF_p(GEN x)
     343             : {
     344          56 :   return icopy(gel(x,4));
     345             : }
     346             : 
     347             : GEN
     348     2145996 : FF_p_i(GEN x)
     349             : {
     350     2145996 :   return gel(x,4);
     351             : }
     352             : 
     353             : GEN
     354      165543 : FF_mod(GEN x)
     355             : {
     356      165543 :   switch(x[1])
     357             :   {
     358             :   case t_FF_FpXQ:
     359         365 :     return ZX_copy(gel(x,3));
     360             :   case t_FF_F2xq:
     361         371 :     return F2x_to_ZX(gel(x,3));
     362             :   default:
     363      164807 :     return Flx_to_ZX(gel(x,3));
     364             :   }
     365             : }
     366             : 
     367             : long
     368         364 : FF_f(GEN x)
     369             : {
     370         364 :   switch(x[1])
     371             :   {
     372             :   case t_FF_F2xq:
     373         147 :     return F2x_degree(gel(x,3));
     374             :   default:
     375         217 :     return degpol(gel(x,3));
     376             :   }
     377             : }
     378             : 
     379             : GEN
     380      918645 : FF_to_F2xq(GEN x)
     381             : {
     382      918645 :   switch(x[1])
     383             :   {
     384             :   case t_FF_FpXQ:
     385           0 :     return ZX_to_F2x(gel(x,2));
     386             :   case t_FF_F2xq:
     387      918645 :     return zv_copy(gel(x,2));
     388             :   default:
     389           0 :     return Flx_to_F2x(gel(x,2));
     390             :   }
     391             : }
     392             : 
     393             : GEN
     394           0 : FF_to_F2xq_i(GEN x)
     395             : {
     396           0 :   switch(x[1])
     397             :   {
     398             :   case t_FF_FpXQ:
     399           0 :     return ZX_to_F2x(gel(x,2));
     400             :   case t_FF_F2xq:
     401           0 :     return gel(x,2);
     402             :   default:
     403           0 :     return Flx_to_F2x(gel(x,2));
     404             :   }
     405             : }
     406             : 
     407             : GEN
     408      726168 : FF_to_Flxq(GEN x)
     409             : {
     410      726168 :   switch(x[1])
     411             :   {
     412             :   case t_FF_FpXQ:
     413           0 :     return ZX_to_Flx(gel(x,2),itou(gel(x,4)));
     414             :   case t_FF_F2xq:
     415           0 :     return F2x_to_Flx(gel(x,2));
     416             :   default:
     417      726168 :     return zv_copy(gel(x,2));
     418             :   }
     419             : }
     420             : 
     421             : GEN
     422           0 : FF_to_Flxq_i(GEN x)
     423             : {
     424           0 :   switch(x[1])
     425             :   {
     426             :   case t_FF_FpXQ:
     427           0 :     return ZX_to_Flx(gel(x,2),itou(gel(x,4)));
     428             :   case t_FF_F2xq:
     429           0 :     return F2x_to_Flx(gel(x,2));
     430             :   default:
     431           0 :     return gel(x,2);
     432             :   }
     433             : }
     434             : 
     435             : GEN
     436       17946 : FF_to_FpXQ(GEN x)
     437             : {
     438       17946 :   switch(x[1])
     439             :   {
     440             :   case t_FF_FpXQ:
     441       16470 :     return ZX_copy(gel(x,2));
     442             :   case t_FF_F2xq:
     443          63 :     return F2x_to_ZX(gel(x,2));
     444             :   default:
     445        1413 :     return Flx_to_ZX(gel(x,2));
     446             :   }
     447             : }
     448             : 
     449             : GEN
     450      170793 : FF_to_FpXQ_i(GEN x)
     451             : {
     452      170793 :   switch(x[1])
     453             :   {
     454             :   case t_FF_FpXQ:
     455        1214 :     return gel(x,2);
     456             :   case t_FF_F2xq:
     457        1176 :     return F2x_to_ZX(gel(x,2));
     458             :   default:
     459      168403 :     return Flx_to_ZX(gel(x,2));
     460             :   }
     461             : }
     462             : 
     463             : GEN
     464     9194582 : FF_add(GEN x, GEN y)
     465             : {
     466             :   ulong pp;
     467     9194582 :   GEN r, T, p, z=_initFF(x,&T,&p,&pp);
     468     9194582 :   _checkFF(x,y,"+");
     469     9194582 :   switch(x[1])
     470             :   {
     471             :   case t_FF_FpXQ:
     472      308168 :     r=FpX_add(gel(x,2),gel(y,2),p);
     473      308168 :     break;
     474             :   case t_FF_F2xq:
     475     1128460 :     r=F2x_add(gel(x,2),gel(y,2));
     476     1128460 :     break;
     477             :   default:
     478     7757954 :     r=Flx_add(gel(x,2),gel(y,2),pp);
     479             :   }
     480     9194582 :   return _mkFF(x,z,r);
     481             : }
     482             : GEN
     483      282918 : FF_sub(GEN x, GEN y)
     484             : {
     485             :   ulong pp;
     486      282918 :   GEN r, T, p, z=_initFF(x,&T,&p,&pp);
     487      282918 :   _checkFF(x,y,"+");
     488      282918 :   switch(x[1])
     489             :   {
     490             :   case t_FF_FpXQ:
     491        2682 :     r=FpX_sub(gel(x,2),gel(y,2),p);
     492        2682 :     break;
     493             :   case t_FF_F2xq:
     494      155191 :     r=F2x_add(gel(x,2),gel(y,2));
     495      155191 :     break;
     496             :   default:
     497      125045 :     r=Flx_sub(gel(x,2),gel(y,2),pp);
     498             :   }
     499      282918 :   return _mkFF(x,z,r);
     500             : }
     501             : 
     502             : GEN
     503     1658706 : FF_Z_add(GEN x, GEN y)
     504             : {
     505             :   ulong pp;
     506     1658706 :   GEN r, T, p, z=_initFF(x,&T,&p,&pp);
     507     1658706 :   switch(x[1])
     508             :   {
     509             :   case t_FF_FpXQ:
     510             :     {
     511        9213 :       pari_sp av=avma;
     512        9213 :       r=gerepileupto(av,FpX_Fp_add(gel(x,2),modii(y,p),p));
     513        9213 :       break;
     514             :     }
     515             :   case t_FF_F2xq:
     516      792890 :     r=mpodd(y)?F2x_1_add(gel(x,2)):vecsmall_copy(gel(x,2));
     517      792890 :     break;
     518             :   default:
     519      856603 :     r=Flx_Fl_add(gel(x,2),umodiu(y,pp),pp);
     520             :   }
     521     1658706 :   return _mkFF(x,z,r);
     522             : }
     523             : 
     524             : GEN
     525        1344 : FF_Q_add(GEN x, GEN y)
     526             : {
     527             :   ulong pp;
     528        1344 :   GEN r, T, p, z=_initFF(x,&T,&p,&pp);
     529        1344 :   switch(x[1])
     530             :   {
     531             :   case t_FF_FpXQ:
     532             :     {
     533           1 :       pari_sp av=avma;
     534           1 :       r=gerepileupto(av,FpX_Fp_add(gel(x,2),Rg_to_Fp(y,p),p));
     535           1 :       break;
     536             :     }
     537             :   case t_FF_F2xq:
     538           7 :     r=Rg_to_Fl(y,pp)?F2x_1_add(gel(x,2)):vecsmall_copy(gel(x,2));
     539           7 :     break;
     540             :   default:
     541        1336 :     r=Flx_Fl_add(gel(x,2),Rg_to_Fl(y,pp),pp);
     542             :   }
     543        1344 :   return _mkFF(x,z,r);
     544             : }
     545             : 
     546             : GEN
     547       34161 : FF_neg(GEN x)
     548             : {
     549             :   ulong pp;
     550       34161 :   GEN r, T, p, z=_initFF(x,&T,&p,&pp);
     551       34161 :   switch(x[1])
     552             :   {
     553             :   case t_FF_FpXQ:
     554        1270 :     r=FpX_neg(gel(x,2),p);
     555        1270 :     break;
     556             :   case t_FF_F2xq:
     557       12804 :     r=vecsmall_copy(gel(x,2));
     558       12804 :     break;
     559             :   default:
     560       20087 :     r=Flx_neg(gel(x,2),pp);
     561             :   }
     562       34161 :   return _mkFF(x,z,r);
     563             : }
     564             : 
     565             : GEN
     566       85050 : FF_neg_i(GEN x)
     567             : {
     568             :   ulong pp;
     569       85050 :   GEN r, T, p, z=_initFF(x,&T,&p,&pp);
     570       85050 :   switch(x[1])
     571             :   {
     572             :   case t_FF_FpXQ:
     573        1748 :     r=FpX_neg(gel(x,2),p);
     574        1748 :     break;
     575             :   case t_FF_F2xq:
     576        8477 :     r=gel(x,2);
     577        8477 :     break;
     578             :   default:
     579       74825 :     r=Flx_neg(gel(x,2),pp);
     580             :   }
     581       85050 :   return _mkFF_i(x,z,r);
     582             : }
     583             : 
     584             : GEN
     585        1687 : FF_map(GEN m, GEN x)
     586             : {
     587             :   ulong pp;
     588        1687 :   GEN r, T, p, z=_initFF(m,&T,&p,&pp);
     589        1687 :   switch(m[1])
     590             :   {
     591             :   case t_FF_FpXQ:
     592         560 :     r=FpX_FpXQ_eval(gel(x,2),gel(m,2),T,p);
     593         560 :     break;
     594             :   case t_FF_F2xq:
     595         672 :     r=F2x_F2xq_eval(gel(x,2),gel(m,2),T);
     596         672 :     break;
     597             :   default:
     598         455 :     r=Flx_Flxq_eval(gel(x,2),gel(m,2),T,pp);
     599             :   }
     600        1687 :   return _mkFF(m,z,r);
     601             : }
     602             : 
     603             : GEN
     604          42 : FF_Frobenius(GEN x, long e)
     605             : {
     606             :   ulong pp;
     607          42 :   GEN r, T, p, z=_initFF(x,&T,&p,&pp);
     608          42 :   ulong n = umodsu(e, FF_f(x));
     609          42 :   if (n==0) return gcopy(x);
     610          42 :   switch(x[1])
     611             :   {
     612             :   case t_FF_FpXQ:
     613          14 :     r=FpXQ_pow(gel(x,2),p,T,p);
     614          14 :     if (n>1) r=FpXQ_autpow(r,n,T,p);
     615          14 :     break;
     616             :   case t_FF_F2xq:
     617          14 :     r=F2xq_sqr(gel(x,2),T);
     618          14 :     if (n>1) r=F2xq_autpow(r,n,T);
     619          14 :     break;
     620             :   default:
     621          14 :     r=Flxq_powu(gel(x,2),pp,T,pp);
     622          14 :     if (n>1) r=Flxq_autpow(r,n,T,pp);
     623             :   }
     624          42 :   return _mkFF(x,z,r);
     625             : }
     626             : 
     627             : GEN
     628         966 : FFX_preimage(GEN x, GEN F, GEN y)
     629             : {
     630             :   GEN r, T, p, z;
     631             :   ulong pp;
     632         966 :   if (FF_equal0(x)) return FF_zero(y);
     633         875 :   z=_initFF(y,&T,&p,&pp);
     634         875 :   F = FFX_to_raw(F, y);
     635         875 :   switch(y[1])
     636             :   {
     637             :   case t_FF_FpXQ:
     638         322 :     r = FpXQX_rem(gel(x,2), F, T, p);
     639         322 :     break;
     640             :   case t_FF_F2xq:
     641         322 :     r = F2xqX_rem(F2x_to_F2xX(gel(x,2),T[1]), F, T);
     642         322 :     break;
     643             :   default:
     644         231 :     r = FlxqX_rem(Flx_to_FlxX(gel(x,2),T[1]), F, T, pp);
     645             :   }
     646         875 :   if (degpol(r) > 0) return NULL;
     647         791 :   r = (y[1] == t_FF_FpXQ)? Fq_to_FpXQ(gel(r,2),T, p): gel(r,2);
     648         791 :   return _mkFF(y,z,r);
     649             : }
     650             : 
     651             : GEN
     652     9577588 : FF_mul(GEN x, GEN y)
     653             : {
     654             :   ulong pp;
     655     9577588 :   GEN r, T, p, z=_initFF(x,&T,&p,&pp);
     656     9577588 :   pari_sp av=avma;
     657     9577588 :   _checkFF(x,y,"*");
     658     9577588 :   switch(x[1])
     659             :   {
     660             :   case t_FF_FpXQ:
     661      295929 :     r=FpXQ_mul(gel(x,2),gel(y,2),T,p);
     662      295929 :     break;
     663             :   case t_FF_F2xq:
     664      777260 :     r=F2xq_mul(gel(x,2),gel(y,2),T);
     665      777260 :     break;
     666             :   default:
     667     8504399 :     r=Flxq_mul(gel(x,2),gel(y,2),T,pp);
     668             :   }
     669     9577588 :   return _mkFF(x,z,gerepileupto(av, r));
     670             : }
     671             : 
     672             : GEN
     673     2238075 : FF_Z_mul(GEN x, GEN y)
     674             : {
     675             :   ulong pp;
     676     2238075 :   GEN r, T, p, A = gel(x,2), z=_initFF(x,&T,&p,&pp);
     677     2238075 :   switch(x[1])
     678             :   {
     679             :   case t_FF_FpXQ: /* modii(y,p) left on stack for efficiency */
     680       40690 :     r = FpX_Fp_mul(A, modii(y,p),p);
     681       40690 :     break;
     682             :   case t_FF_F2xq:
     683     1120819 :     r = mpodd(y)? vecsmall_copy(A): zero_Flx(A[1]);
     684     1120819 :     break;
     685             :   default:
     686     1076566 :     r = Flx_Fl_mul(A, umodiu(y,pp), pp);
     687             :   }
     688     2238075 :   return _mkFF(x,z,r);
     689             : }
     690             : 
     691             : GEN
     692        4823 : FF_Z_Z_muldiv(GEN x, GEN a, GEN b)
     693             : {
     694             :   ulong pp;
     695        4823 :   GEN r, T, p, A = gel(x,2), z=_initFF(x,&T,&p,&pp);
     696        4823 :   switch(x[1])
     697             :   {
     698             :   case t_FF_FpXQ: /* Fp_div(a,b,p) left on stack for efficiency */
     699          93 :     r = FpX_Fp_mul(A, Fp_div(a,b,p), p);
     700          93 :     break;
     701             :   case t_FF_F2xq:
     702         763 :     if (!mpodd(b)) pari_err_INV("FF_Z_Z_muldiv", b);
     703         756 :     r = mpodd(a)? vecsmall_copy(A): zero_Flx(A[1]);
     704         756 :     break;
     705             :   default:
     706        3967 :     r = Flx_Fl_mul(A, Fl_div(umodiu(a,pp),umodiu(b,pp),pp),pp);
     707             :   }
     708        4809 :   return _mkFF(x,z,r);
     709             : }
     710             : 
     711             : GEN
     712     2892924 : FF_sqr(GEN x)
     713             : {
     714             :   ulong pp;
     715     2892924 :   GEN r, T, p, z=_initFF(x,&T,&p,&pp);
     716     2892924 :   switch(x[1])
     717             :   {
     718             :   case t_FF_FpXQ:
     719             :     {
     720       15792 :       pari_sp av=avma;
     721       15792 :       r=gerepileupto(av,FpXQ_sqr(gel(x,2),T,p));
     722       15792 :       break;
     723             :     }
     724             :   case t_FF_F2xq:
     725      469154 :     r=F2xq_sqr(gel(x,2),T);
     726      469154 :     break;
     727             :   default:
     728     2407978 :     r=Flxq_sqr(gel(x,2),T,pp);
     729             :   }
     730     2892924 :   return _mkFF(x,z,r);
     731             : }
     732             : 
     733             : GEN
     734      217056 : FF_mul2n(GEN x, long n)
     735             : {
     736             :   ulong pp;
     737      217056 :   GEN r, T, p, A = gel(x,2), z=_initFF(x,&T,&p,&pp);
     738      217056 :   switch(x[1])
     739             :   {
     740             :   case t_FF_FpXQ:
     741             :     {
     742             :       GEN p1; /* left on stack for efficiency */
     743        2944 :       if (n>0) p1=remii(int2n(n),p);
     744          22 :       else p1=Fp_inv(remii(int2n(-n),p),p);
     745        2944 :       r = FpX_Fp_mul(A, p1, p);
     746             :     }
     747        2944 :     break;
     748             :   case t_FF_F2xq:
     749       91252 :     if (n<0) pari_err_INV("FF_mul2n", gen_2);
     750       91252 :     r = n==0? vecsmall_copy(A): zero_Flx(A[1]);
     751       91252 :     break;
     752             :   default:
     753             :     {
     754             :       ulong l1;
     755      122860 :       if (n>0) l1 = umodiu(int2n(n),pp);
     756         384 :       else l1 = Fl_inv(umodiu(int2n(-n),pp),pp);
     757      122860 :       r = Flx_Fl_mul(A,l1,pp);
     758             :     }
     759             :   }
     760      217056 :   return _mkFF(x,z,r);
     761             : }
     762             : 
     763             : GEN
     764        7889 : FF_inv(GEN x)
     765             : {
     766             :   ulong pp;
     767        7889 :   GEN r, T, p, z=_initFF(x,&T,&p,&pp);
     768        7889 :   pari_sp av=avma;
     769        7889 :   switch(x[1])
     770             :   {
     771             :   case t_FF_FpXQ:
     772         344 :     r=gerepileupto(av,FpXQ_inv(gel(x,2),T,p));
     773         344 :     break;
     774             :   case t_FF_F2xq:
     775        7126 :     r=F2xq_inv(gel(x,2),T);
     776        7126 :     break;
     777             :   default:
     778         419 :     r=Flxq_inv(gel(x,2),T,pp);
     779             :   }
     780        7889 :   return _mkFF(x,z,r);
     781             : }
     782             : 
     783             : GEN
     784      234549 : FF_div(GEN x, GEN y)
     785             : {
     786             :   ulong pp;
     787      234549 :   GEN r, T, p, z=_initFF(x,&T,&p,&pp);
     788      234549 :   pari_sp av=avma;
     789      234549 :   _checkFF(x,y,"/");
     790      234549 :   switch(x[1])
     791             :   {
     792             :   case t_FF_FpXQ:
     793        3387 :     r=gerepileupto(av,FpXQ_div(gel(x,2),gel(y,2),T,p));
     794        3387 :     break;
     795             :   case t_FF_F2xq:
     796      101143 :     r=gerepileupto(av,F2xq_div(gel(x,2),gel(y,2),T));
     797      101073 :     break;
     798             :   default:
     799      130019 :     r=gerepileupto(av,Flxq_div(gel(x,2),gel(y,2),T,pp));
     800             :   }
     801      234451 :   return _mkFF(x,z,r);
     802             : }
     803             : 
     804             : GEN
     805         259 : Z_FF_div(GEN n, GEN x)
     806             : {
     807             :   ulong pp;
     808         259 :   GEN r, T, p, A = gel(x,2), z=_initFF(x,&T,&p,&pp);
     809         259 :   pari_sp av=avma;
     810         259 :   switch(x[1])
     811             :   {
     812             :   case t_FF_FpXQ:
     813           8 :     r = gerepileupto(av,FpX_Fp_mul(FpXQ_inv(A,T,p),modii(n,p),p));
     814           8 :     break;
     815             :   case t_FF_F2xq:
     816          56 :     r = F2xq_inv(A,T); /*Check for division by 0*/
     817          56 :     if(!mpodd(n)) { avma = av; r = zero_Flx(A[1]); }
     818          56 :     break;
     819             :   default:
     820         195 :     r = gerepileupto(av, Flx_Fl_mul(Flxq_inv(A,T,pp),umodiu(n,pp),pp));
     821             :   }
     822         259 :   return _mkFF(x,z,r);
     823             : }
     824             : 
     825             : GEN
     826         217 : FF_sqrtn(GEN x, GEN n, GEN *zetan)
     827             : {
     828             :   ulong pp;
     829         217 :   GEN r, T, p, y=_initFF(x,&T,&p,&pp);
     830         217 :   switch (x[1])
     831             :   {
     832             :   case t_FF_FpXQ:
     833          66 :     r=FpXQ_sqrtn(gel(x,2),n,T,p,zetan);
     834          59 :     break;
     835             :   case t_FF_F2xq:
     836          28 :     r=F2xq_sqrtn(gel(x,2),n,T,zetan);
     837          21 :     break;
     838             :   default:
     839         123 :     r=Flxq_sqrtn(gel(x,2),n,T,pp,zetan);
     840             :   }
     841         196 :   if (!r) pari_err_SQRTN("FF_sqrtn",x);
     842         196 :   (void)_mkFF(x, y, r);
     843         196 :   if (zetan)
     844             :   {
     845         140 :     GEN z = cgetg(lg(y),t_FFELT);
     846         140 :     *zetan=_mkFF(x, z, *zetan);
     847             :   }
     848         196 :   return y;
     849             : }
     850             : 
     851             : GEN
     852          70 : FF_sqrt(GEN x)
     853             : {
     854             :   ulong pp;
     855          70 :   GEN r, T, p, y=_initFF(x,&T,&p,&pp);
     856          70 :   switch (x[1])
     857             :   {
     858             :   case t_FF_FpXQ:
     859           1 :     r = FpXQ_sqrt(gel(x,2),T,p);
     860           1 :     break;
     861             :   case t_FF_F2xq:
     862          49 :     r = F2xq_sqrt(gel(x,2),T);
     863          49 :     break;
     864             :   default:
     865          20 :     r = Flxq_sqrt(gel(x,2),T,pp);
     866             :   }
     867          70 :   if (!r) pari_err_SQRTN("FF_sqrt",x);
     868          70 :   return _mkFF(x, y, r);
     869             : }
     870             : 
     871             : long
     872           7 : FF_issquare(GEN x)
     873             : {
     874             :   GEN T, p;
     875             :   ulong pp;
     876           7 :   _getFF(x, &T, &p, &pp);
     877           7 :   switch(x[1])
     878             :   {
     879             :   case t_FF_FpXQ:
     880           0 :     return FpXQ_issquare(gel(x,2), T, p);
     881             :   case t_FF_F2xq:
     882           7 :     return 1;
     883             :   default: /* case t_FF_Flxq: */
     884           0 :     return Flxq_issquare(gel(x,2), T, pp);
     885             :   }
     886             : }
     887             : 
     888             : long
     889         182 : FF_issquareall(GEN x, GEN *pt)
     890             : {
     891         182 :   if (!pt) return FF_issquare(x);
     892         175 :   return FF_ispower(x, gen_2, pt);
     893             : }
     894             : 
     895             : long
     896         203 : FF_ispower(GEN x, GEN K, GEN *pt)
     897             : {
     898             :   ulong pp;
     899             :   GEN r, T, p;
     900         203 :   pari_sp av = avma;
     901             : 
     902         203 :   if (FF_equal0(x)) { if (pt) *pt = gcopy(x); return 1; }
     903         203 :   _getFF(x, &T, &p, &pp);
     904         203 :   if (pt) *pt = cgetg(5,t_FFELT);
     905         203 :   switch(x[1])
     906             :   {
     907             :   case t_FF_FpXQ:
     908          71 :     r = FpXQ_sqrtn(gel(x,2),K,T,p,NULL);
     909          71 :     break;
     910             :   case t_FF_F2xq:
     911          42 :     r = F2xq_sqrtn(gel(x,2),K,T,NULL);
     912          42 :     break;
     913             :   default: /* case t_FF_Flxq: */
     914          90 :     r = Flxq_sqrtn(gel(x,2),K,T,pp,NULL);
     915          90 :     break;
     916             :   }
     917         203 :   if (!r) { avma = av; return 0; }
     918         112 :   if (pt) { (void)_mkFF(x,*pt,r); }
     919         112 :   return 1;
     920             : }
     921             : 
     922             : GEN
     923          79 : FF_pow(GEN x, GEN n)
     924             : {
     925             :   ulong pp;
     926          79 :   GEN r, T, p, z=_initFF(x,&T,&p,&pp);
     927          79 :   switch(x[1])
     928             :    {
     929             :    case t_FF_FpXQ:
     930          17 :      r = FpXQ_pow(gel(x,2), n, T, p);
     931          17 :      break;
     932             :    case t_FF_F2xq:
     933           3 :      r = F2xq_pow(gel(x,2), n, T);
     934           3 :      break;
     935             :    default:
     936          59 :      r = Flxq_pow(gel(x,2), n, T, pp);
     937             :    }
     938          79 :   return _mkFF(x,z,r);
     939             : }
     940             : 
     941             : GEN
     942          28 : FF_norm(GEN x)
     943             : {
     944             :   ulong pp;
     945             :   GEN T,p;
     946          28 :   _getFF(x,&T,&p,&pp);
     947          28 :   switch (x[1])
     948             :   {
     949             :   case t_FF_FpXQ:
     950           1 :     return FpXQ_norm(gel(x,2),T,p);
     951             :   case t_FF_F2xq:
     952           7 :     return lgpol(gel(x,2))?gen_1:gen_0;
     953             :   default:
     954          20 :     return utoi(Flxq_norm(gel(x,2),T,pp));
     955             :   }
     956             : }
     957             : 
     958             : GEN
     959          28 : FF_trace(GEN x)
     960             : {
     961             :   ulong pp;
     962             :   GEN T,p;
     963          28 :   _getFF(x,&T,&p,&pp);
     964          28 :   switch(x[1])
     965             :   {
     966             :   case t_FF_FpXQ:
     967           1 :     return FpXQ_trace(gel(x,2),T,p);
     968             :   case t_FF_F2xq:
     969           7 :     return F2xq_trace(gel(x,2),T)?gen_1:gen_0;
     970             :   default:
     971          20 :     return utoi(Flxq_trace(gel(x,2),T,pp));
     972             :   }
     973             : }
     974             : 
     975             : GEN
     976          28 : FF_conjvec(GEN x)
     977             : {
     978             :   ulong pp;
     979             :   GEN r,T,p,v;
     980             :   long i,l;
     981             :   pari_sp av;
     982          28 :   _getFF(x,&T,&p,&pp);
     983          28 :   av = avma;
     984          28 :   switch(x[1])
     985             :   {
     986             :   case t_FF_FpXQ:
     987           1 :     v = FpXQ_conjvec(gel(x,2), T, p);
     988           1 :     break;
     989             :   case t_FF_F2xq:
     990           7 :     v = F2xq_conjvec(gel(x,2), T);
     991           7 :     break;
     992             :   default:
     993          20 :     v = Flxq_conjvec(gel(x,2), T, pp);
     994             :   }
     995          28 :   l = lg(v); r = cgetg(l, t_COL);
     996         252 :   for(i=1; i<l; i++)
     997         224 :     gel(r,i) = mkFF_i(x, gel(v,i));
     998          28 :   return gerepilecopy(av, r);
     999             : }
    1000             : 
    1001             : GEN
    1002          28 : FF_charpoly(GEN x)
    1003             : {
    1004             :   ulong pp;
    1005             :   GEN T,p;
    1006          28 :   pari_sp av=avma;
    1007          28 :   _getFF(x,&T,&p,&pp);
    1008          28 :   switch(x[1])
    1009             :   {
    1010             :   case t_FF_FpXQ:
    1011           1 :     return gerepileupto(av,FpXQ_charpoly(gel(x,2), T, p));
    1012             :   case t_FF_F2xq:
    1013           7 :     return gerepileupto(av,Flx_to_ZX(Flxq_charpoly(F2x_to_Flx(gel(x,2)),
    1014             :                                                    F2x_to_Flx(T), 2UL)));
    1015             :   default:
    1016          20 :     return gerepileupto(av,Flx_to_ZX(Flxq_charpoly(gel(x,2), T, pp)));
    1017             :   }
    1018             : }
    1019             : 
    1020             : GEN
    1021         154 : FF_minpoly(GEN x)
    1022             : {
    1023             :   ulong pp;
    1024             :   GEN T,p;
    1025         154 :   pari_sp av=avma;
    1026         154 :   _getFF(x,&T,&p,&pp);
    1027         154 :   switch(x[1])
    1028             :   {
    1029             :   case t_FF_FpXQ:
    1030          43 :     return gerepileupto(av,FpXQ_minpoly(gel(x,2), T, p));
    1031             :   case t_FF_F2xq:
    1032          49 :     return gerepileupto(av,Flx_to_ZX(Flxq_minpoly(F2x_to_Flx(gel(x,2)),
    1033             :                                                   F2x_to_Flx(T), 2UL)));
    1034             :   default:
    1035          62 :     return gerepileupto(av,Flx_to_ZX(Flxq_minpoly(gel(x,2), T, pp)));
    1036             :   }
    1037             : }
    1038             : 
    1039             : GEN
    1040         175 : FF_log(GEN x, GEN g, GEN ord)
    1041             : {
    1042         175 :   pari_sp av=avma;
    1043             :   ulong pp;
    1044             :   GEN r, T, p;
    1045         175 :   _getFF(x,&T,&p,&pp);
    1046         175 :   _checkFF(x,g,"log");
    1047         175 :   switch(x[1])
    1048             :   {
    1049             :   case t_FF_FpXQ:
    1050          44 :     if (!ord) ord = factor_pn_1(p,degpol(T));
    1051          44 :     r = FpXQ_log(gel(x,2), gel(g,2), ord, T, p);
    1052          16 :     break;
    1053             :   case t_FF_F2xq:
    1054          28 :     if (!ord) ord = factor_pn_1(gen_2,F2x_degree(T));
    1055          28 :     r = F2xq_log(gel(x,2), gel(g,2), ord, T);
    1056          28 :     break;
    1057             :   default:
    1058         103 :     if (!ord) ord = factor_pn_1(p,degpol(T));
    1059         103 :     r = Flxq_log(gel(x,2), gel(g,2), ord, T, pp);
    1060             :   }
    1061         147 :   return gerepileupto(av, r);
    1062             : }
    1063             : 
    1064             : GEN
    1065          28 : FF_order(GEN x, GEN o)
    1066             : {
    1067          28 :   pari_sp av=avma;
    1068             :   ulong pp;
    1069             :   GEN r, T,p;
    1070          28 :   _getFF(x,&T,&p,&pp);
    1071          28 :   switch(x[1])
    1072             :   {
    1073             :   case t_FF_FpXQ:
    1074           1 :     if (!o) o = factor_pn_1(p,degpol(T));
    1075           1 :     r = FpXQ_order(gel(x,2), o, T, p);
    1076           1 :     break;
    1077             :   case t_FF_F2xq:
    1078           7 :     if (!o) o = factor_pn_1(gen_2,F2x_degree(T));
    1079           7 :     r = F2xq_order(gel(x,2), o, T);
    1080           7 :     break;
    1081             :   default:
    1082          20 :     if (!o) o = factor_pn_1(p,degpol(T));
    1083          20 :     r = Flxq_order(gel(x,2), o, T, pp);
    1084             :   }
    1085          28 :   if (!o) r = gerepileuptoint(av,r);
    1086          28 :   return r;
    1087             : }
    1088             : 
    1089             : GEN
    1090         385 : FF_primroot(GEN x, GEN *o)
    1091             : {
    1092             :   ulong pp;
    1093         385 :   GEN r,T,p,z=_initFF(x,&T,&p,&pp);
    1094         385 :   switch(x[1])
    1095             :   {
    1096             :   case t_FF_FpXQ:
    1097          30 :     r = gener_FpXQ(T, p, o);
    1098          30 :     break;
    1099             :   case t_FF_F2xq:
    1100         154 :     r = gener_F2xq(T, o);
    1101         154 :     break;
    1102             :   default:
    1103         201 :     r = gener_Flxq(T, pp, o);
    1104             :   }
    1105         385 :   return _mkFF(x,z,r);
    1106             : }
    1107             : 
    1108             : static GEN
    1109      512071 : to_FFE(GEN P, GEN fg)
    1110             : {
    1111      512071 :   if(ell_is_inf(P))
    1112      231833 :     return ellinf();
    1113             :   else
    1114      280238 :     retmkvec2(mkFF_i(fg,gel(P,1)), mkFF_i(fg,gel(P,2)));
    1115             : }
    1116             : 
    1117             : static GEN
    1118       18109 : to_FFE_vec(GEN x, GEN ff)
    1119             : {
    1120       18109 :   long i, lx = lg(x);
    1121       18109 :   for (i=1; i<lx; i++) gel(x,i) = to_FFE(gel(x,i), ff);
    1122       18109 :   return x;
    1123             : }
    1124             : 
    1125             : static GEN
    1126        1711 : FpXQ_ell_to_a4a6(GEN E, GEN T, GEN p)
    1127             : {
    1128             :   GEN a1, a3, b2, c4, c6;
    1129        1711 :   a1 = Rg_to_FpXQ(ell_get_a1(E),T,p);
    1130        1711 :   a3 = Rg_to_FpXQ(ell_get_a3(E),T,p);
    1131        1711 :   b2 = Rg_to_FpXQ(ell_get_b2(E),T,p);
    1132        1711 :   c4 = Rg_to_FpXQ(ell_get_c4(E),T,p);
    1133        1711 :   c6 = Rg_to_FpXQ(ell_get_c6(E),T,p);
    1134        1711 :   retmkvec3(FpX_neg(FpX_mulu(c4, 27, p), p), FpX_neg(FpX_mulu(c6, 54, p), p),
    1135             :             mkvec4(Z_to_FpX(utoi(6),p,varn(T)),FpX_mulu(b2,3,p),
    1136             :                    FpX_mulu(a1,3,p),FpX_mulu(a3,108,p)));
    1137             : }
    1138             : 
    1139             : static GEN
    1140       24710 : F3xq_ell_to_a4a6(GEN E, GEN T)
    1141             : {
    1142             :   GEN a1, a3, b2, b4, b6;
    1143       24710 :   a1 = Rg_to_Flxq(ell_get_a1(E),T,3);
    1144       24710 :   a3 = Rg_to_Flxq(ell_get_a3(E),T,3);
    1145       24710 :   b2 = Rg_to_Flxq(ell_get_b2(E),T,3);
    1146       24710 :   b4 = Rg_to_Flxq(ell_get_b4(E),T,3);
    1147       24710 :   b6 = Rg_to_Flxq(ell_get_b6(E),T,3);
    1148       24710 :   if(lgpol(b2)) /* ordinary case */
    1149             :   {
    1150       17885 :     GEN b4b2 = Flxq_div(b4,b2,T,3);
    1151       17885 :     GEN a6 = Flx_sub(b6,Flxq_mul(b4b2,Flx_add(b4,Flxq_sqr(b4b2,T,3),3),T,3),3);
    1152       17885 :     retmkvec3(mkvec(b2), a6,
    1153             :        mkvec4(Fl_to_Flx(1,T[1]),b4b2,Flx_neg(a1,3),Flx_neg(a3,3)));
    1154             :   }
    1155             :   else /* super-singular case */
    1156        6825 :     retmkvec3(Flx_neg(b4, 3), b6,
    1157             :        mkvec4(Fl_to_Flx(1,T[1]),zero_Flx(T[1]), Flx_neg(a1,3), Flx_neg(a3,3)));
    1158             : }
    1159             : 
    1160             : static GEN
    1161       66812 : Flxq_ell_to_a4a6(GEN E, GEN T, ulong p)
    1162             : {
    1163             :   GEN a1, a3, b2, c4, c6;
    1164       66812 :   if(p==3) return F3xq_ell_to_a4a6(E, T);
    1165       42102 :   a1 = Rg_to_Flxq(ell_get_a1(E),T,p);
    1166       42102 :   a3 = Rg_to_Flxq(ell_get_a3(E),T,p);
    1167       42102 :   b2 = Rg_to_Flxq(ell_get_b2(E),T,p);
    1168       42102 :   c4 = Rg_to_Flxq(ell_get_c4(E),T,p);
    1169       42102 :   c6 = Rg_to_Flxq(ell_get_c6(E),T,p);
    1170       42102 :   retmkvec3(Flx_neg(Flx_mulu(c4, 27, p), p), Flx_neg(Flx_mulu(c6, 54, p), p),
    1171             :             mkvec4(Fl_to_Flx(6%p,T[1]),Flx_mulu(b2,3,p),
    1172             :                    Flx_mulu(a1,3,p),Flx_mulu(a3,108,p)));
    1173             : }
    1174             : 
    1175             : static GEN
    1176       45808 : F2xq_ell_to_a4a6(GEN E, GEN T)
    1177             : {
    1178       45808 :   long v = T[1];
    1179       45808 :   GEN a1 = Rg_to_F2xq(ell_get_a1(E),T);
    1180       45807 :   GEN a2 = Rg_to_F2xq(ell_get_a2(E),T);
    1181       45807 :   GEN a3 = Rg_to_F2xq(ell_get_a3(E),T);
    1182       45808 :   GEN a4 = Rg_to_F2xq(ell_get_a4(E),T);
    1183       45808 :   GEN a6 = Rg_to_F2xq(ell_get_a6(E),T);
    1184       45808 :   if (lgpol(a1))
    1185             :   {
    1186        7861 :     GEN a1i = F2xq_inv(a1,T);
    1187        7861 :     GEN a1i2 = F2xq_sqr(a1i,T);
    1188        7861 :     GEN a1i3 = F2xq_mul(a1i,a1i2,T);
    1189        7861 :     GEN a1i6 = F2xq_sqr(a1i3,T);
    1190        7861 :     GEN d  = F2xq_mul(a3,a1i,T);
    1191        7861 :     GEN dd = F2xq_mul(d,a1i2,T);
    1192        7861 :     GEN e  = F2xq_mul(F2x_add(a4,F2xq_sqr(d,T)),a1i,T);
    1193        7861 :     GEN ee = F2xq_mul(e,a1i3,T);
    1194        7861 :     GEN da2 = F2x_add(a2,d);
    1195        7861 :     GEN d2 = F2xq_mul(da2,a1i2,T);
    1196        7861 :     GEN d6 = F2xq_mul(F2x_add(F2x_add(F2xq_mul(F2x_add(F2xq_mul(da2,d,T),a4),d,T),a6),F2xq_sqr(e,T)),a1i6,T);
    1197        7861 :     retmkvec3(d2, d6, mkvec4(a1i,dd,pol0_F2x(v),ee));
    1198             :   }
    1199             :   else
    1200             :   { /* allow a1 = a3 = 0: singular curve */
    1201       37947 :     GEN d4 = F2x_add(F2xq_sqr(a2,T),a4);
    1202       37947 :     GEN d6 = F2x_add(F2xq_mul(a2,a4,T),a6);
    1203       37947 :     GEN a3i = lgpol(a3)? F2xq_inv(a3,T): a3;
    1204       37947 :     retmkvec3(mkvec3(a3,d4,a3i), d6, mkvec4(pol1_F2x(v),a2,pol0_F2x(T[1]),pol0_F2x(T[1])));
    1205             :   }
    1206             : }
    1207             : 
    1208             : static GEN
    1209        1744 : FqV_to_FpXQV(GEN x, GEN T)
    1210             : {
    1211        1744 :   pari_sp av = avma;
    1212        1744 :   long v = varn(T), i, s=0, l = lg(x);
    1213        1744 :   GEN y = shallowcopy(x);
    1214        8720 :   for(i=1; i<l; i++)
    1215        6976 :     if (typ(gel(x,i))==t_INT)
    1216             :     {
    1217           0 :       gel(y,i) = scalarpol(gel(x,i), v);
    1218           0 :       s = 1;
    1219             :     }
    1220        1744 :   if (!s) { avma = av; return x; }
    1221           0 :   return y;
    1222             : }
    1223             : 
    1224             : GEN
    1225       95816 : FF_ellcard(GEN E)
    1226             : {
    1227             :   GEN T,p;
    1228             :   ulong pp;
    1229       95816 :   GEN e = ellff_get_a4a6(E);
    1230       95816 :   GEN fg = ellff_get_field(E);
    1231       95816 :   _getFF(fg,&T,&p,&pp);
    1232       95816 :   switch(fg[1])
    1233             :   {
    1234             :   case t_FF_FpXQ:
    1235        1695 :     return FpXQ_ellcard(Fq_to_FpXQ(gel(e,1),T,p), Fq_to_FpXQ(gel(e,2),T,p),T,p);
    1236             :   case t_FF_F2xq:
    1237       45556 :     return F2xq_ellcard(gel(e,1),gel(e,2),T);
    1238             :   default:
    1239       48565 :     return Flxq_ellcard(gel(e,1),gel(e,2),T,pp);
    1240             :   }
    1241             : }
    1242             : 
    1243             : GEN
    1244          14 : FF_ellcard_SEA(GEN E, long smallfact)
    1245             : {
    1246          14 :   pari_sp av = avma;
    1247             :   GEN T,p;
    1248             :   ulong pp;
    1249          14 :   GEN e = ellff_get_a4a6(E), a4, a6, card;
    1250          14 :   GEN fg = ellff_get_field(E);
    1251          14 :   _getFF(fg,&T,&p,&pp);
    1252          14 :   switch(fg[1])
    1253             :   {
    1254             :   case t_FF_FpXQ:
    1255           0 :     a4 = Fq_to_FpXQ(gel(e,1), T, p);
    1256           0 :     a6 = Fq_to_FpXQ(gel(e,2), T, p);
    1257           0 :     card = Fq_ellcard_SEA(a4, a6, powiu(p,degpol(T)), T,p, smallfact);
    1258           0 :     break;
    1259             :   case t_FF_F2xq:
    1260           0 :     pari_err_IMPL("SEA for char 2");
    1261             :   default:
    1262          14 :     a4 = Flx_to_ZX(gel(e,1));
    1263          14 :     a6 = Flx_to_ZX(gel(e,2));
    1264          14 :     card = Fq_ellcard_SEA(a4, a6, powuu(pp,degpol(T)), Flx_to_ZX(T), p, smallfact);
    1265             :   }
    1266          14 :   return gerepileuptoint(av, card);
    1267             : }
    1268             : 
    1269             : /* return G, set m */
    1270             : GEN
    1271       19432 : FF_ellgroup(GEN E, GEN *pm)
    1272             : {
    1273             :   GEN T, p, e, fg, N;
    1274             :   ulong pp;
    1275             : 
    1276       19432 :   N = ellff_get_card(E);
    1277       19432 :   e = ellff_get_a4a6(E);
    1278       19432 :   fg = ellff_get_field(E);
    1279       19432 :   _getFF(fg,&T,&p,&pp);
    1280       19432 :   switch(fg[1])
    1281             :   {
    1282             :   case t_FF_FpXQ:
    1283          30 :     return FpXQ_ellgroup(Fq_to_FpXQ(gel(e,1),T,p),
    1284          15 :                          Fq_to_FpXQ(gel(e,2),T,p),N,T,p,pm);
    1285             :   case t_FF_F2xq:
    1286        3808 :     return F2xq_ellgroup(gel(e,1),gel(e,2),N,T,pm);
    1287             :   default:
    1288       15609 :     return Flxq_ellgroup(gel(e,1),gel(e,2),N,T,pp,pm);
    1289             :   }
    1290             : }
    1291             : 
    1292             : GEN
    1293       18109 : FF_ellgens(GEN E)
    1294             : {
    1295             :   GEN D, fg, e, m, T, p, F, e3;
    1296             :   ulong pp;
    1297             : 
    1298       18109 :   fg = ellff_get_field(E);
    1299       18109 :   e = ellff_get_a4a6(E);
    1300       18109 :   m = ellff_get_m(E);
    1301       18109 :   D = ellff_get_D(E);
    1302       18109 :   _getFF(fg,&T,&p,&pp);
    1303       18109 :   switch(fg[1])
    1304             :   {
    1305             :   case t_FF_FpXQ:
    1306           8 :     e3 = FqV_to_FpXQV(gel(e,3),T);
    1307           8 :     F = FpXQ_ellgens(Fq_to_FpXQ(gel(e,1),T,p),Fq_to_FpXQ(gel(e,2),T,p),e3,D,m,T,p);
    1308           8 :     break;
    1309             :   case t_FF_F2xq:
    1310        3738 :     F = F2xq_ellgens(gel(e,1),gel(e,2),gel(e,3),D,m,T);
    1311        3738 :     break;
    1312             :   default:
    1313       14363 :     F = Flxq_ellgens(gel(e,1),gel(e,2),gel(e,3),D,m,T, pp);
    1314       14363 :     break;
    1315             :   }
    1316       18109 :   return to_FFE_vec(F,fg);
    1317             : }
    1318             : 
    1319             : GEN
    1320         119 : FF_elldata(GEN E, GEN fg)
    1321             : {
    1322             :   GEN T,p,e;
    1323             :   ulong pp;
    1324         119 :   _getFF(fg,&T,&p,&pp);
    1325         119 :   switch(fg[1])
    1326             :   {
    1327             :   case t_FF_FpXQ:
    1328           0 :     e = FpXQ_ell_to_a4a6(E,T,p); break;
    1329             :   case t_FF_F2xq:
    1330          56 :     e = F2xq_ell_to_a4a6(E,T); break;
    1331             :   default:
    1332          63 :     e = Flxq_ell_to_a4a6(E,T,pp); break;
    1333             :   }
    1334         119 :   return mkvec2(fg,e);
    1335             : }
    1336             : 
    1337             : /* allow singular E, set E.j = 0 in this case */
    1338             : GEN
    1339      114212 : FF_ellinit(GEN E, GEN fg)
    1340             : {
    1341      114212 :   GEN T,p,e, D, c4, y = E;
    1342             :   ulong pp;
    1343             :   long i;
    1344      114212 :   _getFF(fg,&T,&p,&pp);
    1345      114212 :   switch(fg[1])
    1346             :   {
    1347             :   case t_FF_FpXQ:
    1348        1711 :     e = FpXQ_ell_to_a4a6(E,T,p);
    1349        1711 :     for(i=1;i<=12;i++) gel(y,i) = mkFF_i(fg,Rg_to_FpXQ(gel(E,i),T,p));
    1350        1711 :     break;
    1351             :   case t_FF_F2xq:
    1352       45752 :     e = F2xq_ell_to_a4a6(E,T);
    1353       45752 :     for(i=1;i<=12;i++) gel(y,i) = mkFF_i(fg,Rg_to_F2xq(gel(E,i),T));
    1354       45752 :     break;
    1355             :   default:
    1356       66749 :     e = Flxq_ell_to_a4a6(E,T,pp);
    1357       66749 :     for(i=1;i<=12;i++) gel(y,i) = mkFF_i(fg,Rg_to_Flxq(gel(E,i),T,pp));
    1358       66749 :     break;
    1359             :   }
    1360      114212 :   D = ell_get_disc(y);
    1361      114212 :   c4 = ell_get_c4(y);
    1362      114212 :   gel(y,13) = FF_equal0(D)? D: gdiv(gpowgs(c4,3), D);
    1363      114212 :   gel(y,14) = mkvecsmall(t_ELL_Fq);
    1364      114212 :   gel(y,15) = mkvec2(fg,e);
    1365      114212 :   return y;
    1366             : }
    1367             : 
    1368             : GEN
    1369       27188 : FF_elltwist(GEN E)
    1370             : {
    1371       27188 :   pari_sp av = avma;
    1372       27188 :   GEN fg = ellff_get_field(E), e = ellff_get_a4a6(E);
    1373             :   GEN T, p, a, a6, V;
    1374             :   ulong pp;
    1375       27188 :   _getFF(fg,&T,&p,&pp);
    1376       27188 :   switch (fg[1])
    1377             :   {
    1378             :   case t_FF_FpXQ:
    1379         840 :     FpXQ_elltwist(gel(e,1), gel(e,2), T, p, &a, &a6);
    1380         840 :     V = mkvec5(gen_0, gen_0, gen_0, mkFF_i(fg, a), mkFF_i(fg, a6));
    1381         840 :     break;
    1382             :   case t_FF_F2xq:
    1383        3514 :     F2xq_elltwist(gel(e,1), gel(e,2), T, &a, &a6);
    1384        7028 :     V = typ(a)==t_VECSMALL ?
    1385        3514 :           mkvec5(gen_1, mkFF_i(fg, a), gen_0, gen_0, mkFF_i(fg, a6)):
    1386           0 :           mkvec5(gen_0, gen_0, mkFF_i(fg, gel(a,1)), mkFF_i(fg, gel(a,2)), mkFF_i(fg, a6));
    1387        3514 :     break;
    1388             :   default:
    1389       22834 :     Flxq_elltwist(gel(e,1), gel(e,2), T, pp, &a, &a6);
    1390       45668 :     V = typ(a)==t_VECSMALL ?
    1391       30436 :           mkvec5(gen_0, gen_0, gen_0, mkFF_i(fg, a), mkFF_i(fg, a6)):
    1392        7602 :           mkvec5(gen_0, mkFF_i(fg, gel(a,1)), gen_0, gen_0, mkFF_i(fg, a6));
    1393             :   }
    1394       27188 :   return gerepilecopy(av, V);
    1395             : }
    1396             : 
    1397             : static long
    1398           0 : F3x_equalm1(GEN x)
    1399           0 : { return degpol(x)==0 && x[2] == 2; }
    1400             : 
    1401             : GEN
    1402      244034 : FF_ellrandom(GEN E)
    1403             : {
    1404      244034 :   pari_sp av = avma;
    1405      244034 :   GEN fg = ellff_get_field(E), e = ellff_get_a4a6(E), Q;
    1406             :   GEN T,p;
    1407             :   ulong pp;
    1408      244034 :   _getFF(fg,&T,&p,&pp);
    1409      244034 :   switch (fg[1])
    1410             :   {
    1411             :   case t_FF_FpXQ:
    1412         854 :     Q = random_FpXQE(Fq_to_FpXQ(gel(e,1),T,p), Fq_to_FpXQ(gel(e,2),T,p), T, p);
    1413         854 :     Q = FpXQE_changepoint(Q, FqV_to_FpXQV(gel(e,3), T) , T, p);
    1414         854 :     break;
    1415             :   case t_FF_F2xq:
    1416             :     {
    1417      168056 :       long d = F2x_degree(T);
    1418             :       /* if #E(Fq) = 1 return [0] */
    1419      168056 :       if (d<=2 && typ(gel(e,1)) == t_VEC)
    1420             :       { /* over F2 or F4, supersingular */
    1421        1575 :         GEN v = gel(e,1), A6 = gel(e,2), a3 = gel(v,1), A4 = gel(v,2);
    1422        1575 :         if (F2x_equal1(a3) &&
    1423          84 :              ((d==1 && F2x_equal1(A4) && F2x_equal1(A6))
    1424         483 :            || (d==2 && !lgpol(A4)     && F2x_degree(A6)==1))) return ellinf();
    1425             :       }
    1426      168000 :       Q = random_F2xqE(gel(e,1), gel(e,2), T);
    1427      168000 :       Q = F2xqE_changepoint(Q, gel(e,3), T);
    1428      168000 :       break;
    1429             :     }
    1430             :   default:
    1431             :     /* if #E(Fq) = 1 return [0] */
    1432       75124 :     if (pp==3 && degpol(T)==1 && typ(gel(e,1))==t_VECSMALL)
    1433             :     { /* over F3, supersingular */
    1434           0 :       GEN mb4 = gel(e,1), b6 = gel(e,2);
    1435           0 :       if (F3x_equalm1(mb4) && F3x_equalm1(b6)) return ellinf();
    1436             :     }
    1437       75124 :     Q = random_FlxqE(gel(e,1), gel(e,2), T, pp);
    1438       75124 :     Q = FlxqE_changepoint(Q, gel(e,3), T, pp);
    1439             :   }
    1440      243978 :   return gerepilecopy(av, to_FFE(Q, fg));
    1441             : }
    1442             : 
    1443             : GEN
    1444      247450 : FF_ellmul(GEN E, GEN P, GEN n)
    1445             : {
    1446      247450 :   pari_sp av = avma;
    1447      247450 :   GEN fg = ellff_get_field(E), e = ellff_get_a4a6(E), Q;
    1448             :   GEN T,p, Pp, Qp, e3;
    1449             :   ulong pp;
    1450      247450 :   _getFF(fg,&T,&p,&pp);
    1451      247450 :   switch (fg[1])
    1452             :   {
    1453             :   case t_FF_FpXQ:
    1454         854 :     e3 = FqV_to_FpXQV(gel(e,3),T);
    1455         854 :     Pp = FpXQE_changepointinv(RgE_to_FpXQE(P, T, p), e3, T, p);
    1456         854 :     Qp = FpXQE_mul(Pp, n, gel(e,1), T, p);
    1457         854 :     Q = FpXQE_changepoint(Qp, gel(e,3), T, p);
    1458         854 :     break;
    1459             :   case t_FF_F2xq:
    1460      184352 :     Pp = F2xqE_changepointinv(RgE_to_F2xqE(P, T), gel(e,3), T);
    1461      184352 :     Qp = F2xqE_mul(Pp, n, gel(e,1), T);
    1462      184352 :     Q = F2xqE_changepoint(Qp, gel(e,3), T);
    1463      184352 :     break;
    1464             :   default:
    1465       62244 :     Pp = FlxqE_changepointinv(RgE_to_FlxqE(P, T, pp), gel(e,3), T, pp);
    1466       62244 :     Qp = FlxqE_mul(Pp, n, gel(e,1), T, pp);
    1467       62244 :     Q = FlxqE_changepoint(Qp, gel(e,3), T, pp);
    1468             :   }
    1469      247450 :   return gerepilecopy(av, to_FFE(Q, fg));
    1470             : }
    1471             : 
    1472             : GEN
    1473        1750 : FF_ellorder(GEN E, GEN P, GEN o)
    1474             : {
    1475        1750 :   pari_sp av = avma;
    1476        1750 :   GEN fg = ellff_get_field(E), e = ellff_get_a4a6(E);
    1477             :   GEN r,T,p,Pp,e3;
    1478             :   ulong pp;
    1479        1750 :   _getFF(fg,&T,&p,&pp);
    1480        1750 :   switch (fg[1])
    1481             :   {
    1482             :   case t_FF_FpXQ:
    1483          14 :     e3 = FqV_to_FpXQV(gel(e,3),T);
    1484          14 :     Pp = FpXQE_changepointinv(RgE_to_FpXQE(P,T,p), e3, T, p);
    1485          14 :     r = FpXQE_order(Pp, o, gel(e,1), T, p);
    1486          14 :     break;
    1487             :   case t_FF_F2xq:
    1488         280 :     Pp = F2xqE_changepointinv(RgE_to_F2xqE(P,T), gel(e,3), T);
    1489         280 :     r = F2xqE_order(Pp, o, gel(e,1), T);
    1490         280 :     break;
    1491             :   default:
    1492        1456 :     Pp = FlxqE_changepointinv(RgE_to_FlxqE(P,T,pp), gel(e,3), T, pp);
    1493        1456 :     r = FlxqE_order(Pp, o, gel(e,1), T, pp);
    1494             :   }
    1495        1750 :   return gerepileupto(av, r);
    1496             : }
    1497             : 
    1498             : GEN
    1499          91 : FF_elllog(GEN E, GEN P, GEN Q, GEN o)
    1500             : {
    1501          91 :   pari_sp av = avma;
    1502          91 :   GEN fg = ellff_get_field(E), e = ellff_get_a4a6(E);
    1503             :   GEN r,T,p, Pp,Qp, e3;
    1504             :   ulong pp;
    1505          91 :   _getFF(fg,&T,&p,&pp);
    1506          91 :   switch(fg[1])
    1507             :   {
    1508             :   case t_FF_FpXQ:
    1509           0 :     e3 = FqV_to_FpXQV(gel(e,3),T);
    1510           0 :     Pp = FpXQE_changepointinv(RgE_to_FpXQE(P,T,p), e3, T, p);
    1511           0 :     Qp = FpXQE_changepointinv(RgE_to_FpXQE(Q,T,p), e3, T, p);
    1512           0 :     r = FpXQE_log(Pp, Qp, o, gel(e,1), T, p);
    1513           0 :     break;
    1514             :   case t_FF_F2xq:
    1515          42 :     Pp = F2xqE_changepointinv(RgE_to_F2xqE(P,T), gel(e,3), T);
    1516          42 :     Qp = F2xqE_changepointinv(RgE_to_F2xqE(Q,T), gel(e,3), T);
    1517          42 :     r = F2xqE_log(Pp, Qp, o, gel(e,1), T);
    1518          42 :     break;
    1519             :   default:
    1520          49 :     Pp = FlxqE_changepointinv(RgE_to_FlxqE(P,T,pp), gel(e,3), T, pp);
    1521          49 :     Qp = FlxqE_changepointinv(RgE_to_FlxqE(Q,T,pp), gel(e,3), T, pp);
    1522          49 :     r = FlxqE_log(Pp, Qp, o, gel(e,1), T, pp);
    1523             :   }
    1524          91 :   return gerepileupto(av, r);
    1525             : }
    1526             : 
    1527             : GEN
    1528        4984 : FF_ellweilpairing(GEN E, GEN P, GEN Q, GEN m)
    1529             : {
    1530        4984 :   GEN fg = ellff_get_field(E), e = ellff_get_a4a6(E);
    1531             :   GEN r,T,p, Pp,Qp, e3;
    1532             :   ulong pp;
    1533        4984 :   GEN z=_initFF(fg,&T,&p,&pp);
    1534        4984 :   pari_sp av = avma;
    1535        4984 :   switch(fg[1])
    1536             :   {
    1537             :   case t_FF_FpXQ:
    1538           7 :     e3 = FqV_to_FpXQV(gel(e,3),T);
    1539           7 :     Pp = FpXQE_changepointinv(RgE_to_FpXQE(P,T,p), e3, T, p);
    1540           7 :     Qp = FpXQE_changepointinv(RgE_to_FpXQE(Q,T,p), e3, T, p);
    1541           7 :     r = FpXQE_weilpairing(Pp, Qp, m, gel(e,1), T, p);
    1542           7 :     break;
    1543             :   case t_FF_F2xq:
    1544        4963 :     Pp = F2xqE_changepointinv(RgE_to_F2xqE(P,T), gel(e,3), T);
    1545        4963 :     Qp = F2xqE_changepointinv(RgE_to_F2xqE(Q,T), gel(e,3), T);
    1546        4963 :     r = F2xqE_weilpairing(Pp, Qp, m, gel(e,1), T);
    1547        4963 :     break;
    1548             :   default:
    1549          14 :     Pp = FlxqE_changepointinv(RgE_to_FlxqE(P,T,pp), gel(e,3), T, pp);
    1550          14 :     Qp = FlxqE_changepointinv(RgE_to_FlxqE(Q,T,pp), gel(e,3), T, pp);
    1551          14 :     r = FlxqE_weilpairing(Pp, Qp, m, gel(e,1), T, pp);
    1552             :   }
    1553        4984 :   r = gerepileupto(av, r);
    1554        4984 :   return _mkFF(fg,z,r);
    1555             : }
    1556             : 
    1557             : GEN
    1558          91 : FF_elltatepairing(GEN E, GEN P, GEN Q, GEN m)
    1559             : {
    1560          91 :   GEN fg = ellff_get_field(E), e = ellff_get_a4a6(E);
    1561             :   GEN r,T,p, Pp,Qp, e3;
    1562             :   ulong pp;
    1563          91 :   GEN z=_initFF(fg,&T,&p,&pp);
    1564          91 :   pari_sp av = avma;
    1565          91 :   switch(fg[1])
    1566             :   {
    1567             :   case t_FF_FpXQ:
    1568           7 :     e3 = FqV_to_FpXQV(gel(e,3),T);
    1569           7 :     Pp = FpXQE_changepointinv(RgE_to_FpXQE(P,T,p), e3, T, p);
    1570           7 :     Qp = FpXQE_changepointinv(RgE_to_FpXQE(Q,T,p), e3, T, p);
    1571           7 :     r = FpXQE_tatepairing(Pp, Qp, m, gel(e,1), T, p);
    1572           7 :     break;
    1573             :   case t_FF_F2xq:
    1574          28 :     Pp = F2xqE_changepointinv(RgE_to_F2xqE(P,T), gel(e,3), T);
    1575          28 :     Qp = F2xqE_changepointinv(RgE_to_F2xqE(Q,T), gel(e,3), T);
    1576          28 :     r = F2xqE_tatepairing(Pp, Qp, m, gel(e,1), T);
    1577          28 :     break;
    1578             :   default:
    1579          56 :     Pp = FlxqE_changepointinv(RgE_to_FlxqE(P,T,pp), gel(e,3), T, pp);
    1580          56 :     Qp = FlxqE_changepointinv(RgE_to_FlxqE(Q,T,pp), gel(e,3), T, pp);
    1581          56 :     r = FlxqE_tatepairing(Pp, Qp, m, gel(e,1), T, pp);
    1582             :   }
    1583          91 :   r = gerepileupto(av, r);
    1584          91 :   return _mkFF(fg,z,r);
    1585             : }
    1586             : 
    1587             : GEN
    1588      103649 : FFX_roots(GEN Pf, GEN ff)
    1589             : {
    1590      103649 :   pari_sp av = avma;
    1591             :   GEN r,T,p;
    1592             :   ulong pp;
    1593      103649 :   GEN P = FFX_to_raw(Pf, ff);
    1594      103649 :   _getFF(ff,&T,&p,&pp);
    1595      103649 :   switch(ff[1])
    1596             :   {
    1597             :   case t_FF_FpXQ:
    1598          85 :     r = FpXQX_roots(P, T, p);
    1599          85 :     break;
    1600             :   case t_FF_F2xq:
    1601       57512 :     r = F2xqX_roots(P, T);
    1602       57512 :     break;
    1603             :   default:
    1604       46052 :     r = FlxqX_roots(P, T, pp);
    1605             :   }
    1606      103649 :   return gerepilecopy(av, raw_to_FFC(r, ff));
    1607             : }
    1608             : 
    1609             : static GEN
    1610           7 : raw_to_FFXC(GEN x, GEN ff)
    1611           7 : { pari_APPLY_type(t_COL, raw_to_FFX(gel(x,i), ff)); }
    1612             : 
    1613             : static GEN
    1614         448 : raw_to_FFX_fact(GEN F, GEN ff)
    1615             : {
    1616             :   GEN y, u, v;
    1617         448 :   GEN P = gel(F,1), E = gel(F,2);
    1618         448 :   long j, l = lg(P);
    1619         448 :   y = cgetg(3,t_MAT);
    1620         448 :   u = cgetg(l,t_COL); gel(y,1) = u;
    1621         448 :   v = cgetg(l,t_COL); gel(y,2) = v;
    1622        2107 :   for (j=1; j<l; j++)
    1623             :   {
    1624        1659 :     gel(u,j) = raw_to_FFX(gel(P,j), ff);
    1625        1659 :     gel(v,j) = utoi(uel(E,j));
    1626             :   }
    1627         448 :   return y;
    1628             : }
    1629             : 
    1630             : static GEN
    1631        2447 : FFX_zero(GEN ff, long v)
    1632             : {
    1633        2447 :   GEN r = cgetg(3,t_POL);
    1634        2447 :   r[1] = evalvarn(v);
    1635        2447 :   gel(r,2) = FF_zero(ff);
    1636        2447 :   return r;
    1637             : }
    1638             : 
    1639             : static GEN
    1640      104168 : FFX_wrap2(GEN Pf, GEN Qf, GEN ff, GEN FpXQX(GEN, GEN, GEN, GEN),
    1641             :           GEN F2xqX(GEN, GEN, GEN), GEN FlxqX(GEN, GEN, GEN, ulong))
    1642             : {
    1643      104168 :   pari_sp av = avma;
    1644             :   GEN r,T,p;
    1645             :   ulong pp;
    1646      104168 :   GEN P = FFX_to_raw(Pf, ff);
    1647      104168 :   GEN Q = FFX_to_raw(Qf, ff);
    1648      104168 :   _getFF(ff,&T,&p,&pp);
    1649      104168 :   switch(ff[1])
    1650             :   {
    1651             :   case t_FF_FpXQ:
    1652        1932 :     r = FpXQX(P, Q, T, p);
    1653        1932 :     break;
    1654             :   case t_FF_F2xq:
    1655       38902 :     r = F2xqX(P, Q, T);
    1656       38902 :     break;
    1657             :   default:
    1658       63334 :     r = FlxqX(P, Q, T, pp);
    1659             :   }
    1660      104168 :   if (!lgpol(r)) { avma = av; return FFX_zero(ff, varn(Pf)); }
    1661      101721 :   return gerepilecopy(av, raw_to_FFX(r, ff));
    1662             : }
    1663             : 
    1664             : GEN
    1665      101739 : FFX_mul(GEN Pf, GEN Qf, GEN ff)
    1666      101739 : { return FFX_wrap2(Pf, Qf, ff, FpXQX_mul, F2xqX_mul, FlxqX_mul); }
    1667             : 
    1668             : GEN
    1669        2261 : FFX_sqr(GEN Pf, GEN ff)
    1670             : {
    1671        2261 :   pari_sp av = avma;
    1672             :   GEN r,T,p;
    1673             :   ulong pp;
    1674        2261 :   GEN P = FFX_to_raw(Pf, ff);
    1675        2261 :   _getFF(ff,&T,&p,&pp);
    1676        2261 :   switch(ff[1])
    1677             :   {
    1678             :   case t_FF_FpXQ:
    1679         196 :     r = FpXQX_sqr(P, T, p);
    1680         196 :     break;
    1681             :   case t_FF_F2xq:
    1682         952 :     r = F2xqX_sqr(P, T);
    1683         952 :     break;
    1684             :   default:
    1685        1113 :     r = FlxqX_sqr(P, T, pp);
    1686             :   }
    1687        2261 :   if (!lgpol(r)) { avma = av; return FFX_zero(ff, varn(Pf)); }
    1688        2261 :   return gerepilecopy(av, raw_to_FFX(r, ff));
    1689             : }
    1690             : 
    1691             : GEN
    1692        2415 : FFX_rem(GEN Pf, GEN Qf, GEN ff)
    1693        2415 : { return FFX_wrap2(Pf, Qf, ff, FpXQX_rem, F2xqX_rem, FlxqX_rem); }
    1694             : 
    1695             : GEN
    1696           0 : FFXQ_sqr(GEN Pf, GEN Qf, GEN ff)
    1697           0 : { return FFX_wrap2(Pf, Qf, ff, FpXQXQ_sqr, F2xqXQ_sqr, FlxqXQ_sqr); }
    1698             : 
    1699             : GEN
    1700          14 : FFXQ_inv(GEN Pf, GEN Qf, GEN ff)
    1701          14 : { return FFX_wrap2(Pf, Qf, ff, FpXQXQ_inv, F2xqXQ_inv, FlxqXQ_inv); }
    1702             : 
    1703             : GEN
    1704          14 : FFXQ_mul(GEN Pf, GEN Qf, GEN Sf, GEN ff)
    1705             : {
    1706          14 :   pari_sp av = avma;
    1707             :   GEN r,T,p;
    1708             :   ulong pp;
    1709          14 :   GEN P = FFX_to_raw(Pf, ff);
    1710          14 :   GEN Q = FFX_to_raw(Qf, ff);
    1711          14 :   GEN S = FFX_to_raw(Sf, ff);
    1712          14 :   _getFF(ff,&T,&p,&pp);
    1713          14 :   switch(ff[1])
    1714             :   {
    1715             :   case t_FF_FpXQ:
    1716           0 :     r = FpXQXQ_mul(P, Q, S, T, p);
    1717           0 :     break;
    1718             :   case t_FF_F2xq:
    1719           7 :     r = F2xqXQ_mul(P, Q, S, T);
    1720           7 :     break;
    1721             :   default:
    1722           7 :     r = FlxqXQ_mul(P, Q, S, T, pp);
    1723             :   }
    1724          14 :   if (!lgpol(r)) { avma = av; return FFX_zero(ff, varn(Pf)); }
    1725          14 :   return gerepilecopy(av, raw_to_FFX(r, ff));
    1726             : }
    1727             : 
    1728             : long
    1729         168 : FFX_ispower(GEN Pf, long k, GEN ff, GEN *pt_r)
    1730             : {
    1731         168 :   pari_sp av = avma;
    1732             :   GEN P,T,p;
    1733             :   ulong pp;
    1734             :   long s;
    1735         168 :   if (degpol(Pf) % k) return 0;
    1736         168 :   P = FFX_to_raw(Pf, ff);
    1737         168 :   _getFF(ff,&T,&p,&pp);
    1738         168 :   switch(ff[1])
    1739             :   {
    1740             :   case t_FF_FpXQ:
    1741          56 :     s = FpXQX_ispower(P, k, T, p, pt_r);
    1742          56 :     break;
    1743             :   case t_FF_F2xq:
    1744          56 :     s = F2xqX_ispower(P, k, T, pt_r);
    1745          56 :     break;
    1746             :   default:
    1747          56 :     s = FlxqX_ispower(P, k, T, pp, pt_r);
    1748             :   }
    1749         168 :   if (s==0) { avma = av; return 0; }
    1750         147 :   if (pt_r)
    1751         147 :     *pt_r = gerepilecopy(av, raw_to_FFX(*pt_r, ff));
    1752           0 :   else avma = av;
    1753         147 :   return 1;
    1754             : }
    1755             : 
    1756             : GEN
    1757         441 : FFX_factor(GEN Pf, GEN ff)
    1758             : {
    1759         441 :   pari_sp av = avma;
    1760             :   GEN r,T,p;
    1761             :   ulong pp;
    1762         441 :   GEN P = FFX_to_raw(Pf, ff);
    1763         441 :   _getFF(ff,&T,&p,&pp);
    1764         441 :   switch(ff[1])
    1765             :   {
    1766             :   case t_FF_FpXQ:
    1767         121 :     r = FpXQX_factor(P, T, p);
    1768         121 :     break;
    1769             :   case t_FF_F2xq:
    1770         133 :     r = F2xqX_factor(P, T);
    1771         133 :     break;
    1772             :   default:
    1773         187 :     r = FlxqX_factor(P, T, pp);
    1774             :   }
    1775         441 :   return gerepilecopy(av, raw_to_FFX_fact(r, ff));
    1776             : }
    1777             : 
    1778             : GEN
    1779           7 : FFX_factor_squarefree(GEN Pf, GEN ff)
    1780             : {
    1781           7 :   pari_sp av = avma;
    1782             :   GEN r,T,p;
    1783             :   ulong pp;
    1784           7 :   GEN P = FFX_to_raw(Pf, ff);
    1785           7 :   _getFF(ff,&T,&p,&pp);
    1786           7 :   switch(ff[1])
    1787             :   {
    1788             :   case t_FF_FpXQ:
    1789           7 :     r = FpXQX_factor_squarefree(P, T, p);
    1790           7 :     break;
    1791             :   case t_FF_F2xq:
    1792           0 :     r = F2xqX_factor_squarefree(P, T);
    1793           0 :     break;
    1794             :   default:
    1795           0 :     r = FlxqX_factor_squarefree(P, T, pp);
    1796             :   }
    1797           7 :   return gerepilecopy(av, raw_to_FFXC(r, ff));
    1798             : }
    1799             : 
    1800             : GEN
    1801           7 : FFX_ddf(GEN Pf, GEN ff)
    1802             : {
    1803           7 :   pari_sp av = avma;
    1804             :   GEN r,T,p;
    1805             :   ulong pp;
    1806           7 :   GEN P = FFX_to_raw(Pf, ff);
    1807           7 :   _getFF(ff,&T,&p,&pp);
    1808           7 :   switch(ff[1])
    1809             :   {
    1810             :   case t_FF_FpXQ:
    1811           7 :     r = FpXQX_ddf(P, T, p);
    1812           7 :     break;
    1813             :   case t_FF_F2xq:
    1814           0 :     r = F2xqX_ddf(P, T);
    1815           0 :     break;
    1816             :   default:
    1817           0 :     r = FlxqX_ddf(P, T, pp);
    1818             :   }
    1819           7 :   return gerepilecopy(av, raw_to_FFX_fact(r, ff));
    1820             : }
    1821             : 
    1822             : GEN
    1823         126 : FFX_degfact(GEN Pf, GEN ff)
    1824             : {
    1825         126 :   pari_sp av = avma;
    1826             :   GEN r,T,p;
    1827             :   ulong pp;
    1828         126 :   GEN P = FFX_to_raw(Pf, ff);
    1829         126 :   _getFF(ff, &T, &p, &pp);
    1830         126 :   switch(ff[1])
    1831             :   {
    1832             :   case t_FF_FpXQ:
    1833          42 :     r = FpXQX_degfact(P, T, p);
    1834          42 :     break;
    1835             :   case t_FF_F2xq:
    1836          42 :     r = F2xqX_degfact(P, T);
    1837          42 :     break;
    1838             :   default:
    1839          42 :     r = FlxqX_degfact(P, T, pp);
    1840             :   }
    1841         126 :   return gerepilecopy(av, r);
    1842             : }
    1843             : 
    1844             : GEN
    1845           0 : FqX_to_FFX(GEN x, GEN ff)
    1846             : {
    1847             :   long i, lx;
    1848           0 :   GEN y =  cgetg_copy(x,&lx);
    1849           0 :   y[1] = x[1];
    1850           0 :   for (i=2; i<lx; i++) gel(y,i) = Fq_to_FF(gel(x,i), ff);
    1851           0 :   return y;
    1852             : }
    1853             : 
    1854             : GEN
    1855        2575 : ffgen(GEN T, long v)
    1856             : {
    1857        2575 :   GEN A, p = NULL, ff = cgetg(5,t_FFELT);
    1858             :   long d;
    1859        2574 :   switch(typ(T))
    1860             :   {
    1861             :     case t_FFELT:
    1862          28 :       p = FF_p_i(T); T = FF_mod(T); d = degpol(T);
    1863          28 :       break;
    1864             :     case t_POL:
    1865         252 :       d = degpol(T); p = NULL;
    1866         252 :       if (d < 1 || !RgX_is_FpX(T, &p) || !p) pari_err_TYPE("ffgen",T);
    1867         252 :       T = RgX_to_FpX(T, p);
    1868             :       /* testing for irreducibility is too costly */
    1869         252 :       if (!FpX_is_squarefree(T,p)) pari_err_IRREDPOL("ffgen",T);
    1870         245 :       break;
    1871             :     case t_INT:
    1872        1895 :       d = ispseudoprimepower(T,&p);
    1873        1896 :       if (!d) pari_err_PRIME("ffgen",T);
    1874        1896 :       T = init_Fq(p, d, v);
    1875        1897 :       break;
    1876             :     case t_VEC: case t_COL:
    1877         399 :       if (lg(T) == 3) {
    1878         399 :         p = gel(T,1);
    1879         399 :         A = gel(T,2);
    1880         399 :         if (typ(p) == t_INT && typ(A) == t_INT)
    1881             :         {
    1882         399 :           d = itos(A);
    1883         399 :           T = init_Fq(p, d, v);
    1884         399 :           break;
    1885             :         }
    1886             :       }
    1887             :     default:
    1888           0 :       pari_err_TYPE("ffgen",T);
    1889           0 :       return NULL;
    1890             :   }
    1891        2569 :   if (v < 0) v = varn(T);
    1892        2569 :   if (lgefint(p)==3)
    1893             :   {
    1894        2295 :     ulong pp = p[2];
    1895        2295 :     long sv = evalvarn(v);
    1896        2295 :     if (pp==2)
    1897             :     {
    1898        1197 :       ff[1] = t_FF_F2xq;
    1899        1197 :       T = ZX_to_F2x(T); T[1] = sv;
    1900        1197 :       A = polx_F2x(sv); if (d == 1) A = F2x_rem(A, T);
    1901        1197 :       p = gen_2;
    1902             :     }
    1903             :     else
    1904             :     {
    1905        1098 :       ff[1] = t_FF_Flxq;
    1906        1098 :       T = ZX_to_Flx(T,pp); T[1] = sv;
    1907        1098 :       A = polx_Flx(sv); if (d == 1) A = Flx_rem(A, T, pp);
    1908        1098 :       p = icopy(p);
    1909             :     }
    1910             :   }
    1911             :   else
    1912             :   {
    1913         274 :     ff[1] = t_FF_FpXQ;
    1914         274 :     setvarn(T,v);
    1915         274 :     A = pol_x(v); if (d == 1) A = FpX_rem(A, T, p);
    1916         274 :     p = icopy(p);
    1917             :   }
    1918        2569 :   gel(ff,2) = A;
    1919        2569 :   gel(ff,3) = T;
    1920        2569 :   gel(ff,4) = p; return ff;
    1921             : }
    1922             : 
    1923             : GEN
    1924        2989 : p_to_FF(GEN p, long v)
    1925             : {
    1926             :   GEN A, T;
    1927        2989 :   GEN ff = cgetg(5,t_FFELT);
    1928        2989 :   if (lgefint(p)==3)
    1929             :   {
    1930        2984 :     ulong pp = p[2];
    1931        2984 :     long sv = evalvarn(v);
    1932        2984 :     if (pp==2)
    1933             :     {
    1934         329 :       ff[1] = t_FF_F2xq;
    1935         329 :       T = polx_F2x(sv);
    1936         329 :       A = pol1_F2x(sv);
    1937         329 :       p = gen_2;
    1938             :     }
    1939             :     else
    1940             :     {
    1941        2655 :       ff[1] = t_FF_Flxq;
    1942        2655 :       T = polx_Flx(sv);
    1943        2655 :       A = pol1_Flx(sv);
    1944        2655 :       p = icopy(p);
    1945             :     }
    1946             :   }
    1947             :   else
    1948             :   {
    1949           5 :     ff[1] = t_FF_FpXQ;
    1950           5 :     T = pol_x(v);
    1951           5 :     A = pol_1(v);
    1952           5 :     p = icopy(p);
    1953             :   }
    1954        2989 :   gel(ff,2) = A;
    1955        2989 :   gel(ff,3) = T;
    1956        2989 :   gel(ff,4) = p; return ff;
    1957             : }
    1958             : GEN
    1959        4179 : Tp_to_FF(GEN T, GEN p)
    1960             : {
    1961             :   GEN A, ff;
    1962             :   long v;
    1963        4179 :   if (!T) return p_to_FF(p,0);
    1964        3990 :   ff = cgetg(5,t_FFELT);
    1965        3990 :   v = varn(T);
    1966        3990 :   if (lgefint(p)==3)
    1967             :   {
    1968        3780 :     ulong pp = p[2];
    1969        3780 :     long sv = evalvarn(v);
    1970        3780 :     if (pp==2)
    1971             :     {
    1972        1526 :       ff[1] = t_FF_F2xq;
    1973        1526 :       T = ZX_to_F2x(T);
    1974        1526 :       A = pol1_F2x(sv);
    1975        1526 :       p = gen_2;
    1976             :     }
    1977             :     else
    1978             :     {
    1979        2254 :       ff[1] = t_FF_Flxq;
    1980        2254 :       T = ZX_to_Flx(T, pp);
    1981        2254 :       A = pol1_Flx(sv);
    1982        2254 :       p = icopy(p);
    1983             :     }
    1984             :   }
    1985             :   else
    1986             :   {
    1987         210 :     ff[1] = t_FF_FpXQ;
    1988         210 :     T = ZX_copy(T);
    1989         210 :     A = pol_1(v);
    1990         210 :     p = icopy(p);
    1991             :   }
    1992        3990 :   gel(ff,2) = A;
    1993        3990 :   gel(ff,3) = T;
    1994        3990 :   gel(ff,4) = p; return ff;
    1995             : }
    1996             : 
    1997             : GEN
    1998          28 : fforder(GEN x, GEN o)
    1999             : {
    2000          28 :   if (typ(x)!=t_FFELT) pari_err_TYPE("fforder",x);
    2001          28 :   return FF_order(x,o);
    2002             : }
    2003             : 
    2004             : GEN
    2005         385 : ffprimroot(GEN x, GEN *o)
    2006             : {
    2007         385 :   if (typ(x)!=t_FFELT) pari_err_TYPE("ffprimroot",x);
    2008         385 :   return FF_primroot(x,o);
    2009             : }
    2010             : 
    2011             : GEN
    2012         175 : fflog(GEN x, GEN g, GEN o)
    2013             : {
    2014         175 :   if (typ(x)!=t_FFELT) pari_err_TYPE("fflog",x);
    2015         175 :   if (typ(g)!=t_FFELT) pari_err_TYPE("fflog",g);
    2016         175 :   return FF_log(x,g,o);
    2017             : }
    2018             : 
    2019             : GEN
    2020      144466 : ffrandom(GEN ff)
    2021             : {
    2022             :   ulong pp;
    2023      144466 :   GEN r, T, p, z = _initFF(ff,&T,&p,&pp);
    2024      144466 :   switch(ff[1])
    2025             :   {
    2026             :   case t_FF_FpXQ:
    2027        6940 :     r = random_FpX(degpol(T), varn(T), p);
    2028        6940 :     break;
    2029             :   case t_FF_F2xq:
    2030      117271 :     r = random_F2x(F2x_degree(T), T[1]);
    2031      117271 :     break;
    2032             :   default:
    2033       20255 :     r = random_Flx(degpol(T), T[1], pp);
    2034             :   }
    2035      144466 :   return _mkFF(ff,z,r);
    2036             : }
    2037             : 
    2038             : int
    2039     9261848 : Rg_is_FF(GEN c, GEN *ff)
    2040             : {
    2041     9261848 :   switch(typ(c))
    2042             :   {
    2043             :   case t_FFELT:
    2044        8008 :     if (!*ff) *ff = c;
    2045        7840 :     else if (!FF_samefield(*ff, c)) return 0;
    2046        8008 :     break;
    2047             :   default:
    2048     9253840 :     return 0;
    2049             :   }
    2050        8008 :   return 1;
    2051             : }
    2052             : 
    2053             : int
    2054     9254429 : RgC_is_FFC(GEN x, GEN *ff)
    2055             : {
    2056     9254429 :   long i, lx = lg(x);
    2057     9262437 :   for (i=lx-1; i>0; i--)
    2058     9261849 :     if (!Rg_is_FF(gel(x,i), ff)) return 0;
    2059         588 :   return (*ff != NULL);
    2060             : }
    2061             : 
    2062             : int
    2063     9253917 : RgM_is_FFM(GEN x, GEN *ff)
    2064             : {
    2065     9253917 :   long j, lx = lg(x);
    2066     9254428 :   for (j=lx-1; j>0; j--)
    2067     9254351 :     if (!RgC_is_FFC(gel(x,j), ff)) return 0;
    2068          77 :   return (*ff != NULL);
    2069             : }
    2070             : 
    2071             : static GEN
    2072        2206 : FqC_to_FpXQC(GEN x, GEN T, GEN p)
    2073             : {
    2074             :   long i, lx;
    2075        2206 :   GEN y = cgetg_copy(x,&lx);
    2076       34066 :   for(i=1; i<lx; i++)
    2077       31860 :     gel(y, i) = Fq_to_FpXQ(gel(x, i), T, p);
    2078        2206 :   return y;
    2079             : }
    2080             : 
    2081             : static GEN
    2082         390 : FqM_to_FpXQM(GEN x, GEN T, GEN p)
    2083             : {
    2084             :   long i, lx;
    2085         390 :   GEN y = cgetg_copy(x,&lx);
    2086        2526 :   for(i=1; i<lx; i++)
    2087        2136 :     gel(y, i) = FqC_to_FpXQC(gel(x, i), T, p);
    2088         390 :   return y;
    2089             : }
    2090             : 
    2091             : /* for functions t_MAT -> t_MAT */
    2092             : static GEN
    2093         308 : FFM_wrap(GEN M, GEN ff, GEN (*Fq)(GEN,GEN,GEN),
    2094             :                        GEN (*Flxq)(GEN,GEN,ulong),
    2095             :                        GEN (*F2xq)(GEN,GEN))
    2096             : {
    2097         308 :   pari_sp av = avma;
    2098             :   ulong pp;
    2099             :   GEN T, p;
    2100         308 :   _getFF(ff,&T,&p,&pp); M = FFM_to_raw(M, ff);
    2101         308 :   switch(ff[1])
    2102             :   {
    2103         119 :   case t_FF_FpXQ: M = Fq(M,T,p); if (M) M = FqM_to_FpXQM(M,T,p);
    2104         119 :                   break;
    2105          70 :   case t_FF_F2xq: M = F2xq(M,T); break;
    2106         119 :   default: M = Flxq(M,T,pp); break;
    2107             :   }
    2108         308 :   if (!M) { avma = av; return NULL; }
    2109         273 :   return gerepilecopy(av, raw_to_FFM(M, ff));
    2110             : }
    2111             : 
    2112             : /* for functions (t_MAT, t_MAT) -> t_MAT */
    2113             : static GEN
    2114        4116 : FFM_FFM_wrap(GEN M, GEN N, GEN ff,
    2115             :              GEN (*Fq)(GEN, GEN, GEN, GEN),
    2116             :              GEN (*Flxq)(GEN, GEN, GEN, ulong),
    2117             :              GEN (*F2xq)(GEN, GEN, GEN))
    2118             : {
    2119        4116 :   pari_sp av = avma;
    2120             :   ulong pp;
    2121             :   GEN T, p;
    2122        4116 :   int is_sqr = M==N;
    2123        4116 :   _getFF(ff, &T, &p, &pp);
    2124        4116 :   M = FFM_to_raw(M, ff);
    2125        4116 :   N = is_sqr? M: FFM_to_raw(N, ff);
    2126        4116 :   switch(ff[1])
    2127             :   {
    2128         320 :   case t_FF_FpXQ: M = Fq(M, N, T, p); if (M) M = FqM_to_FpXQM(M, T, p);
    2129         320 :                   break;
    2130        1449 :   case t_FF_F2xq: M = F2xq(M, N, T); break;
    2131        2347 :   default: M = Flxq(M, N, T, pp); break;
    2132             :   }
    2133        4116 :   if (!M) { avma = av; return NULL; }
    2134        4025 :   return gerepilecopy(av, raw_to_FFM(M, ff));
    2135             : }
    2136             : 
    2137             : /* for functions (t_MAT, t_COL) -> t_COL */
    2138             : static GEN
    2139         196 : FFM_FFC_wrap(GEN M, GEN C, GEN ff,
    2140             :              GEN (*Fq)(GEN, GEN, GEN, GEN),
    2141             :              GEN (*Flxq)(GEN, GEN, GEN, ulong),
    2142             :              GEN (*F2xq)(GEN, GEN, GEN))
    2143             : {
    2144         196 :   pari_sp av = avma;
    2145             :   ulong pp;
    2146             :   GEN T, p;
    2147         196 :   _getFF(ff, &T, &p, &pp);
    2148         196 :   M = FFM_to_raw(M, ff);
    2149         196 :   C = FFC_to_raw(C, ff);
    2150         196 :   switch(ff[1])
    2151             :   {
    2152          63 :   case t_FF_FpXQ: C = Fq(M, C, T, p); if (C) C = FqC_to_FpXQC(C, T, p);
    2153          63 :                   break;
    2154          70 :   case t_FF_F2xq: C = F2xq(M, C, T); break;
    2155          63 :   default: C = Flxq(M, C, T, pp); break;
    2156             :   }
    2157         196 :   if (!C) { avma = av; return NULL; }
    2158         147 :   return gerepilecopy(av, raw_to_FFC(C, ff));
    2159             : }
    2160             : 
    2161             : GEN
    2162          77 : FFM_ker(GEN M, GEN ff)
    2163          77 : { return FFM_wrap(M,ff, &FqM_ker,&FlxqM_ker,&F2xqM_ker); }
    2164             : GEN
    2165          49 : FFM_image(GEN M, GEN ff)
    2166          49 : { return FFM_wrap(M,ff, &FqM_image,&FlxqM_image,&F2xqM_image); }
    2167             : GEN
    2168         147 : FFM_inv(GEN M, GEN ff)
    2169         147 : { return FFM_wrap(M,ff, &FqM_inv,&FlxqM_inv,&F2xqM_inv); }
    2170             : GEN
    2171          35 : FFM_suppl(GEN M, GEN ff)
    2172          35 : { return FFM_wrap(M,ff, &FqM_suppl,&FlxqM_suppl,&F2xqM_suppl); }
    2173             : 
    2174             : GEN
    2175          84 : FFM_deplin(GEN M, GEN ff)
    2176             : {
    2177          84 :   pari_sp av = avma;
    2178             :   ulong pp;
    2179             :   GEN C, T, p;
    2180          84 :   _getFF(ff, &T, &p, &pp); M = FFM_to_raw(M, ff);
    2181          84 :   switch(ff[1]) {
    2182          35 :   case t_FF_FpXQ: C = FqM_deplin(M, T, p);
    2183          35 :     if (C) C = FqC_to_FpXQC(C, T, p); break;
    2184          14 :   case t_FF_F2xq: C = F2xqM_deplin(M, T); break;
    2185          35 :   default: C = FlxqM_deplin(M, T, pp); break;
    2186             :   }
    2187          84 :   if (!C) { avma = av; return NULL; }
    2188          49 :   return gerepilecopy(av, raw_to_FFC(C, ff));
    2189             : }
    2190             : 
    2191             : GEN
    2192          21 : FFM_indexrank(GEN M, GEN ff)
    2193             : {
    2194          21 :   pari_sp av = avma;
    2195             :   ulong pp;
    2196             :   GEN R, T, p;
    2197          21 :   _getFF(ff,&T,&p,&pp); M = FFM_to_raw(M, ff);
    2198          21 :   switch(ff[1]) {
    2199           7 :   case t_FF_FpXQ: R = FqM_indexrank(M,T,p); break;
    2200           7 :   case t_FF_F2xq: R = F2xqM_indexrank(M,T); break;
    2201           7 :   default: R = FlxqM_indexrank(M,T,pp); break;
    2202             :   }
    2203          21 :   return gerepileupto(av, R);
    2204             : }
    2205             : 
    2206             : long
    2207          63 : FFM_rank(GEN M, GEN ff)
    2208             : {
    2209          63 :   pari_sp av = avma;
    2210             :   long r;
    2211             :   ulong pp;
    2212             :   GEN T, p;
    2213          63 :   _getFF(ff,&T,&p,&pp); M = FFM_to_raw(M, ff);
    2214          63 :   switch(ff[1])
    2215             :   {
    2216          28 :   case t_FF_FpXQ: r = FqM_rank(M,T,p); break;
    2217           7 :   case t_FF_F2xq: r = F2xqM_rank(M,T); break;
    2218          28 :   default: r = FlxqM_rank(M,T,pp); break;
    2219             :   }
    2220          63 :   avma = av; return r;
    2221             : }
    2222             : GEN
    2223          63 : FFM_det(GEN M, GEN ff)
    2224             : {
    2225          63 :   pari_sp av = avma;
    2226             :   ulong pp;
    2227             :   GEN d, T, p;
    2228          63 :   _getFF(ff,&T,&p,&pp); M = FFM_to_raw(M, ff);
    2229          63 :   switch(ff[1])
    2230             :   {
    2231          28 :   case t_FF_FpXQ: d = FqM_det(M,T,p); break;
    2232           7 :   case t_FF_F2xq: d = F2xqM_det(M,T); break;
    2233          28 :   default: d = FlxqM_det(M,T,pp); break;
    2234             :   }
    2235          63 :   return gerepilecopy(av, mkFF_i(ff, d));
    2236             : }
    2237             : 
    2238             : GEN
    2239          56 : FFM_FFC_gauss(GEN M, GEN C, GEN ff)
    2240             : {
    2241          56 :   return FFM_FFC_wrap(M, C, ff, FqM_FqC_gauss,
    2242             :                       FlxqM_FlxqC_gauss, F2xqM_F2xqC_gauss);
    2243             : }
    2244             : 
    2245             : GEN
    2246          63 : FFM_gauss(GEN M, GEN N, GEN ff)
    2247             : {
    2248          63 :   return FFM_FFM_wrap(M, N, ff, FqM_gauss,
    2249             :                       FlxqM_gauss, F2xqM_gauss);
    2250             : }
    2251             : 
    2252             : GEN
    2253          63 : FFM_FFC_invimage(GEN M, GEN C, GEN ff)
    2254             : {
    2255          63 :   return FFM_FFC_wrap(M, C, ff, FqM_FqC_invimage,
    2256             :                       FlxqM_FlxqC_invimage, F2xqM_F2xqC_invimage);
    2257             : }
    2258             : 
    2259             : GEN
    2260         105 : FFM_invimage(GEN M, GEN N, GEN ff)
    2261             : {
    2262         105 :   return FFM_FFM_wrap(M, N, ff, FqM_invimage,
    2263             :                       FlxqM_invimage, F2xqM_invimage);
    2264             : }
    2265             : 
    2266             : GEN
    2267          77 : FFM_FFC_mul(GEN M, GEN C, GEN ff)
    2268             : {
    2269          77 :   return FFM_FFC_wrap(M, C, ff, FqM_FqC_mul,
    2270             :                       FlxqM_FlxqC_mul, F2xqM_F2xqC_mul);
    2271             : }
    2272             : 
    2273             : GEN
    2274        3948 : FFM_mul(GEN M, GEN N, GEN ff)
    2275             : {
    2276        3948 :   return FFM_FFM_wrap(M, N, ff, FqM_mul, FlxqM_mul, F2xqM_mul);
    2277             : }

Generated by: LCOV version 1.11