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.8.0 lcov report (development 19043-64ae2d8) Lines: 293 297 98.7 %
Date: 2016-06-25 Functions: 53 55 96.4 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 205 216 94.9 %

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

Generated by: LCOV version 1.9