Code coverage tests

This page documents the degree to which the PARI/GP source code is tested by our public test suite, distributed with the source distribution in directory src/test/. This is measured by the gcov utility; we then process gcov output using the lcov frond-end.

We test a few variants depending on Configure flags on the pari.math.u-bordeaux.fr machine (x86_64 architecture), and agregate them in the final report:

The target is 90% coverage for all mathematical modules (given that branches depending on DEBUGLEVEL or DEBUGMEM are not covered). This script is run to produce the results below.

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

Generated by: LCOV version 1.11