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

Generated by: LCOV version 1.11