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 19595-9b18265) Lines: 290 301 96.3 %
Date: 2016-09-25 05:54:30 Functions: 53 55 96.4 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.11