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

Generated by: LCOV version 1.11