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

Generated by: LCOV version 1.13