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

Generated by: LCOV version 1.13