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

Generated by: LCOV version 1.11