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-bordeaux1.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 - headers - paripriv.h (source / functions) Hit Total Coverage
Test: PARI/GP v2.8.0 lcov report (development 16962-5a32637) Lines: 5 5 100.0 %
Date: 2014-10-29 Functions: 5 5 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 8 8 100.0 %

           Branch data     Line data    Source code
       1                 :            : /* Copyright (C) 2004  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                 :            : BEGINEXTERN
      15                 :            : /* hashtables */
      16                 :            : hashtable *hashstr_import_static(hashentry *e, ulong size);
      17                 :            : void hashstr_dbg(hashtable *h);
      18                 :            : 
      19                 :            : /* for qsort */
      20                 :            : typedef int (*QSCOMP)(const void *, const void *);
      21                 :            : 
      22                 :            : #define ucoeff(a,i,j)  (((ulong**)(a))[j][i])
      23                 :            : #define umael(a,i,j)   (((ulong**)(a))[i][j])
      24                 :            : #define uel(a,i)       (((ulong*)(a))[i])
      25                 :            : 
      26                 :            : /* to manipulate 'blocs' */
      27                 :            : #define BL_HEAD 4
      28                 :            : #define bl_base(x) (void*)((x) - BL_HEAD)
      29                 :            : #define bl_refc(x) (((GEN)x)[-4])
      30                 :            : #define bl_next(x) (((GEN*)x)[-3])
      31                 :            : #define bl_prev(x) (((GEN*)x)[-2])
      32                 :            : #define bl_num(x)  (((GEN)x)[-1])
      33                 :            : INLINE void
      34         [ +  + ]:  110933847 : clone_lock(GEN C) { if (isclone(C)) ++bl_refc(C); }
      35                 :            : INLINE void
      36         [ +  + ]:  111198976 : clone_unlock(GEN C) { if (isclone(C)) gunclone(C); }
      37                 :            : 
      38                 :            : /* swap */
      39                 :            : #define lswap(x,y) {long _z=x; x=y; y=_z;}
      40                 :            : #define pswap(x,y) {GEN *_z=x; x=y; y=_z;}
      41                 :            : #define swap(x,y)  {GEN  _z=x; x=y; y=_z;}
      42                 :            : #define dswap(x,y) { double _t=x; x=y; y=_t; }
      43                 :            : #define pdswap(x,y) { double* _t=x; x=y; y=_t; }
      44                 :            : #define swapspec(x,y, nx,ny) {swap(x,y); lswap(nx,ny);}
      45                 :            : 
      46                 :            : /* unused */
      47                 :            : void ellprint(GEN e);
      48                 :            : 
      49                 :            : /* binary splitting */
      50                 :            : struct abpq { GEN *a, *b, *p, *q; };
      51                 :            : struct abpq_res { GEN P, Q, B, T; };
      52                 :            : void abpq_init(struct abpq *A, long n);
      53                 :            : void abpq_sum(struct abpq_res *r, long n1, long n2, struct abpq *A);
      54                 :            : 
      55                 :            : /* generic */
      56                 :            : GEN trans_fix_arg(long *prec, GEN *s0, GEN *sig, GEN *tau, pari_sp *av, GEN *res);
      57                 :            : GEN sort_factor_pol(GEN y, int (*cmp)(GEN,GEN));
      58                 :            : 
      59                 :            : /* loops */
      60                 :            : GEN incloop(GEN a);
      61                 :            : GEN resetloop(GEN a, GEN b);
      62                 :            : GEN setloop(GEN a);
      63                 :            : 
      64                 :            : /* parser */
      65                 :            : GEN  iferrpari(GEN a, GEN b, GEN c);
      66                 :            : void forpari(GEN a, GEN b, GEN node);
      67                 :            : void untilpari(GEN a, GEN b);
      68                 :            : void whilepari(GEN a, GEN b);
      69                 :            : GEN  ifpari(GEN g, GEN a, GEN b);
      70                 :            : GEN  andpari(GEN a, GEN b);
      71                 :            : GEN  orpari(GEN a, GEN b);
      72                 :            : void ifpari_void(GEN g, GEN a, GEN b);
      73                 :            : GEN  ifpari_multi(GEN g, GEN a);
      74                 :            : GEN  geval_gp(GEN x, GEN t);
      75                 :            : 
      76                 :            : GEN  gadde(GEN *x, GEN y);
      77                 :            : GEN  gadd1e(GEN *x);
      78                 :            : GEN  gdive(GEN *x, GEN y);
      79                 :            : GEN  gdivente(GEN *x, GEN y);
      80                 :            : GEN  gdivrounde(GEN *x, GEN y);
      81                 :            : GEN  gmode(GEN *x, GEN y);
      82                 :            : GEN  gmule(GEN *x, GEN y);
      83                 :            : GEN  gshiftle(GEN *x, long n);
      84                 :            : GEN  gshiftre(GEN *x, long n);
      85                 :            : GEN  gsube(GEN *x, GEN y);
      86                 :            : GEN  gsub1e(GEN *x);
      87                 :            : GEN  gshift_right(GEN x, long n);
      88                 :            : 
      89                 :            : GEN  derivnum0(GEN a, GEN code, long prec);
      90                 :            : GEN  derivfun0(GEN code, GEN args, long prec);
      91                 :            : GEN  direuler0(GEN a, GEN b, GEN code, GEN c);
      92                 :            : void forcomposite(GEN a, GEN b, GEN code);
      93                 :            : void fordiv(GEN a, GEN code);
      94                 :            : void forell0(long a, long b, GEN code);
      95                 :            : void forprime(GEN a, GEN b, GEN code);
      96                 :            : void forstep(GEN a, GEN b, GEN s, GEN code);
      97                 :            : void forsubgroup0(GEN cyc, GEN bound, GEN code);
      98                 :            : void forvec(GEN x, GEN code, long flag);
      99                 :            : void forpart0(GEN k, GEN code , GEN nbound, GEN abound);
     100                 :            : GEN  intcirc0(GEN a, GEN R, GEN code, GEN tab, long prec);
     101                 :            : GEN  intfourcos0(GEN a, GEN b, GEN x, GEN code, GEN tab, long prec);
     102                 :            : GEN  intfourexp0(GEN a, GEN b, GEN x, GEN code, GEN tab, long prec);
     103                 :            : GEN  intfoursin0(GEN a, GEN b, GEN x, GEN code, GEN tab, long prec);
     104                 :            : GEN  intfuncinit0(GEN a, GEN b, GEN code, long flag, long m, long prec);
     105                 :            : GEN  intlaplaceinv0(GEN sig, GEN x, GEN code, GEN tab, long prec);
     106                 :            : GEN  intmellininv0(GEN sig, GEN x, GEN code, GEN tab, long prec);
     107                 :            : GEN  intnum0(GEN a, GEN b, GEN code, GEN tab, long prec);
     108                 :            : GEN  intnuminit0(GEN a, GEN b, GEN tab, long prec);
     109                 :            : GEN  intnuminitgen0(GEN a, GEN b, GEN code, long m, long flag, long prec);
     110                 :            : GEN  intnumromb0(GEN a, GEN b, GEN code, long flag, long prec);
     111                 :            : GEN  matrice(GEN nlig, GEN ncol, GEN code);
     112                 :            : GEN  prodeuler0(GEN a, GEN b, GEN code, long prec);
     113                 :            : GEN  prodinf0(GEN a, GEN code, long flag, long prec);
     114                 :            : GEN  produit(GEN a, GEN b, GEN code, GEN x);
     115                 :            : GEN  somme(GEN a, GEN b, GEN code, GEN x);
     116                 :            : GEN  sumalt0(GEN a, GEN code,long flag, long prec);
     117                 :            : GEN  sumdivexpr(GEN num, GEN code);
     118                 :            : GEN  sumdivmultexpr(GEN num, GEN code);
     119                 :            : GEN  suminf0(GEN a, GEN code, long prec);
     120                 :            : GEN  sumnum0(GEN a, GEN sig, GEN code, GEN tab, long flag, long prec);
     121                 :            : GEN  sumnumalt0(GEN a, GEN sig, GEN code, GEN tab, long flag, long prec);
     122                 :            : GEN  sumnuminit0(GEN a, GEN tab, long sgn, long prec);
     123                 :            : GEN  sumpos0(GEN a, GEN code, long flag,long prec);
     124                 :            : GEN  vecexpr0(GEN nmax, GEN code, GEN pred);
     125                 :            : GEN  vecexpr1(GEN nmax, GEN code, GEN pred);
     126                 :            : GEN  vecteursmall(GEN nmax, GEN code);
     127                 :            : GEN  vecteur(GEN nmax, GEN n);
     128                 :            : GEN  vvecteur(GEN nmax, GEN n);
     129                 :            : GEN  zbrent0(GEN a, GEN b, GEN code, long prec);
     130                 :            : 
     131                 :            : /* mt */
     132                 :            : void mt_sigint(void);
     133                 :            : void mt_err_recover(long er);
     134                 :            : void mt_init_stack(size_t s);
     135                 :            : int  mt_is_thread(void);
     136                 :            : GEN  parapply_worker(GEN d, GEN code);
     137                 :            : GEN  pareval_worker(GEN code);
     138                 :            : void parfor(GEN a, GEN b, GEN code, GEN code2);
     139                 :            : GEN  parfor_worker(GEN i, GEN C);
     140                 :            : void parforprime(GEN a, GEN b, GEN code, GEN code2);
     141                 :            : GEN  parvector_worker(GEN i, GEN C);
     142                 :            : 
     143                 :            : /* multiprecision */
     144                 :            : GEN   addrex01(GEN x);
     145                 :            : GEN   adduispec_offset(ulong s, GEN x, long offset, long nx);
     146                 :            : int   lgcdii(ulong* d, ulong* d1, ulong* u, ulong* u1, ulong* v, ulong* v1, ulong vmax);
     147                 :            : ulong rgcduu(ulong d, ulong d1, ulong vmax, ulong* u, ulong* u1, ulong* v, ulong* v1, long *s);
     148                 :            : ulong xgcduu(ulong d, ulong d1, int f, ulong* v, ulong* v1, long *s);
     149                 :            : ulong xxgcduu(ulong d, ulong d1, int f, ulong* u, ulong* u1, ulong* v, ulong* v1, long *s);
     150                 :            : GEN   divgunu(GEN x, ulong i);
     151                 :            : GEN   divrunu(GEN x, ulong i);
     152                 :            : GEN   muliispec(GEN x, GEN y, long nx, long ny);
     153                 :            : GEN   red_montgomery(GEN T, GEN N, ulong inv);
     154                 :            : GEN   sqrispec(GEN x, long nx);
     155                 :            : GEN   subrex01(GEN x);
     156                 :            : GEN   modr_safe(GEN x, GEN y);
     157                 :            : ulong *convi(GEN x, long *l);
     158                 :            : 
     159                 :            : int approx_0(GEN x, GEN y);
     160                 :            : GEN bernfrac_using_zeta(long n);
     161                 :            : 
     162                 :            : /* powers */
     163                 :            : GEN    rpowuu(ulong a, ulong n, long prec);
     164                 :            : ulong  u_pow10(int n);
     165                 :            : 
     166                 :            : /* floats */
     167                 :            : double dabs(double s, double t);
     168                 :            : void   dcxlog(double s, double t, double *a, double *b);
     169                 :            : double dnorm(double s, double t);
     170                 :            : double dbllog2(GEN z);
     171                 :            : 
     172                 :            : /* hnf */
     173                 :            : GEN hnfadd(GEN m,GEN p,GEN* ptdep,GEN* ptA,GEN* ptC,GEN extramat,GEN extraC);
     174                 :            : GEN hnfadd_i(GEN m,GEN p,GEN* ptdep,GEN* ptA,GEN* ptC,GEN extramat,GEN extraC);
     175                 :            : GEN hnfspec_i(GEN m,GEN p,GEN* ptdep,GEN* ptA,GEN* ptC,long k0);
     176                 :            : GEN hnfspec(GEN m,GEN p,GEN* ptdep,GEN* ptA,GEN* ptC,long k0);
     177                 :            : GEN mathnfspec(GEN x, GEN *ptperm, GEN *ptdep, GEN *ptB, GEN *ptC);
     178                 :            : GEN ZM_hnfmodall_i(GEN x, GEN dm, long flag);
     179                 :            : 
     180                 :            : GEN LLL_check_progress(GEN Bnorm, long n0, GEN m, int final, long *ti_LLL);
     181                 :            : GEN extendedgcd(GEN A);
     182                 :            : 
     183                 :            : /* miscellaneous linear algebra */
     184                 :            : GEN  imagecomplspec(GEN x, long *nlze);
     185                 :            : GEN  ZM_imagecomplspec(GEN x, long *nlze);
     186                 :            : GEN  dim1proj(GEN prh);
     187                 :            : GEN  detcyc(GEN cyc, long *L);
     188                 :            : 
     189                 :            : GEN merge_factor_i(GEN f, GEN g);
     190                 :            : 
     191                 :            : /* integer factorization / discrete log */
     192                 :            : GEN   coprime_part(GEN x, GEN f);
     193                 :            : ulong ucoprime_part(ulong x, ulong f);
     194                 :            : ulong is_kth_power(GEN x, ulong p, GEN *pt);
     195                 :            : GEN   mpqs(GEN N);
     196                 :            : ulong gcduodd(ulong x, ulong y);
     197                 :            : 
     198                 :            : /* Polynomials */
     199                 :            : /* a) Arithmetic/conversions */
     200                 :            : GEN  addmulXn(GEN x, GEN y, long d);
     201                 :            : GEN  addshiftpol(GEN x, GEN y, long d);
     202                 :            : GEN  lift_if_rational(GEN x);
     203                 :            : GEN  monomial(GEN a, long degpol, long v);
     204                 :            : GEN  monomialcopy(GEN a, long degpol, long v);
     205                 :            : GEN  mulmat_pol(GEN A, GEN x);
     206                 :            : GEN  ser2pol_i(GEN x, long lx);
     207                 :            : GEN  ser2rfrac_i(GEN x);
     208                 :            : GEN  shiftpol_i(GEN x, long v);
     209                 :            : GEN  swap_vars(GEN b0, long v);
     210                 :            : GEN  RgX_recipspec_shallow(GEN x, long l, long n);
     211                 :            : 
     212                 :            : /* b) Modular */
     213                 :            : GEN  bezout_lift_fact(GEN T, GEN Tmod, GEN p, long e);
     214                 :            : long F2x_split_Berlekamp(GEN *t);
     215                 :            : long Flx_split_Berlekamp(GEN *t, ulong p);
     216                 :            : long FpX_split_Berlekamp(GEN *t, GEN pp);
     217                 :            : long FqX_split_Berlekamp(GEN *t, GEN T, GEN p);
     218                 :            : GEN  FpX_quad_root(GEN x, GEN p, int unknown);
     219                 :            : GEN  FqX_split_all(GEN z, GEN T, GEN p);
     220                 :            : long FqX_split_by_degree(GEN *pz, GEN u, GEN T, GEN p);
     221                 :            : long FqX_split_deg1(GEN *pz, GEN u, GEN T, GEN p);
     222                 :            : GEN  FqX_split_roots(GEN z, GEN T, GEN p, GEN pol);
     223                 :            : GEN  polsym_gen(GEN P, GEN y0, long n, GEN T, GEN N);
     224                 :            : GEN  ZXQ_charpoly_sqf(GEN A, GEN B, long *lambda, long v);
     225                 :            : GEN  ZX_disc_all(GEN,ulong);
     226                 :            : GEN  ZX_resultant_all(GEN A, GEN B, GEN dB, ulong bound);
     227                 :            : GEN  ZX_ZXY_resultant_all(GEN A, GEN B, long *lambda, GEN *LPRS);
     228                 :            : GEN  RgXQ_minpoly_naive(GEN y, GEN P);
     229                 :            : GEN lift_intern(GEN x);
     230                 :            : 
     231                 :            : /* c) factorization */
     232                 :            : GEN chk_factors_get(GEN lt, GEN famod, GEN c, GEN T, GEN N);
     233                 :            : long cmbf_maxK(long nb);
     234                 :            : GEN ZX_DDF(GEN x);
     235                 :            : GEN fact_from_DDF(GEN fa, GEN e, long n);
     236                 :            : GEN initgaloisborne(GEN T, GEN dn, long prec, GEN *pL, GEN *pprep, GEN *pdis);
     237                 :            : GEN logmax_modulus_bound(GEN p);
     238                 :            : GEN polint_i(GEN xa, GEN ya, GEN x, long n, GEN *ptdy);
     239                 :            : GEN quicktrace(GEN x, GEN sym);
     240                 :            : GEN special_pivot(GEN x);
     241                 :            : GEN vandermondeinversemod(GEN L, GEN T, GEN den, GEN mod);
     242                 :            : GEN ZX_monic_factorpadic(GEN f, GEN p, long prec);
     243                 :            : 
     244                 :            : /* Finite fields */
     245                 :            : 
     246                 :            : enum { t_FF_FpXQ = 0, t_FF_Flxq = 1, t_FF_F2xq = 2 };
     247                 :            : GEN FF_ellinit(GEN E, GEN fg);
     248                 :            : GEN FF_elldata(GEN E, GEN fg);
     249                 :            : 
     250                 :            : /* Elliptic curves */
     251                 :            : /* common to Q and Rg */
     252                 :            : enum { R_PERIODS = 1, R_ETA, R_ROOTS, R_AB };
     253                 :            : 
     254                 :            : enum { Qp_ROOT = 1, Qp_TATE };
     255                 :            : enum { Q_GROUPGEN = 5, Q_GLOBALRED, Q_ROOTNO, Q_MINIMALMODEL };
     256                 :            : 
     257                 :            : /* common to Fp and Fq */
     258                 :            : enum { FF_CARD = 1, FF_GROUP, FF_GROUPGEN, FF_O };
     259                 :            : 
     260                 :            : /* for Buchall_param */
     261                 :            : enum { fupb_NONE, fupb_RELAT, fupb_LARGE, fupb_PRECI };
     262                 :            : 
     263                 :            : /* Allocation / gerepile */
     264                 :            : void   setdebugvar(long n);
     265                 :            : void   debug_stack(void);
     266                 :            : void   fill_stack(void);
     267                 :            : void   init_dalloc(void);
     268                 :            : double *dalloc(size_t n);
     269                 :            : void   minim_alloc(long n, double ***q, GEN *x, double **y,  double **z, double **v);
     270                 :            : int    pop_entree_block(entree *ep, long loc);
     271                 :            : int    pop_val_if_newer(entree *ep, long loc);
     272                 :            : 
     273                 :            : /* general printing */
     274                 :            : void print_errcontext(PariOUT *out, const char *msg, const char *s, const char *entry);
     275                 :            : void print_prefixed_text(PariOUT *out, const char *s, const char *prefix, const char *str);
     276                 :            : INLINE void
     277                 :         49 : print_text(const char *s) { print_prefixed_text(pariOut, s,NULL,NULL); }
     278                 :            : INLINE void
     279                 :       5369 : out_print_text(PariOUT *out, const char *s) { print_prefixed_text(out, s,NULL,NULL); }
     280                 :            : INLINE long
     281 [ +  + ][ +  + ]:     729273 : is_keyword_char(char c) { return (isalnum((int)c) || c=='_'); }
     282                 :            : 
     283                 :            : /* Interfaces (GP, etc.) */
     284                 :            : hashtable *hash_from_link(GEN e, GEN names, int use_stack);
     285                 :            : void gen_relink(GEN x, hashtable *table);
     286                 :            : entree* is_entry_intern(const char *s, entree **table, long *hash);
     287                 :            : entree* do_alias(entree *ep);
     288                 :            : char* get_sep(const char *t);
     289                 :            : long get_int(const char *s, long dflt);
     290                 :            : ulong get_uint(const char *s);
     291                 :            : int  gp_init_functions(void);
     292                 :            : void gp_initrc(pari_stack *p_A);
     293                 :            : 
     294                 :            : void pari_sigint(const char *s);
     295                 :            : pariFILE *pari_last_tmp_file(void);
     296                 :            : void* get_stack(double fraction, long min);
     297                 :            : void  init_graph(void);
     298                 :            : void  free_graph(void);
     299                 :            : void  initout(int initerr);
     300                 :            : void  resetout(int initerr);
     301                 :            : void  init_linewrap(long w);
     302                 :            : void  pari_kernel_init(void);
     303                 :            : void  pari_kernel_close(void);
     304                 :            : void  print_functions_hash(const char *s);
     305                 :            : void  print_all_user_fun(int member);
     306                 :            : GEN   readbin(const char *name, FILE *f, int *vector);
     307                 :            : int   term_height(void);
     308                 :            : int   term_width(void);
     309                 :            : void  whatnow_new_syntax(const char *f, long n);
     310                 :            : /* gp_colors */
     311                 :            : void decode_color(long n, long *c);
     312                 :            : 
     313                 :            : /* defaults */
     314                 :            : extern ulong precreal;
     315                 :            : 
     316                 :            : void lim_lines_output(char *s, long n, long max);
     317                 :            : int tex2mail_output(GEN z, long n);
     318                 :            : void gen_output(GEN x, pariout_t *T);
     319                 :            : void fputGEN_pariout(GEN x, pariout_t *T, FILE *out);
     320                 :            : 
     321                 :            : void parsestate_reset(void);
     322                 :            : void parsestate_save(struct pari_parsestate *state);
     323                 :            : void parsestate_restore(struct pari_parsestate *state);
     324                 :            : 
     325                 :            : void compilestate_reset(void);
     326                 :            : void compilestate_save(struct pari_compilestate *comp);
     327                 :            : void compilestate_restore(struct pari_compilestate *comp);
     328                 :            : 
     329                 :            : void evalstate_clone(void);
     330                 :            : void evalstate_reset(void);
     331                 :            : void evalstate_restore(struct pari_evalstate *state);
     332                 :            : GEN  evalstate_restore_err(struct pari_evalstate *state);
     333                 :            : void evalstate_save(struct pari_evalstate *state);
     334                 :            : 
     335                 :            : void mtstate_save(long *pending);
     336                 :            : void mtstate_reset(void);
     337                 :            : void mtstate_restore(long *pending);
     338                 :            : 
     339                 :            : void debug_context(void);
     340                 :            : 
     341                 :            : typedef struct {
     342                 :            :   const char *s;
     343                 :            :   size_t ls;
     344                 :            :   char **dir;
     345                 :            : } forpath_t;
     346                 :            : void forpath_init(forpath_t *T, gp_path *path, const char *s);
     347                 :            : char *forpath_next(forpath_t *T);
     348                 :            : 
     349                 :            : /* GP output && output format */
     350                 :            : void gpwritebin(const char *s, GEN x);
     351                 :            : extern char *current_logfile;
     352                 :            : 
     353                 :            : /* colors */
     354                 :            : extern long    gp_colors[];
     355                 :            : extern int     disable_color;
     356                 :            : 
     357                 :            : /* entrees */
     358                 :            : #define EpVALENCE(ep) ((ep)->valence & 0xFF)
     359                 :            : #define EpSTATIC(ep) ((ep)->valence & 0x100)
     360                 :            : #define EpSETSTATIC(ep) ((ep)->valence |= 0x100)
     361                 :            : enum { EpNEW = 100, EpALIAS, EpVAR, EpINSTALL };
     362                 :            : #define initial_value(ep) ((ep)+1)
     363                 :            : 
     364                 :            : /* functions lists */
     365                 :            : extern const long functions_tblsz;  /* hashcodes table size */
     366                 :            : extern entree **functions_hash;   /* functions hashtable */
     367                 :            : extern entree **defaults_hash;    /* defaults hashtable */
     368                 :            : extern entree oldfonctions[];
     369                 :            : 
     370                 :            : /* buffers */
     371                 :            : typedef struct Buffer {
     372                 :            :   char *buf;
     373                 :            :   ulong len;
     374                 :            :   jmp_buf env;
     375                 :            : } Buffer;
     376                 :            : Buffer *new_buffer(void);
     377                 :            : void delete_buffer(Buffer *b);
     378                 :            : void fix_buffer(Buffer *b, long newlbuf);
     379                 :            : 
     380                 :            : typedef struct {
     381                 :            :   const char *s; /* source */
     382                 :            :   char *t, *end; /* target, last char read */
     383                 :            :   int in_string, in_comment, more_input, wait_for_brace;
     384                 :            :   Buffer *buf;
     385                 :            : } filtre_t;
     386                 :            : void init_filtre(filtre_t *F, Buffer *buf);
     387                 :            : Buffer *filtered_buffer(filtre_t *F);
     388                 :            : const char *break_loop_prompt(long n);
     389                 :            : void kill_buffers_upto_including(Buffer *B);
     390                 :            : void pop_buffer(void);
     391                 :            : void kill_buffers_upto(Buffer *B);
     392                 :            : int gp_read_line(filtre_t *F, const char *PROMPT);
     393                 :            : void parse_key_val(char *src, char **ps, char **pt);
     394                 :            : void pari_init_buffers(void);
     395                 :            : extern int (*cb_pari_get_line_interactive)(const char*, const char*, filtre_t *F);
     396                 :            : extern char *(*cb_pari_fgets_interactive)(char *s, int n, FILE *f);
     397                 :            : int get_line_from_file(const char *prompt, filtre_t *F, FILE *file);
     398                 :            : void pari_skip_space(char **s);
     399                 :            : void pari_skip_alpha(char **s);
     400                 :            : char *pari_translate_string(const char *src, char *s, char *entry);
     401                 :            : 
     402                 :            : gp_data *default_gp_data(void);
     403                 :            : 
     404                 :            : void delete_dirs(gp_path *p);
     405                 :            : void gp_expand_path(gp_path *p);
     406                 :            : const char *pari_default_path(void);
     407                 :            : int path_is_absolute(char *s);
     408                 :            : 
     409                 :            : typedef struct input_method {
     410                 :            : /* mandatory */
     411                 :            :   char * (*fgets)(char *,int,FILE*);
     412                 :            :   char * (*getline)(char**, int f, struct input_method*, filtre_t *F);
     413                 :            :   int free; /* boolean: must we free the output of getline() ? */
     414                 :            : /* for interactive methods */
     415                 :            :   const char *prompt, *prompt_cont;
     416                 :            : /* for non-interactive methods */
     417                 :            :   FILE *file;
     418                 :            : } input_method;
     419                 :            : 
     420                 :            : int input_loop(filtre_t *F, input_method *IM);
     421                 :            : char *file_input(char **s0, int junk, input_method *IM, filtre_t *F);
     422                 :            : char *file_getline(Buffer *b, char **s0, input_method *IM);
     423                 :            : 
     424                 :            : /* By files */
     425                 :            : 
     426                 :            : /* Qfb.c */
     427                 :            : 
     428                 :            : GEN     redimagsl2(GEN q, GEN *U);
     429                 :            : GEN     redrealsl2(GEN V, GEN d, GEN rd);
     430                 :            : GEN     redrealsl2step(GEN A, GEN d, GEN rd);
     431                 :            : GEN     redtausl2(GEN t, GEN *U);
     432                 :            : 
     433                 :            : /* alglin1.c */
     434                 :            : typedef long (*pivot_fun)(GEN,GEN,long,GEN);
     435                 :            : GEN ZM_pivots(GEN x0, long *rr);
     436                 :            : GEN RgM_pivots(GEN x0, GEN data, long *rr, pivot_fun pivot);
     437                 :            : 
     438                 :            : /* arith1.c */
     439                 :            : 
     440                 :            : int     is_gener_Fp(GEN x, GEN p, GEN p_1, GEN L);
     441                 :            : int     is_gener_Fl(ulong x, ulong p, ulong p_1, GEN L);
     442                 :            : 
     443                 :            : /* arith2.c */
     444                 :            : 
     445                 :            : int     divisors_init(GEN n, GEN *pP, GEN *pE);
     446                 :            : long    set_optimize(long what, GEN g);
     447                 :            : 
     448                 :            : /* base2.c */
     449                 :            : 
     450                 :            : GEN     gen_if_principal(GEN bnf, GEN x);
     451                 :            : int     nfissquarefree(GEN nf, GEN x);
     452                 :            : GEN     polsymmodp(GEN g, GEN p);
     453                 :            : GEN     nfbasis_gp(GEN T);
     454                 :            : 
     455                 :            : /* base3.c */
     456                 :            : 
     457                 :            : void    check_nfelt(GEN x, GEN *den);
     458                 :            : GEN     zk_ei_mul(GEN nf, GEN x, long i);
     459                 :            : 
     460                 :            : /* base4.c */
     461                 :            : 
     462                 :            : void    check_listpr(GEN x);
     463                 :            : GEN     extideal_HNF_mul(GEN nf, GEN x, GEN y);
     464                 :            : GEN     factor_norm(GEN x);
     465                 :            : GEN     factorbackprime(GEN nf, GEN L, GEN e);
     466                 :            : long    val_norm(GEN x, GEN p, long *vz);
     467                 :            : 
     468                 :            : /* base5.c */
     469                 :            : 
     470                 :            : GEN     check_and_build_nfabs(GEN rnf);
     471                 :            : GEN     check_and_build_norms(GEN rnf);
     472                 :            : 
     473                 :            : /* buch1.c */
     474                 :            : 
     475                 :            : GEN     form_to_ideal(GEN x);
     476                 :            : GEN     qfbforms(GEN D);
     477                 :            : 
     478                 :            : /* buch2.c */
     479                 :            : 
     480                 :            : typedef struct GRHprime_t { ulong p; double logp; GEN dec; } GRHprime_t;
     481                 :            : typedef struct GRHcheck_t { double cD, cN; GRHprime_t *primes; long clone, nprimes, maxprimes; ulong limp; forprime_t P; } GRHcheck_t;
     482                 :            : void    free_GRHcheck(GRHcheck_t *S);
     483                 :            : void    init_GRHcheck(GRHcheck_t *S, long N, long R1, double LOGD);
     484                 :            : void    GRH_ensure(GRHcheck_t *S, long nb);
     485                 :            : ulong   GRH_last_prime(GRHcheck_t *S);
     486                 :            : int     GRHok(GRHcheck_t *S, double L, double SA, double SB);
     487                 :            : GEN     check_and_build_matal(GEN bnf);
     488                 :            : GEN     extract_full_lattice(GEN x);
     489                 :            : GEN     init_red_mod_units(GEN bnf, long prec);
     490                 :            : GEN     isprincipalarch(GEN bnf, GEN col, GEN kNx, GEN e, GEN dx, long *pe);
     491                 :            : GEN     red_mod_units(GEN col, GEN z);
     492                 :            : 
     493                 :            : /* buch3.c */
     494                 :            : 
     495                 :            : GEN     minkowski_bound(GEN D, long N, long r2, long prec);
     496                 :            : int     subgroup_conductor_ok(GEN H, GEN L);
     497                 :            : GEN     subgrouplist_cond_sub(GEN bnr, GEN C, GEN bound);
     498                 :            : 
     499                 :            : /* ellsea.c */
     500                 :            : 
     501                 :            : void    pari_close_seadata(void);
     502                 :            : void    pari_init_seadata(void);
     503                 :            : 
     504                 :            : /* es.c */
     505                 :            : 
     506                 :            : const char * eng_ord(long i);
     507                 :            : char *  env_ok(const char *s);
     508                 :            : void    filestate_restore(pariFILE *F);
     509                 :            : void    killallfiles(void);
     510                 :            : pariFILE* newfile(FILE *f, const char *name, int type);
     511                 :            : void    pari_init_homedir(void);
     512                 :            : void    pari_close_homedir(void);
     513                 :            : void    pari_init_files(void);
     514                 :            : void    pari_close_files(void);
     515                 :            : int     popinfile(void);
     516                 :            : pariFILE* try_pipe(const char *cmd, int flag);
     517                 :            : 
     518                 :            : /* Flxq_log.c */
     519                 :            : 
     520                 :            : GEN Flxq_log_index(GEN a0, GEN b0, GEN m, GEN T0, ulong p);
     521                 :            : 
     522                 :            : /* FlxqE.c */
     523                 :            : 
     524                 :            : GEN     ZpXQ_norm_pcyc(GEN x, GEN T, GEN q, GEN p);
     525                 :            : long    zx_is_pcyc(GEN T);
     526                 :            : 
     527                 :            : /* galconj.c */
     528                 :            : 
     529                 :            : GEN     galoiscosets(GEN O, GEN perm);
     530                 :            : long    intheadlong(GEN x, GEN mod);
     531                 :            : GEN     listznstarelts(long m, long p);
     532                 :            : GEN     matheadlong(GEN W, GEN mod);
     533                 :            : GEN     matrixnorm(GEN M, long prec);
     534                 :            : long    polheadlong(GEN P, long n, GEN mod);
     535                 :            : GEN     vandermondeinverseprep(GEN L);
     536                 :            : 
     537                 :            : /* galois.c */
     538                 :            : 
     539                 :            : GEN     polgaloisnamesbig(long n, long k);
     540                 :            : 
     541                 :            : /* gen1.c */
     542                 :            : 
     543                 :            : int     ff_poltype(GEN *x, GEN *p, GEN *pol);
     544                 :            : GEN     gred_frac2(GEN x1, GEN x2);
     545                 :            : GEN     gred_rfrac2(GEN x1, GEN x2);
     546                 :            : GEN     gred_rfrac_simple(GEN n, GEN d);
     547                 :            : GEN     sqr_ser_part(GEN x, long l1, long l2);
     548                 :            : 
     549                 :            : /* gen3.c */
     550                 :            : 
     551                 :            : GEN     gsubst_expr(GEN pol, GEN from, GEN to);
     552                 :            : GEN     poltoser(GEN x, long v, long prec);
     553                 :            : GEN     rfractoser(GEN x, long v, long prec);
     554                 :            : 
     555                 :            : /* hyperell.c */
     556                 :            : 
     557                 :            : GEN     ZlXQX_hyperellpadicfrobenius(GEN H, GEN T, ulong p, long n);
     558                 :            : 
     559                 :            : /* ifactor1.c */
     560                 :            : 
     561                 :            : GEN     ellfacteur(GEN n, int insist);
     562                 :            : GEN     pollardbrent(GEN n);
     563                 :            : ulong   snextpr(ulong p, byteptr *d, long *rcn, long *q, long k);
     564                 :            : GEN     squfof(GEN n);
     565                 :            : 
     566                 :            : /* prime.c */
     567                 :            : 
     568                 :            : long    BPSW_psp_nosmalldiv(GEN N);
     569                 :            : int     Fl_MR_Jaeschke(ulong n, long k);
     570                 :            : int     MR_Jaeschke(GEN n, long k);
     571                 :            : long    isanypower_nosmalldiv(GEN N, GEN *px);
     572                 :            : void    prime_table_next_p(ulong a, byteptr *pd, ulong *pp, ulong *pn);
     573                 :            : int     uisprime_101(ulong n);
     574                 :            : int     uisprime_661(ulong n);
     575                 :            : 
     576                 :            : /* init.c */
     577                 :            : 
     578                 :            : void    pari_init_defaults(void);
     579                 :            : 
     580                 :            : /* nffactor.c */
     581                 :            : 
     582                 :            : int     nfissplit(GEN nf, GEN x);
     583                 :            : 
     584                 :            : /* perm.c */
     585                 :            : 
     586                 :            : long    cosets_perm_search(GEN C, GEN p);
     587                 :            : GEN     group_export_GAP(GEN G);
     588                 :            : GEN     group_export_MAGMA(GEN G);
     589                 :            : GEN     perm_generate(GEN S, GEN H, long o);
     590                 :            : long    perm_relorder(GEN p, GEN S);
     591                 :            : GEN     perm_to_GAP(GEN p);
     592                 :            : 
     593                 :            : /* polarit1.c */
     594                 :            : 
     595                 :            : GEN     F2x_Berlekamp_ker(GEN u);
     596                 :            : GEN     Flx_Berlekamp_ker(GEN u, ulong p);
     597                 :            : GEN     FpX_Berlekamp_ker(GEN u, GEN p);
     598                 :            : GEN     FlxqX_Berlekamp_ker(GEN u, GEN T, ulong p);
     599                 :            : GEN     FpXQX_Berlekamp_ker(GEN u, GEN T, GEN p);
     600                 :            : GEN     F2x_factcantor(GEN f, long flag);
     601                 :            : GEN     Flx_factcantor(GEN f, ulong p, long flag);
     602                 :            : GEN     FpX_factcantor(GEN f, GEN pp, long flag);
     603                 :            : GEN     FqX_rand(long d1, long v, GEN T, GEN p);
     604                 :            : int     cmp_padic(GEN x, GEN y);
     605                 :            : GEN     factcantor0(GEN f, GEN pp, long flag);
     606                 :            : 
     607                 :            : /* polarit2.c */
     608                 :            : 
     609                 :            : GEN     sylvestermatrix_i(GEN x, GEN y);
     610                 :            : 
     611                 :            : /* QX_factor */
     612                 :            : 
     613                 :            : void    factor_quad(GEN x, GEN res, long *ptcnt);
     614                 :            : 
     615                 :            : /* FpX.c */
     616                 :            : 
     617                 :            : GEN     FpX_gcd_check(GEN x, GEN y, GEN p);
     618                 :            : 
     619                 :            : /* polarit3.c */
     620                 :            : 
     621                 :            : GEN     Flm_Frobenius_pow(GEN M, long d, GEN T, ulong p);
     622                 :            : GEN     FpM_Frobenius_pow(GEN M, long d, GEN T, GEN p);
     623                 :            : GEN     FpX_compositum(GEN A, GEN B, GEN p);
     624                 :            : GEN     FpX_direct_compositum(GEN A, GEN B, GEN p);
     625                 :            : ulong   ZX_ZXY_ResBound(GEN A, GEN B, GEN dB);
     626                 :            : GEN     ffinit_Artin_Shreier(GEN ip, long l);
     627                 :            : GEN     ffinit_rand(GEN p, long n);
     628                 :            : void    init_modular(forprime_t *S);
     629                 :            : GEN     polint_triv(GEN xa, GEN ya);
     630                 :            : 
     631                 :            : /* random.c */
     632                 :            : 
     633                 :            : void    pari_init_rand(void);
     634                 :            : 
     635                 :            : /* rootpol.c */
     636                 :            : 
     637                 :            : GEN     FFT(GEN x, GEN Omega);
     638                 :            : GEN     FFTinit(long k, long prec);
     639                 :            : 
     640                 :            : /* subcyclo.c */
     641                 :            : 
     642                 :            : GEN     bnr_to_znstar(GEN bnr, long *complex);
     643                 :            : GEN     galoiscyclo(long n, long v);
     644                 :            : GEN     znstar_bits(long n, GEN H);
     645                 :            : long    znstar_conductor(long n, GEN H);
     646                 :            : GEN     znstar_cosets(long n, long phi_n, GEN H);
     647                 :            : GEN     znstar_elts(long n, GEN H);
     648                 :            : GEN     znstar_generate(long n, GEN V);
     649                 :            : GEN     znstar_hnf(GEN Z, GEN M);
     650                 :            : GEN     znstar_hnf_elts(GEN Z, GEN H);
     651                 :            : GEN     znstar_hnf_generators(GEN Z, GEN M);
     652                 :            : GEN     znstar_reduce_modulus(GEN H, long n);
     653                 :            : GEN     znstar_small(GEN zn);
     654                 :            : 
     655                 :            : /* trans1.c */
     656                 :            : 
     657                 :            : GEN     logagmcx(GEN q, long prec);
     658                 :            : void    pari_init_floats(void);
     659                 :            : void    pari_close_floats(void);
     660                 :            : GEN     rootsof1complex(GEN n, long prec);
     661                 :            : GEN     rootsof1padic(GEN n, GEN y);
     662                 :            : GEN     zellagmcx(GEN a0, GEN b0, GEN r, GEN t, long prec);
     663                 :            : 
     664                 :            : /* trans2.c */
     665                 :            : 
     666                 :            : GEN     cxpsi(GEN s0, long prec);
     667                 :            : double  darg(double s, double t);
     668                 :            : 
     669                 :            : /* trans3.c */
     670                 :            : 
     671                 :            : GEN     bernreal_using_zeta(long n, GEN iz, long prec);
     672                 :            : GEN     czeta(GEN s0, long prec);
     673                 :            : GEN     double_eta_quotient(GEN a, GEN w, GEN D, long p, long q, GEN pq, GEN sqrtD);
     674                 :            : GEN     inv_szeta_euler(long n, double lba, long prec);
     675                 :            : GEN     polylogd0(long m, GEN x, long flag, long prec);
     676                 :            : GEN     trueE2(GEN tau, long prec);
     677                 :            : GEN     twistpartialzeta(GEN q, long f, long c, GEN va, GEN cff);
     678                 :            : 
     679                 :            : ENDEXTERN

Generated by: LCOV version 1.9