Code coverage tests

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

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

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

LCOV - code coverage report
Current view: top level - language - members.c (source / functions) Hit Total Coverage
Test: PARI/GP v2.12.0 lcov report (development 23344-f0cc1b3f6) Lines: 300 304 98.7 %
Date: 2018-12-12 05:41:43 Functions: 54 54 100.0 %
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             : /**                          MEMBER FUNCTIONS                      **/
      20             : /**                                                                **/
      21             : /********************************************************************/
      22             : INLINE int
      23        9562 : is_ell5(GEN x) {
      24             :   long lx;
      25        9562 :   if (typ(x) != t_VEC) return 0;
      26        9177 :   lx = lg(x);
      27        9177 :   return lx == 17 || (lx == 6 && !is_vec_t(typ(gel(x,2))));
      28             : }
      29        3430 : INLINE int is_ell(GEN x) {
      30        3430 :   long lx = lg(x);
      31        3430 :   return (typ(x) == t_VEC && lx == 17);
      32             : }
      33             : 
      34             : static void
      35        7623 : member_err(const char *s, GEN y) { pari_err_TYPE(s,y); }
      36             : 
      37             : GEN
      38         203 : member_e(GEN x)
      39             : {
      40         203 :   GEN y = get_prid(x);
      41         203 :   if (!y) member_err("e",x);
      42          14 :   return gel(y,3);
      43             : }
      44             : 
      45             : GEN
      46        6839 : member_f(GEN x)
      47             : {
      48        6839 :   GEN y = get_prid(x);
      49        6839 :   if (!y)
      50             :   {
      51         294 :     if (typ(x) == t_FFELT) return utoipos(FF_f(x));
      52         168 :     member_err("f",x);
      53             :   }
      54        6545 :   return gel(y,4);
      55             : }
      56             : 
      57             : GEN
      58       98231 : member_p(GEN x)
      59             : {
      60       98231 :   long t; (void)get_nf(x,&t);
      61       98231 :   switch(t)
      62             :   {
      63           7 :     case typ_GAL: return gal_get_p(x);
      64         196 :     case typ_ELL: switch(ell_get_type(x))
      65             :     {
      66             :       case t_ELL_Fp:
      67         119 :       case t_ELL_Fq: return ellff_get_p(x);
      68           7 :       case t_ELL_Qp: return ellQp_get_p(x);
      69          70 :       default: member_err("p",x);
      70             :     }
      71           7 :     case typ_MODPR: x = get_prid(x);
      72       97664 :     case typ_PRID: return pr_get_p(x);
      73             :   }
      74         364 :   switch(typ(x)) {
      75          63 :     case t_PADIC: return gel(x,2);
      76         175 :     case t_FFELT: return FF_p_i(x);
      77             :   }
      78         126 :   member_err("p",x);
      79           0 :   return NULL;
      80             : }
      81             : 
      82             : GEN
      83         210 : member_bid(GEN x)
      84             : {
      85         210 :   long t; (void)get_nf(x,&t);
      86         210 :   switch(t) {
      87          14 :     case typ_BNR: return bnr_get_bid(x);
      88             :     case typ_BIDZ:
      89          14 :     case typ_BID: return x;
      90             :   }
      91         182 :   member_err("bid",x);
      92           0 :   return NULL;
      93             : }
      94             : 
      95             : GEN
      96         203 : member_bnf(GEN x)
      97             : {
      98         203 :   long t; GEN y = get_bnf(x,&t);
      99         203 :   if (!y) {
     100         189 :     if (t == typ_ELL && ell_get_type(x) == t_ELL_NF)
     101             :     {
     102           0 :       y = ellnf_get_bnf(x);
     103           0 :       if (y) return y;
     104             :     }
     105         189 :     member_err("bnf",x);
     106             :   }
     107          14 :   return y;
     108             : }
     109             : 
     110             : GEN
     111         301 : member_nf(GEN x)
     112             : {
     113         301 :   long t; GEN y = get_nf(x,&t);
     114         301 :   if (!y) {
     115         273 :     if (t == typ_RNF) return gel(x,10);
     116         252 :     if (t == typ_ELL && ell_get_type(x) == t_ELL_NF) return ellnf_get_nf(x);
     117         168 :     member_err("nf",x);
     118             :   }
     119          28 :   return y;
     120             : }
     121             : 
     122             : /* integral basis */
     123             : GEN
     124         245 : member_zk(GEN x)
     125             : {
     126         245 :   long t; GEN y = get_nf(x,&t);
     127         245 :   if (!y)
     128             :   {
     129         175 :     switch(t)
     130             :     {
     131             :       case typ_Q:
     132           7 :         y = cgetg(3,t_VEC);
     133           7 :         gel(y,1) = gen_1;
     134           7 :         gel(y,2) = pol_x(varn(gel(x,1))); return y;
     135             :       case typ_RNF:
     136           7 :         return gel(x,7);
     137             :     }
     138         161 :     member_err("zk",x);
     139             :   }
     140          70 :   return nf_get_zk(y);
     141             : }
     142             : 
     143             : GEN
     144        2709 : member_disc(GEN x) /* discriminant */
     145             : {
     146        2709 :   long t; GEN y = get_nf(x,&t);
     147        2709 :   if (!y)
     148             :   {
     149        2660 :     switch(t)
     150             :     {
     151           7 :       case typ_Q  : return quad_disc(x);
     152        2457 :       case typ_ELL: return ell_get_disc(x);
     153          63 :       case typ_RNF: return rnf_get_disc(x);
     154             :     }
     155         133 :     member_err("disc",x);
     156             :   }
     157          49 :   return nf_get_disc(y);
     158             : }
     159             : 
     160             : GEN
     161        1764 : member_pol(GEN x) /* polynomial */
     162             : {
     163        1764 :   long t; GEN y = get_nf(x,&t);
     164        1764 :   if (!y)
     165             :   {
     166        1428 :     switch(t)
     167             :     {
     168           7 :       case typ_POL: return x;
     169           7 :       case typ_Q  : return gel(x,1);
     170         308 :       case typ_GAL: return gal_get_pol(x);
     171         119 :       case typ_RNF: return rnf_get_pol(x);
     172             :     }
     173         987 :     if (typ(x)==t_POLMOD) return gel(x,2);
     174         980 :     if (typ(x)==t_FFELT) return FF_to_FpXQ(x);
     175         119 :     member_err("pol",x);
     176             :   }
     177         336 :   return nf_get_pol(y);
     178             : }
     179             : 
     180             : GEN
     181         238 : member_polabs(GEN x)
     182             : {
     183         238 :   long t; (void)get_nf(x,&t);
     184         238 :   if (t != typ_RNF) member_err("pol",x);
     185          42 :   return rnf_get_polabs(x);
     186             : }
     187             : 
     188             : GEN
     189        7777 : member_mod(GEN x) /* modulus */
     190             : {
     191        7777 :   long t; (void)get_nf(x,&t);
     192        7777 :   switch(t) {
     193           7 :     case typ_GAL: return gal_get_mod(x);
     194        6538 :     case typ_BNR: return bnr_get_mod(x);
     195         749 :     case typ_BIDZ: return bid_get_ideal(x);
     196          14 :     case typ_BID: return bid_get_mod(x);
     197             :   }
     198         469 :   switch(typ(x))
     199             :   {
     200          70 :     case t_INTMOD: case t_POLMOD: case t_QUAD: break;
     201           7 :     case t_PADIC: return gel(x,3);
     202         266 :     case t_FFELT: return FF_mod(x);
     203             :     case t_VEC:
     204          98 :       if (checkmf_i(x))
     205             :       {
     206           7 :         GEN T = mf_get_field(x), CHI = mf_get_CHI(x), P = mfcharpol(CHI);
     207           7 :         return (degpol(T) == 1)? P: (degpol(P) > 1? gmodulo(T, P): T);
     208             :       }
     209          91 :       else if (checkMF_i(x))
     210           7 :         return mfcharpol(MF_get_CHI(x));
     211         112 :     default: member_err("mod",x);
     212             :   }
     213          70 :   return gel(x,1);
     214             : }
     215             : 
     216             : GEN
     217         609 : member_sign(GEN x) /* signature */
     218             : {
     219         609 :   long t; GEN y = get_nf(x,&t);
     220         609 :   if (!y) member_err("sign",x);
     221          84 :   return gel(y,2);
     222             : }
     223             : GEN
     224         203 : member_r1(GEN x) { return gel(member_sign(x), 1); }
     225             : GEN
     226         203 : member_r2(GEN x) { return gel(member_sign(x), 2); }
     227             : 
     228             : GEN
     229         210 : member_index(GEN x)
     230             : {
     231         210 :   long t; GEN y = get_nf(x,&t);
     232         210 :   if (!y)
     233             :   {
     234         175 :     if (t == typ_RNF) return rnf_get_index(x);
     235         168 :     member_err("index",x);
     236             :   }
     237          35 :   return nf_get_index(y);
     238             : }
     239             : 
     240             : /* x assumed to be output by get_nf: ie a t_VEC with length 11 */
     241             : static GEN
     242         616 : nfmats(GEN x)
     243             : {
     244             :   GEN y;
     245         616 :   if (!x) return NULL;
     246          91 :   y = gel(x,5);
     247          91 :   if (typ(y) == t_VEC && lg(y) < 8) return NULL;
     248          91 :   return y;
     249             : }
     250             : 
     251             : GEN
     252         203 : member_t2(GEN x) /* T2 matrix */
     253             : {
     254         203 :   long t; GEN y = nfmats(get_nf(x,&t));
     255         203 :   if (!y) member_err("t2",x);
     256          28 :   return gram_matrix(gel(y,2));
     257             : }
     258             : 
     259             : GEN
     260         203 : member_diff(GEN x) /* different */
     261             : {
     262         203 :   long t; GEN y = nfmats(get_nf(x,&t));
     263         203 :   if (!y) member_err("diff",x);
     264          28 :   return gel(y,5);
     265             : }
     266             : 
     267             : GEN
     268         210 : member_codiff(GEN x) /* codifferent */
     269             : {
     270             :   long t;
     271         210 :   GEN T, d, Di, nf = get_nf(x,&t), y = nfmats(nf);
     272         210 :   if (!y) member_err("codiff",x);
     273          35 :   T = gel(y,4);
     274          35 :   Di = ZM_inv(T, &d); if (!d) return matid(lg(Di)-1);
     275          35 :   return RgM_Rg_div(ZM_hnfmodid(Di, d), d);
     276             : }
     277             : 
     278             : GEN
     279         231 : member_roots(GEN x) /* roots */
     280             : {
     281         231 :   long t; GEN y = get_nf(x,&t);
     282         231 :   if (!y)
     283             :   {
     284         203 :     if (t == typ_GAL) return gal_get_roots(x);
     285         196 :     if (t == typ_ELL)
     286          56 :       switch(ell_get_type(x))
     287             :       {
     288          21 :         case t_ELL_Qp: return mkcol( ellQp_root(x, ellQp_get_prec(x)) );
     289             :         case t_ELL_Q:
     290          21 :         case t_ELL_Rg: return ellR_roots(x, ellR_get_prec(x));
     291             :       }
     292         154 :     member_err("roots",x);
     293             :   }
     294          28 :   return nf_get_roots(y);
     295             : }
     296             : 
     297             : /* assume x output by get_bnf: ie a t_VEC with length 10 */
     298             : static GEN
     299         224 : check_RES(GEN x, const char *s)
     300             : {
     301         224 :   GEN y = gel(x,8);
     302         224 :   if (typ(y) != t_VEC || lg(y) < 4) member_err(s,x);
     303         224 :   return y;
     304             : }
     305             : 
     306             : /* y = get_bnf(x, &t) */
     307             : static GEN
     308       17500 : _member_clgp(GEN x, GEN y, long t) /* class group (3-component row vector) */
     309             : {
     310       17500 :   if (!y)
     311             :   {
     312       17227 :     switch(t)
     313             :     {
     314        4361 :       case typ_QUA: return mkvec3(gel(x,1), gel(x,2), gel(x,3));
     315             :       case typ_BIDZ:
     316        5523 :       case typ_BID: return gel(x,2);
     317             :     }
     318        7343 :     if (typ(x)==t_VEC)
     319        7042 :       switch(lg(x))
     320             :       {
     321             :         case 3: /* no gen */
     322        6776 :         case 4: return x;
     323             :       }
     324         567 :     member_err("clgp",x);
     325             :   }
     326         273 :   if (t==typ_BNR) return gel(x,5);
     327         203 :   y = check_RES(y, "clgp"); return gel(y,1);
     328             : }
     329             : static GEN
     330       17500 : _check_clgp(GEN x, GEN y, long t)
     331       17500 : { GEN c = _member_clgp(x,y,t); checkabgrp(c); return c; }
     332             : GEN
     333         266 : member_clgp(GEN x)
     334         266 : { long t; GEN y = get_bnf(x,&t); return _check_clgp(x,y,t); }
     335             : 
     336             : GEN
     337         217 : member_reg(GEN x) /* regulator */
     338             : {
     339         217 :   long t; GEN y = get_bnf(x,&t);
     340         217 :   if (!y)
     341             :   {
     342         189 :     if (t == typ_QUA) return gel(x,4);
     343         182 :     member_err("reg",x);
     344             :   }
     345          28 :   if (t == typ_BNR) pari_err_IMPL("ray regulator");
     346          21 :   y = check_RES(y, "reg");
     347          21 :   return gel(y,2);
     348             : }
     349             : 
     350             : GEN
     351         224 : member_fu(GEN x) /* fundamental units */
     352             : {
     353         224 :   long t; GEN fu, y = get_bnf(x,&t);
     354         224 :   if (!y)
     355             :   {
     356         189 :     switch(t)
     357             :     {
     358             :       case typ_Q:
     359           7 :         x = quad_disc(x);
     360           7 :         return (signe(x)<0)? cgetg(1,t_VEC): quadunit(x);
     361             :     }
     362         182 :     member_err("fu",x);
     363             :   }
     364          35 :   if (t == typ_BNR) pari_err_IMPL("ray units");
     365          28 :   fu = bnf_get_fu_nocheck(y);
     366          28 :   if (typ(fu) == t_MAT) return gen_0; /*missing units*/
     367          28 :   return matbasistoalg(y, fu);
     368             : }
     369             : 
     370             : /* torsion units. return [w,e] where w is the number of roots of 1, and e a
     371             :  * polmod (or integer) generator */
     372             : GEN
     373         210 : member_tu(GEN x)
     374             : {
     375         210 :   long t; GEN bnf = get_bnf(x,&t), res = cgetg(3,t_VEC);
     376         210 :   if (!bnf)
     377             :   {
     378             :     GEN y;
     379         189 :     if (t != typ_Q) member_err("tu",x);
     380           7 :     y = quad_disc(x);
     381           7 :     if (signe(y) > 0 || abscmpiu(y,4) > 0) return mkvec2(gen_m1, gen_2);
     382             : 
     383           7 :     gel(res,1) = utoipos((itos(y) == -4)? 4: 6);
     384           7 :     gel(res,2) = gcopy(x);
     385             :   }
     386             :   else
     387             :   {
     388          21 :     GEN z = bnf_get_tuU(bnf);
     389          21 :     if (t == typ_BNR) pari_err_IMPL("ray torsion units");
     390          14 :     gel(res,1) = utoipos( bnf_get_tuN(bnf) );
     391          14 :     gel(res,2) = typ(z)==t_INT? gen_m1: basistoalg(bnf,z);
     392             :   }
     393          21 :   return res;
     394             : }
     395             : 
     396             : /* structure of (Z_K/m)^*, where x is an idealstarinit (with or without gen)
     397             :  * or a bnrinit (with or without gen) */
     398             : GEN
     399         203 : member_zkst(GEN x)
     400             : {
     401         203 :   long t; (void)get_nf(x,&t);
     402         203 :   switch(t)
     403             :   {
     404             :     case typ_BIDZ:
     405          14 :     case typ_BID: return bid_get_grp(x);
     406             :     case typ_BNR: {
     407           7 :       GEN bid = bnr_get_bid(x);
     408           7 :       if (typ(bid) == t_VEC && lg(bid) > 2) return bid_get_grp(bid);
     409             :     }
     410             :   }
     411         182 :   member_err("zkst",x);
     412             :   return NULL; /* LCOV_EXCL_LINE */
     413             : }
     414             : 
     415             : GEN
     416        3003 : member_no(GEN x) /* number of elements of a group (of type clgp) */
     417             : {
     418        3003 :   pari_sp av = avma;
     419        3003 :   long t; GEN y = get_bnf(x,&t);
     420        3003 :   if (t == typ_ELL) switch(ell_get_type(x))
     421             :   {
     422             :     case t_ELL_Fp:
     423          14 :     case t_ELL_Fq: return ellcard(x, NULL);
     424             :   }
     425        2989 :   x = _check_clgp(x,y,t);
     426        2835 :   set_avma(av); return gel(x,1);
     427             : }
     428             : 
     429             : GEN
     430       11865 : member_cyc(GEN x) /* cyclic decomposition (SNF) of a group (of type clgp) */
     431             : {
     432       11865 :   pari_sp av = avma;
     433       11865 :   long t; GEN y = get_bnf(x,&t);
     434       11865 :   if (t == typ_ELL) switch(ell_get_type(x))
     435             :   {
     436             :     case t_ELL_Fp:
     437          14 :     case t_ELL_Fq: return ellgroup(x, NULL);
     438             :   }
     439       11851 :   x = _check_clgp(x,y,t);
     440       11697 :   set_avma(av); return gel(x,2);
     441             : }
     442             : 
     443             : /* SNF generators of a group (of type clgp), or generators of a prime
     444             :  * ideal */
     445             : GEN
     446        2562 : member_gen(GEN x)
     447             : {
     448             :   pari_sp av;
     449        2562 :   long t; GEN y = get_bnf(x,&t);
     450        2562 :   switch(t)
     451             :   {
     452           7 :     case typ_MODPR: x = get_prid(x);
     453          70 :     case typ_PRID: return mkvec2(gel(x,1), gel(x,2));
     454          28 :     case typ_GAL: return gal_get_gen(x);
     455          70 :     case typ_ELL: return ellgenerators(x);
     456             :   }
     457        2394 :   av = avma;
     458        2394 :   x = _check_clgp(x,y,t);
     459        2275 :   if (lg(x)!=4) member_err("gen",x);
     460        2261 :   set_avma(av); return gel(x,3);
     461             : }
     462             : GEN
     463         434 : member_group(GEN x)
     464             : {
     465         434 :   long t; (void)get_nf(x,&t);
     466         434 :   if (t == typ_GAL) return gal_get_group(x);
     467         308 :   if (t == typ_ELL) return ellgroup0(x, NULL, 1);
     468         168 :   member_err("group",x);
     469             :   return NULL; /* LCOV_EXCL_LINE */
     470             : }
     471             : GEN
     472         203 : member_orders(GEN x)
     473             : {
     474         203 :   long t; (void)get_nf(x,&t);
     475         203 :   if (t == typ_GAL) return gal_get_orders(x);
     476         196 :   member_err("orders",x);
     477             :   return NULL; /* LCOV_EXCL_LINE */
     478             : }
     479             : 
     480             : GEN
     481        1918 : member_a1(GEN x)
     482             : {
     483        1918 :   if (!is_ell5(x)) member_err("a1",x);
     484        1750 :   return ell_get_a1(x);
     485             : }
     486             : 
     487             : GEN
     488        1911 : member_a2(GEN x)
     489             : {
     490        1911 :   if (!is_ell5(x)) member_err("a2",x);
     491        1743 :   return ell_get_a2(x);
     492             : }
     493             : 
     494             : GEN
     495        1911 : member_a3(GEN x)
     496             : {
     497        1911 :   if (!is_ell5(x)) member_err("a3",x);
     498        1743 :   return ell_get_a3(x);
     499             : }
     500             : 
     501             : GEN
     502        1911 : member_a4(GEN x)
     503             : {
     504        1911 :   if (!is_ell5(x)) member_err("a4",x);
     505        1743 :   return ell_get_a4(x);
     506             : }
     507             : 
     508             : GEN
     509        1911 : member_a6(GEN x)
     510             : {
     511        1911 :   if (!is_ell5(x)) member_err("a6",x);
     512        1743 :   return ell_get_a6(x);
     513             : }
     514             : 
     515             : GEN
     516         203 : member_b2(GEN x)
     517             : {
     518         203 :   if (!is_ell(x)) member_err("b2",x);
     519          28 :   return ell_get_b2(x);
     520             : }
     521             : 
     522             : GEN
     523         203 : member_b4(GEN x)
     524             : {
     525         203 :   if (!is_ell(x)) member_err("b4",x);
     526          28 :   return ell_get_b4(x);
     527             : }
     528             : 
     529             : GEN
     530         203 : member_b6(GEN x)
     531             : {
     532         203 :   if (!is_ell(x)) member_err("b6",x);
     533          28 :   return ell_get_b6(x);
     534             : }
     535             : 
     536             : GEN
     537         203 : member_b8(GEN x)
     538             : {
     539         203 :   if (!is_ell(x)) member_err("b8",x);
     540          28 :   return ell_get_b8(x);
     541             : }
     542             : 
     543             : GEN
     544         210 : member_c4(GEN x)
     545             : {
     546         210 :   if (!is_ell(x)) member_err("c4",x);
     547          35 :   return ell_get_c4(x);
     548             : }
     549             : 
     550             : GEN
     551         210 : member_c6(GEN x)
     552             : {
     553         210 :   if (!is_ell(x)) member_err("c6",x);
     554          35 :   return ell_get_c6(x);
     555             : }
     556             : 
     557             : GEN
     558        1106 : member_j(GEN x)
     559             : {
     560        1106 :   if (!is_ell(x)) member_err("j",x);
     561         931 :   return ell_get_j(x);
     562             : }
     563             : 
     564             : static int
     565         182 : ell_is_complex(GEN x)
     566         182 : { long t = ell_get_type(x); return t == t_ELL_Q || t == t_ELL_Rg; }
     567             : 
     568             : static long
     569          98 : ellnf_get_prec(GEN x) { return nf_get_prec(ellnf_get_nf(x)); }
     570             : 
     571             : GEN
     572         287 : member_omega(GEN x)
     573             : {
     574         287 :   if (!is_ell(x)) member_err("omega",x);
     575         112 :   if (ell_get_type(x)==t_ELL_NF)
     576          35 :     return ellnf_vecomega(x, ellnf_get_prec(x));
     577          77 :   if (!ell_is_complex(x)) pari_err_TYPE("omega [not defined over C]",x);
     578          42 :   return ellR_omega(x, ellR_get_prec(x));
     579             : }
     580             : 
     581             : GEN
     582         266 : member_eta(GEN x)
     583             : {
     584         266 :   if (!is_ell(x)) member_err("eta",x);
     585          91 :   if (ell_get_type(x)==t_ELL_NF)
     586          28 :     return ellnf_veceta(x, ellnf_get_prec(x));
     587          63 :   if (!ell_is_complex(x)) pari_err_TYPE("eta [not defined over C]",x);
     588          35 :   return ellR_eta(x, ellR_get_prec(x));
     589             : }
     590             : 
     591             : GEN
     592         252 : member_area(GEN x)
     593             : {
     594         252 :   if (!is_ell(x)) member_err("area",x);
     595          77 :   if (ell_get_type(x)==t_ELL_NF)
     596          35 :     return ellnf_vecarea(x, ellnf_get_prec(x));
     597          42 :   if (!ell_is_complex(x)) pari_err_TYPE("area [not defined over C]",x);
     598          14 :   return ellR_area(x, ellR_get_prec(x));
     599             : }
     600             : 
     601             : GEN
     602         287 : member_tate(GEN x)
     603             : {
     604             :   long prec;
     605         287 :   if (!is_ell(x)) member_err("tate",x);
     606         112 :   if (ell_get_type(x) != t_ELL_Qp)
     607          28 :     pari_err_TYPE("tate [not defined over Qp]",x);
     608          84 :   prec = ellQp_get_prec(x);
     609          84 :   return ellQp_Tate_uniformization(x, prec);
     610             : }

Generated by: LCOV version 1.13