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 - language - compat.c (source / functions) Hit Total Coverage
Test: PARI/GP v2.8.0 lcov report (development 17072-bc6ca01) Lines: 0 60 0.0 %
Date: 2014-11-17 Functions: 0 29 0.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 35 0.0 %

           Branch data     Line data    Source code
       1                 :            : /* Copyright (C) 2000  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                 :            : #include "anal.h"
      17                 :            : static long
      18                 :          0 : nfbasis_flag_translate(long flag)
      19                 :            : {
      20   [ #  #  #  #  :          0 :   switch(flag) {
                      # ]
      21                 :          0 :     case 0: return 0;
      22                 :          0 :     case 1: return nf_PARTIALFACT;
      23                 :          0 :     case 2: return nf_ROUND2;
      24                 :          0 :     case 3: return nf_ROUND2|nf_PARTIALFACT;
      25                 :          0 :     default: pari_err_FLAG("nfbasis");
      26                 :          0 :              return 0;
      27                 :            :   }
      28                 :            : }
      29                 :            : static GEN
      30                 :          0 : nfbasis0(GEN x, long flag, GEN fa)
      31                 :            : {
      32                 :          0 :   pari_sp av = avma;
      33                 :            :   nfmaxord_t S;
      34                 :            :   GEN B;
      35         [ #  # ]:          0 :   nfmaxord(&S, fa? mkvec2(x,fa): x, nfbasis_flag_translate(flag));
      36                 :          0 :   B = RgXV_unscale(S.basis, S.unscale);
      37                 :          0 :   return gerepilecopy(av, B);
      38                 :            : }
      39                 :            : static  GEN
      40                 :          0 : nfdisc0(GEN x, long flag, GEN fa)
      41                 :            : {
      42                 :          0 :   pari_sp av = avma;
      43                 :            :   nfmaxord_t S;
      44         [ #  # ]:          0 :   nfmaxord(&S, fa? mkvec2(x,fa): x, nfbasis_flag_translate(flag));
      45                 :          0 :   return gerepilecopy(av, S.dK);
      46                 :            : }
      47                 :            : static GEN
      48                 :          0 : factorpadic0(GEN f,GEN p,long r,long flag)
      49                 :            : {
      50         [ #  # ]:          0 :   if (typ(f)!=t_POL) pari_err_TYPE("factorpadic",f);
      51         [ #  # ]:          0 :   if (typ(p)!=t_INT) pari_err_TYPE("factorpadic",p);
      52         [ #  # ]:          0 :   if (!signe(f)) return prime_fact(f);
      53         [ #  # ]:          0 :   if (r <= 0)
      54                 :          0 :     pari_err_DOMAIN("factorpadic", "precision", "<=",gen_0,stoi(r));
      55         [ #  # ]:          0 :   switch(flag)
      56                 :            :   {
      57                 :            :     case 0: case 1:
      58                 :          0 :        return factorpadic(f,p,r);
      59                 :          0 :      default: pari_err_FLAG("factorpadic");
      60                 :            :   }
      61                 :          0 :   return NULL; /* not reached */
      62                 :            : }
      63                 :            : static GEN
      64                 :          0 : ghell2(GEN e, GEN a, long prec) { return ellheight(e,a,prec); }
      65                 :            : 
      66                 :            : static GEN
      67                 :          0 : polylogd(long m, GEN x, long prec) { return polylog0(m,x,1,prec); }
      68                 :            : 
      69                 :            : static GEN
      70                 :          0 : polylogdold(long m, GEN x, long prec) { return polylog0(m,x,2,prec); }
      71                 :            : 
      72                 :            : static GEN
      73                 :          0 : polylogp(long m, GEN x, long prec) { return polylog0(m,x,3,prec); }
      74                 :            : 
      75                 :            : static GEN
      76                 :          0 : prod0(GEN x, GEN a, GEN b, GEN ch) {return produit(a,b,ch,x);}
      77                 :            : 
      78                 :            : static GEN
      79                 :          0 : sum0(GEN x, GEN a, GEN b, GEN ch) {return somme(a,b,ch,x);}
      80                 :            : 
      81                 :            : static long
      82                 :          0 : sturm0(GEN x) {return sturm(x);}
      83                 :            : 
      84                 :            : static GEN
      85                 :          0 : sigmak0(long k, GEN x) {return sumdivk(x,k);}
      86                 :            : 
      87                 :            : static GEN
      88                 :          0 : lseriesell0(GEN a, GEN b, GEN c, GEN d, long prec)
      89                 :          0 :   {(void)c; return elllseries(a,b,d,prec);}
      90                 :            : 
      91                 :            : static GEN
      92                 :          0 : weipell(GEN e, long precdl) { return ellwpseries(e,0,precdl); }
      93                 :            : 
      94                 :            : static long
      95                 :          0 : rounderror(GEN x)
      96                 :            : {
      97                 :          0 :   pari_sp av = avma;
      98                 :          0 :   long e; (void)grndtoi(x,&e);
      99                 :          0 :   avma = av; return (long)(e*LOG10_2);
     100                 :            : }
     101                 :            : 
     102                 :            : static GEN
     103                 :          0 : _factpol(GEN x, long t/*unused*/, long hint/*unused*/) {
     104                 :          0 :   (void)t; (void)hint; return QX_factor(x);
     105                 :            : }
     106                 :            : 
     107                 :            : static void
     108                 :          0 : suppressed(void) {pari_err(e_MISC,"this function no longer exists");}
     109                 :            : 
     110                 :            : #define BUCH_PROTO "GDGDGD5,G,D1,G,D4,L,D3,L,p"
     111                 :            : #define B_ARGS GEN g1,GEN g2,GEN g3,GEN g4,GEN g5,long l1,long l2,long prec
     112                 :            : #define B_ARG1 g1,gtodouble(g2),gtodouble(g3),l1
     113                 :            : #define B_CALL(flag) Buchall_param(B_ARG1,(flag),prec)
     114                 :            : #define B_UNUSED (void)g4,(void)g5,(void)l2
     115                 :            : 
     116                 :            : #define B_DEFAULT if (!g2) g2 = dbltor(.3); \
     117                 :            :                   if (!g3) g3 = dbltor(.3)
     118                 :            : 
     119                 :            : #define CLASSUNIT(flag) do { \
     120                 :            :   pari_sp av = avma; \
     121                 :            :   GEN bnf = B_CALL(flag), nf = bnf_get_nf(bnf), x; \
     122                 :            :   B_UNUSED; \
     123                 :            :   x = mkvec4(gel(nf,1), gel(nf,2), mkvec2(gel(nf,3), gel(nf,4)), gel(nf,7));\
     124                 :            :   return gerepilecopy(av, mkmat(shallowconcat(x, gel(bnf,8)))); } while(0)
     125                 :            : 
     126                 :            : static GEN
     127 [ #  # ][ #  # ]:          0 : buchgenfu(B_ARGS) { B_DEFAULT; CLASSUNIT(0); }
     128                 :            : static GEN
     129 [ #  # ][ #  # ]:          0 : buchgenforcefu(B_ARGS) { B_DEFAULT; CLASSUNIT(nf_FORCE); }
     130                 :            : static GEN
     131 [ #  # ][ #  # ]:          0 : buchinitfu(B_ARGS) { B_DEFAULT; B_UNUSED; return B_CALL(0); }
     132                 :            : static GEN
     133 [ #  # ][ #  # ]:          0 : buchinitforcefu(B_ARGS) { B_DEFAULT; B_UNUSED; return B_CALL(nf_FORCE); }
     134                 :            : static GEN
     135                 :          0 : smallbuchinit(B_ARGS) { (void)g2,(void)g3,(void)l1,B_UNUSED; return bnfcompress(Buchall(g1, 0, prec)); }
     136                 :            : static GEN
     137                 :          0 : factoredbase(GEN x, GEN fa) { return nfbasis0(x, 0, fa); }
     138                 :            : static GEN
     139                 :          0 : factoreddiscf(GEN x, GEN fa) { return nfdisc0(x, 0, fa); }
     140                 :            : static GEN
     141                 :          0 : buchfu(GEN bnf) { return bnf_get_fu_nocheck(checkbnf(bnf)); }
     142                 :            : static GEN
     143                 :          0 : buchrayinitgen(GEN bnf, GEN ideal)
     144                 :          0 : { return Buchray(bnf,ideal, nf_INIT | nf_GEN); }
     145                 :            : static GEN
     146                 :          0 : buchrayinit(GEN bnf, GEN ideal)
     147                 :          0 : { return Buchray(bnf,ideal, nf_INIT); }
     148                 :            : static GEN
     149                 :          0 : buchray(GEN bnf, GEN ideal)
     150                 :          0 : { return Buchray(bnf,ideal, nf_GEN); }
     151                 :            : static GEN
     152                 :          0 : principalideal(GEN nf, GEN x) { return algtobasis(nf,x); }
     153                 :            : 
     154                 :            : entree oldfonctions[]={
     155                 :            : {"!_",0,(void*)gnot,13,"G","!_"},
     156                 :            : {"#_",0,(void*)glength,13,"lG","length(x): number of non code words in x, number of characters for a string."},
     157                 :            : {"%",0,(void*)pari_get_hist,1,"D0,L,","last history item"},
     158                 :            : {"+_",0,NULL,13,NULL,"+_"},
     159                 :            : {"-_",0,(void*)gneg,13,"G","-_"},
     160                 :            : {"_!",0,(void*)mpfact,13,"L","_!"},
     161                 :            : {"_!=_",0,(void*)gne,13,"GG","_!=_"},
     162                 :            : {"_%=_",0,(void*)gmode,13,"&G","_%=_"},
     163                 :            : {"_%_",0,(void*)gmod,13,"GG","_%_"},
     164                 :            : {"_&&_",0,(void*)andpari,13,"GE","_&&_"},
     165                 :            : {"_'",0,(void*)deriv,13,"GDn","_'"},
     166                 :            : {"_*=_",0,(void*)gmule,13,"&G","x*=y: shortcut for x=x*y."},
     167                 :            : {"_*_",0,(void*)gmul,13,"GG","_*_"},
     168                 :            : {"_++",0,(void*)gadd1e,13,"&","x++"},
     169                 :            : {"_+=_",0,(void*)gadde,13,"&G","x+=y: shortcut for x=x+y."},
     170                 :            : {"_+_",0,(void*)gadd,13,"GG","x+y: sum of x and y."},
     171                 :            : {"_--",0,(void*)gsub1e,13,"&","x--"},
     172                 :            : {"_-=_",0,(void*)gsube,13,"&G","x-=y"},
     173                 :            : {"_-_",0,(void*)gsub,13,"GG","x-y: difference of x and y."},
     174                 :            : {"_.a1",0,(void*)member_a1,14,"G","_.a1"},
     175                 :            : {"_.a2",0,(void*)member_a2,14,"G","_.a2"},
     176                 :            : {"_.a3",0,(void*)member_a3,14,"G","_.a3"},
     177                 :            : {"_.a4",0,(void*)member_a4,14,"G","_.a4"},
     178                 :            : {"_.a6",0,(void*)member_a6,14,"G","_.a6"},
     179                 :            : {"_.area",0,(void*)member_area,14,"G","_.area"},
     180                 :            : {"_.b2",0,(void*)member_b2,14,"G","_.b2"},
     181                 :            : {"_.b4",0,(void*)member_b4,14,"G","_.b4"},
     182                 :            : {"_.b6",0,(void*)member_b6,14,"G","_.b6"},
     183                 :            : {"_.b8",0,(void*)member_b8,14,"G","_.b8"},
     184                 :            : {"_.bid",0,(void*)member_bid,14,"G","_.bid"},
     185                 :            : {"_.bnf",0,(void*)member_bnf,14,"G","_.bnf"},
     186                 :            : {"_.c4",0,(void*)member_c4,14,"G","_.c4"},
     187                 :            : {"_.c6",0,(void*)member_c6,14,"G","_.c6"},
     188                 :            : {"_.clgp",0,(void*)member_clgp,14,"G","_.clgp"},
     189                 :            : {"_.codiff",0,(void*)member_codiff,14,"G","_.codiff"},
     190                 :            : {"_.cyc",0,(void*)member_cyc,14,"G","_.cyc"},
     191                 :            : {"_.diff",0,(void*)member_diff,14,"G","_.diff"},
     192                 :            : {"_.disc",0,(void*)member_disc,14,"G","_.disc"},
     193                 :            : {"_.e",0,(void*)member_e,14,"G","_.e"},
     194                 :            : {"_.eta",0,(void*)member_eta,14,"G","_.eta"},
     195                 :            : {"_.f",0,(void*)member_f,14,"G","_.f"},
     196                 :            : {"_.fu",0,(void*)member_fu,14,"G","_.fu"},
     197                 :            : {"_.futu",0,(void*)member_futu,14,"G","_.futu"},
     198                 :            : {"_.gen",0,(void*)member_gen,14,"G","_.gen"},
     199                 :            : {"_.group",0,(void*)member_group,14,"G","_.group"},
     200                 :            : {"_.index",0,(void*)member_index,14,"G","_.index"},
     201                 :            : {"_.j",0,(void*)member_j,14,"G","_.j"},
     202                 :            : {"_.mod",0,(void*)member_mod,14,"G","_.mod"},
     203                 :            : {"_.nf",0,(void*)member_nf,14,"G","_.nf"},
     204                 :            : {"_.no",0,(void*)member_no,14,"G","_.no"},
     205                 :            : {"_.omega",0,(void*)member_omega,14,"G","_.omega"},
     206                 :            : {"_.orders",0,(void*)member_orders,14,"G","_.orders"},
     207                 :            : {"_.p",0,(void*)member_p,14,"G","_.p"},
     208                 :            : {"_.pol",0,(void*)member_pol,14,"G","_.pol"},
     209                 :            : {"_.r1",0,(void*)member_r1,14,"G","_.r1"},
     210                 :            : {"_.r2",0,(void*)member_r2,14,"G","_.r2"},
     211                 :            : {"_.reg",0,(void*)member_reg,14,"G","_.reg"},
     212                 :            : {"_.roots",0,(void*)member_roots,14,"G","_.roots"},
     213                 :            : {"_.sign",0,(void*)member_sign,14,"G","_.sign"},
     214                 :            : {"_.t2",0,(void*)member_t2,14,"G","_.t2"},
     215                 :            : {"_.tate",0,(void*)member_tate,14,"G","_.tate"},
     216                 :            : {"_.tu",0,(void*)member_tu,14,"G","_.tu"},
     217                 :            : {"_.tufu",0,(void*)member_tufu,14,"G","_.tufu"},
     218                 :            : {"_.zk",0,(void*)member_zk,14,"G","_.zk"},
     219                 :            : {"_.zkst",0,(void*)member_zkst,14,"G","_.zkst"},
     220                 :            : {"_/=_",0,(void*)gdive,13,"&G","x/=y"},
     221                 :            : {"_/_",0,(void*)gdiv,13,"GG","_/_"},
     222                 :            : {"_<<=_",0,(void*)gshiftle,13,"&L","x<<=y"},
     223                 :            : {"_<<_",0,(void*)gshift,13,"GL","x<<y"},
     224                 :            : {"_<=_",0,(void*)gle,13,"GG","_<=_"},
     225                 :            : {"_<_",0,(void*)glt,13,"GG","_<_"},
     226                 :            : {"_==_",0,(void*)geq,13,"GG","_==_"},
     227                 :            : {"_>=_",0,(void*)gge,13,"GG","_>=_"},
     228                 :            : {"_>>=_",0,(void*)gshiftre,13,"&L","_>>=_"},
     229                 :            : {"_>>_",0,(void*)gshift_right,13,"GL","x>>y"},
     230                 :            : {"_>_",0,(void*)ggt,13,"GG","_>_"},
     231                 :            : {"_[_.._,_.._]",0,(void*)matslice0,13,"GD0,L,D0,L,D0,L,D0,L,","x[a..b,c..d] = [x[a,c],  x[a+1,c],  ...,x[b,c];                      x[a,c+1],x[a+1,c+1],...,x[b,c+1];                        ...       ...          ...                      x[a,d],  x[a+1,d]  ,...,x[b,d]]"},
     232                 :            : {"_[_.._]",0,(void*)vecslice0,13,"GD0,L,L","x[a..b] = [x[a],x[a+1],...,x[b]]"},
     233                 :            : {"_\\/=_",0,(void*)gdivrounde,13,"&G","x\\\\/=y"},
     234                 :            : {"_\\/_",0,(void*)gdivround,13,"GG","x\\\\/y: rounded Euclidean quotient of x and y."},
     235                 :            : {"_\\=_",0,(void*)gdivente,13,"&G","x\\\\=y"},
     236                 :            : {"_\\_",0,(void*)gdivent,13,"GG","x\\\\y: Euclidean quotient of x and y."},
     237                 :            : {"_^_",0,(void*)gpow,13,"GGp","_^_"},
     238                 :            : {"_^s",0,(void*)gpowgs,13,"GL","_^s"},
     239                 :            : {"__",0,NULL,13,NULL,"__"},
     240                 :            : {"_derivfun",0,(void*)derivfun0,15,"GGp","_derivfun(closure,[args]) numerical derivation of closure with respect to the first variable at (args)."},
     241                 :            : {"_eval_mnemonic",0,(void*)eval_mnemonic,15,"lGs","Convert a mnemonic string to a flag."},
     242                 :            : {"_multi_if",0,(void*)ifpari_multi,15,"GE*","internal variant of if() that allows more than 3 arguments."},
     243                 :            : {"_void_if",0,(void*)ifpari_void,11,"vGDIDI","internal variant of if() that does not return a value."},
     244                 :            : {"_||_",0,(void*)orpari,13,"GE","x||y"},
     245                 :            : {"_~",0,(void*)gtrans,13,"G","_~"},
     246                 :            : {"O",0,(void*)ggrando,7,"GD1,L,","O(a^b): p-adic or power series zero with precision given by b."},
     247                 :            : {"O(_^_)",0,(void*)ggrando,7,"GD1,L,","O(a^b): p-adic or power series zero with precision given by b."},
     248                 :            : {"Str",0,(void*)Str,2,"s*","Str({x}*): concatenates its (string) argument into a single string."},
     249                 :            : {"abs",1,(void*)gabs,3,"Gp","abs(x)=absolute value (or modulus) of x."},
     250                 :            : {"acos",1,(void*)gacos,3,"Gp","acos(x)=inverse cosine of x."},
     251                 :            : {"acosh",1,(void*)gacosh,3,"Gp","acosh(x)=inverse hyperbolic cosine of x."},
     252                 :            : {"addell",3,(void*)elladd,5,"GGG","addell(e,z1,z2)=sum of the points z1 and z2 on elliptic curve e."},
     253                 :            : {"addprimes",1,(void*)addprimes,4,"G","addprimes(x)=add primes in the vector x (with at most 20 components) to the prime table."},
     254                 :            : {"adj",1,(void*)adj,8,"G","adj(x)=adjoint matrix of x."},
     255                 :            : {"agm",2,(void*)agm,3,"GGp","agm(x,y)=arithmetic-geometric mean of x and y."},
     256                 :            : {"akell",2,(void*)akell,5,"GG","akell(e,n)=computes the n-th Fourier coefficient of the L-function of the elliptic curve e."},
     257                 :            : {"algdep",23,(void*)algdep,8,"GL","algdep(x,n)=algebraic relations up to degree n of x."},
     258                 :            : {"algdep2",33,(void*)algdep0,8,"GLL","algdep2(x,n,dec)=algebraic relations up to degree n of x where dec is as in  lindep2."},
     259                 :            : {"algtobasis",2,(void*)algtobasis,6,"GG","algtobasis(nf,x)=transforms the algebraic number x into a column vector on the integral basis nf[7]."},
     260                 :            : {"anell",23,(void*)anell,5,"GL","anell(e,n)=computes the first n Fourier coefficients of the L-function of the elliptic curve e (n<32768)."},
     261                 :            : {"apell",2,(void*)ellap,5,"GG","apell(e,p)=computes a_p for the elliptic curve e using Shanks-Mestre's method."},
     262                 :            : {"apell2",2,(void*)ellap,5,"GG","apell2(e,p)=apell(e,p)."},
     263                 :            : {"apprpadic",2,(void*)padicappr,7,"GG","apprpadic(x,a)=p-adic roots of the polynomial x congruent to a mod p."},
     264                 :            : {"arg",1,(void*)garg,3,"Gp","arg(x)=argument of x,such that -pi<arg(x)<=pi."},
     265                 :            : {"asin",1,(void*)gasin,3,"Gp","asin(x)=inverse sine of x."},
     266                 :            : {"asinh",1,(void*)gasinh,3,"Gp","asinh(x)=inverse hyperbolic sine of x."},
     267                 :            : {"assmat",1,(void*)matcompanion,8,"G","matcompanion(x)=associated matrix to polynomial x."},
     268                 :            : {"atan",1,(void*)gatan,3,"Gp","atan(x)=inverse tangent of x."},
     269                 :            : {"atanh",1,(void*)gatanh,3,"Gp","atanh(x)=inverse hyperbolic tangent of x."},
     270                 :            : {"basis",13,(void*)nfbasis0,6,"GD0,L,DG","basis(x)=integral basis of the field Q[a], where a is a root of the polynomial x, using the round 4 algorithm."},
     271                 :            : {"basis2",13,(void*)nfbasis0,6,"GD2,L,DG","basis2(x)=integral basis of the field Q[a], where a is a root of the polynomial x, using the round 2 algorithm."},
     272                 :            : {"basistoalg",2,(void*)basistoalg,6,"GG","basistoalg(nf,x)=transforms the vertical vector x on the integral basis into an algebraic number."},
     273                 :            : {"bernreal",11,(void*)bernreal,3,"Lp","bernreal(x)=Bernoulli number B_x, as a real number with the current precision."},
     274                 :            : {"bernvec",11,(void*)bernvec,3,"L","bernvec(x)=Vector of rational Bernoulli numbers B_0, B_2,... up to B_(2x)."},
     275                 :            : {"bestappr",2,(void*)bestappr,4,"GGp","bestappr(x,k)=gives the best approximation to the real x with denominator less or equal to k."},
     276                 :            : {"bezout",2,(void*)gcdext0,4,"GG","bezout(x,y)=gives a 3-dimensional row vector [u,v,d] such that d=gcd(x,y) and u*x+v*y=d."},
     277                 :            : {"bezoutres",2,(void*)polresultantext,4,"GG","bezoutres(x,y)=gives a 3-dimensional row vector [u,v,d] such that d=resultant(x,y) and u*x+v*y=d, where x and y are polynomials."},
     278                 :            : {"bigomega",1,(void*)bigomega,4,"lG","bigomega(x)=number of repeated prime divisors of x."},
     279                 :            : {"bilhell",3,(void*)bilhell,5,"GGGp","bilhell(e,z1,z2)=canonical bilinear form for the points z1,z2 on the elliptic curve e. Either z1 or z2 can also be a vector/matrix of points."},
     280                 :            : {"bin",21,(void*)binomial,4,"GL","bin(x,y)=binomial coefficient x*(x-1)...*(x-y+1)/y! defined for y in Z and any x."},
     281                 :            : {"binary",1,(void*)binaire,2,"G","binary(x)=gives the vector formed by the binary digits of x (x C-integer)."},
     282                 :            : {"bittest",2,(void*)gbittest,2,"GL","bittest(x,n)=gives bit number n (coefficient of 2^n) of the integer x."},
     283                 :            : {"boundcf",21,(void*)gboundcf,4,"GL","boundcf(x,lmax)=continued fraction expansion of x with at most lmax terms."},
     284                 :            : {"boundfact",21,(void*)boundfact,4,"GL","boundfact(x,lim)=partial factorization of the integer x (using primes up to lim)."},
     285                 :            : {"buchcertify",10,(void*)bnfcertify,6,"lG","buchcertify(bnf)=certify the correctness (i.e. remove the GRH) of the bnf data output by buchinit or buchinitfu."},
     286                 :            : {"buchfu",1,(void*)buchfu,6,"Gp","buchfu(bnf)=compute the fundamental units of the number field bnf output by buchinit."},
     287                 :            : {"buchgen",99,(void*)buchgenfu,6,BUCH_PROTO,"buchgen(P,...)=compute the structure of the class group and the regulator for the number field defined by the polynomial P. See manual for the other parameters (which can be omitted)."},
     288                 :            : {"buchgenforcefu",99,(void*)buchgenforcefu,6,BUCH_PROTO,"buchgenforcefu(P,...)=compute the structure of the class group, the regulator a primitive root of unity and a system of fundamental units for the number field defined by the polynomial P, and insist until the units are obtained. See manual for the other parameters (which can be omitted)."},
     289                 :            : {"buchgenfu",99,(void*)buchgenfu,6,BUCH_PROTO,"buchgenfu(P,...)=compute the structure of the class group, the regulator a primitive root of unity and a system of fundamental units (if they are not too large) for the number field defined by the polynomial P. See manual for the other parameters (which can be omitted)."},
     290                 :            : {"buchimag",99,(void*)buchimag,4,"GD0.1,G,D0.1,G,D5,G,","buchimag(D,...)=compute the structure of the class group of the complex quadratic field of discriminant D<0. See manual for the other parameters (which can be omitted)."},
     291                 :            : {"buchinit",99,(void*)buchinitfu,6,BUCH_PROTO,"buchinit(P,...)=compute the necessary data for future use in ideal and unit group computations. See manual for details."},
     292                 :            : {"buchinitforcefu",99,(void*)buchinitforcefu,6,BUCH_PROTO,"buchinitforcefu(P,...)=compute the necessary data for future use in ideal and unit group computations, and insist on having fundamental units. See manual for details."},
     293                 :            : {"buchinitfu",99,(void*)buchinitfu,6,BUCH_PROTO,"buchinitfu(P,...)=compute the necessary data for future use in ideal and unit group computations, including fundamental units if they are not too large. See manual for details."},
     294                 :            : {"buchnarrow",1,(void*)buchnarrow,6,"Gp","buchnarrow(bnf)=given a big number field as output by buchinitxx, gives as a 3-component vector the structure of the narrow class group."},
     295                 :            : {"buchray",2,(void*)buchray,6,"GGp","buchray(bnf,ideal)=given a big number field as output by buchinitfu (only) and  an ideal or a 2-component row vector formed by an ideal and a list of R1 zeros or ones representing a module, finds the ray class group structure corresponding to this module."},
     296                 :            : {"buchrayinit",2,(void*)buchrayinit,6,"GGp","buchrayinit(bnf,ideal)=same as buchrayinitgen, except that the generators are not explicitly computed."},
     297                 :            : {"buchrayinitgen",2,(void*)buchrayinitgen,6,"GGp","buchrayinitgen(bnf,ideal)=given a big number field as output by buchinitfu (only) and  an ideal or a 2-component row vector formed by an ideal and a list of R1 zeros or ones representing a module, initializes data for computing in the ray class group  corresponding to this module. In particular, the fifth component is the ray class group structure."},
     298                 :            : {"buchreal",97,(void*)buchreal,4,"GD0,G,D0.1,G,D0.1,G,D5,G,p","buchreal(D,...)=compute the structure of the class group and the regulator of the real quadratic field of discriminant D>0 in the wide sense. See manual for the other parameters (which can be omitted)."},
     299                 :            : {"bytesize",10,(void*)gsizebyte,2,"lG","bytesize(x)=number of bytes occupied by the complete tree of the object x."},
     300                 :            : {"ceil",1,(void*)gceil,2,"G","ceil(x)=ceiling of x=smallest integer>=x."},
     301                 :            : {"centerlift",1,(void*)centerlift,2,"G","centerlift(x)=centered lift of x. Same as lift except for integermods."},
     302                 :            : {"cf",1,(void*)gcf,4,"Gp","cf(x)=continued fraction expansion of x (x rational,real or rational function)."},
     303                 :            : {"cf2",2,(void*)gcf2,4,"GGp","cf2(b,x)=continued fraction expansion of x (x rational,real or rational function), where b is the vector of numerators of the continued fraction."},
     304                 :            : {"changevar",0,(void*)suppressed,11,"GG","changevar(x,y)=THIS FUNCTION HAS BEEN SUPPRESSED."},
     305                 :            : {"char",14,(void*)caradj,8,"GnD&","char(x,y)=det(y*I-x)=characteristic polynomial of the matrix x using the comatrix."},
     306                 :            : {"char1",14,(void*)caract,8,"Gn","char1(x,y)=det(y*I-x)=characteristic polynomial of the matrix x using Lagrange interpolation."},
     307                 :            : {"char2",14,(void*)carhess,8,"Gn","char2(x,y)=characteristic polynomial of the matrix x expressed with variable y, using the Hessenberg form. Can be much faster or much slower than char, depending on the base ring."},
     308                 :            : {"chell",2,(void*)ellchangecurve,5,"GG","chell(x,y)=change data on elliptic curve according to y=[u,r,s,t]."},
     309                 :            : {"chinese",2,(void*)chinese,4,"GG","chinese(x,y)=x,y being integers modulo mx and my,finds z such that z is congruent to x mod mx and y mod my."},
     310                 :            : {"chptell",2,(void*)ellchangepoint,5,"GG","chptell(x,y)=change data on point or vector of points x on an elliptic curve according to y=[u,r,s,t]."},
     311                 :            : {"classno",1,(void*)classno,4,"G","classno(x)=class number of discriminant x."},
     312                 :            : {"classno2",1,(void*)classno2,4,"G","classno2(x)=class number of discriminant x."},
     313                 :            : {"coeff",21,(void*)truecoeff,2,"GL","coeff(x,s)=coefficient of degree s of x, or the s-th component for vectors or matrices (for which it is simpler to use x[])."},
     314                 :            : {"compimag",2,(void*)qficomp,4,"GG","compimag(x,y)=Gaussian composition of the binary quadratic forms x and y of negative discriminant."},
     315                 :            : {"compo",21,(void*)compo,2,"GL","compo(x,s)=the s'th component of the internal representation of x. For vectors or matrices, it is simpler to use x[]."},
     316                 :            : {"compositum",2,(void*)compositum,6,"GG","compositum(pol1,pol2)=vector of all possible compositums of the number fields defined by the polynomials pol1 and pol2."},
     317                 :            : {"compositum2",2,(void*)compositum2,6,"GG","compositum2(pol1,pol2)=vector of all possible compositums of the number fields defined by the polynomials pol1 and pol2, with roots of pol1 and pol2 expressed on the compositum polynomials."},
     318                 :            : {"comprealraw",2,(void*)qfrcompraw,4,"GG","comprealraw(x,y)=Gaussian composition without reduction of the binary quadratic forms x and y of positive discriminant."},
     319                 :            : {"concat",2,(void*)concat,8,"GG","concat(x,y)=concatenation of x and y."},
     320                 :            : {"conductor",99,(void*)bnrconductor0,6,"GDGDGD1,L,","conductor(bnr,subgroup)=conductor of the subfield of the ray class field bnr given by buchrayinit, defined by the HNF matrix subgroup."},
     321                 :            : {"conductorofchar",2,(void*)bnrconductorofchar,6,"GG","conductorofchar(bnr,chi)=conductor of the character chi on the ray class group bnr."},
     322                 :            : {"conj",1,(void*)gconj,2,"G","conj(x)=the algebraic conjugate of x."},
     323                 :            : {"conjvec",1,(void*)conjvec,2,"Gp","conjvec(x)=conjugate vector of the algebraic number x."},
     324                 :            : {"content",1,(void*)content,4,"G","content(x)=gcd of all the components of x, when this makes sense."},
     325                 :            : {"convol",2,(void*)convol,7,"GG","convol(x,y)=convolution (or Hadamard product) of two power series."},
     326                 :            : {"core",1,(void*)core,4,"G","core(n)=unique (positive of negative) squarefree integer d dividing n such that n/d is a square."},
     327                 :            : {"core2",1,(void*)core2,4,"G","core2(n)=2-component row vector [d,f], where d is the unique squarefree integer dividing n such that n/d=f^2 is a square."},
     328                 :            : {"coredisc",1,(void*)coredisc,4,"G","coredisc(n)=discriminant of the quadratic field Q(sqrt(n))."},
     329                 :            : {"coredisc2",1,(void*)coredisc2,4,"G","coredisc2(n)=2-component row vector [d,f], where d is the discriminant of the quadratic field Q(sqrt(n)) and n=df^2. f may be a half integer."},
     330                 :            : {"cos",1,(void*)gcos,3,"Gp","cos(x)=cosine of x."},
     331                 :            : {"cosh",1,(void*)gcosh,3,"Gp","cosh(x)=hyperbolic cosine of x."},
     332                 :            : {"cvtoi",13,(void*)gcvtoi,2,"Gf","cvtoi(x)=truncation of x, without taking into account loss of integer part precision."},
     333                 :            : {"cyclo",11,(void*)polcyclo,7,"LDn","cyclo(n)=n-th cyclotomic polynomial."},
     334                 :            : {"decodefactor",1,(void*)factorback,4,"G","decodefactor(fa)=given a factorisation fa, gives the factored object back."},
     335                 :            : {"decodemodule",2,(void*)decodemodule,6,"GG","decodemodule(nf,fa)=given a coded module fa as in discrayabslist, gives the true module."},
     336                 :            : {"degree",10,(void*)degree,2,"lG","degree(x)=degree of the polynomial or rational function x. -1 if equal 0, 0 if non-zero scalar."},
     337                 :            : {"denom",1,(void*)denom,2,"G","denom(x)=denominator of x (or lowest common denominator in case of an array)."},
     338                 :            : {"deplin",1,(void*)deplin,8,"Gp","deplin(x)=finds a linear dependence between the columns of the matrix x."},
     339                 :            : {"deriv",14,(void*)deriv,7,"Gn","deriv(x,y)=derivative of x with respect to the main variable of y."},
     340                 :            : {"det",1,(void*)det,8,"G","det(x)=determinant of the matrix x."},
     341                 :            : {"det2",1,(void*)det2,8,"G","det2(x)=determinant of the matrix x (better for integer entries)."},
     342                 :            : {"detint",1,(void*)detint,8,"G","detint(x)=some multiple of the determinant of the lattice generated by the columns of x (0 if not of maximal rank). Useful with hermitemod."},
     343                 :            : {"diagonal",1,(void*)diagonal,8,"G","diagonal(x)=creates the diagonal matrix whose diagonal entries are the entries of the vector x."},
     344                 :            : {"dilog",1,(void*)dilog,3,"Gp","dilog(x)=dilogarithm of x."},
     345                 :            : {"dirdiv",2,(void*)dirdiv,7,"GG","dirdiv(x,y)=division of the Dirichlet series x by the Dir. series y."},
     346                 :            : {"direuler",83,(void*)direuler0,7,"V=GGEDG","direuler(p=a,b,expr)=Dirichlet Euler product of expression expr from p=a to p=b, limited to b terms. Expr should be a polynomial or rational function in p and X, and X is understood to mean p^(-s)."},
     347                 :            : {"dirmul",2,(void*)dirmul,7,"GG","dirmul(x,y)=multiplication of the Dirichlet series x by the Dir. series y."},
     348                 :            : {"dirzetak",2,(void*)dirzetak,6,"GG","dirzetak(nf,b)=Dirichlet series of the Dedekind zeta function of the number field nf up to the bound b-1."},
     349                 :            : {"disc",1,(void*)poldisc0,7,"GDn","disc(x)=discriminant of the polynomial x."},
     350                 :            : {"discf",1,(void*)nfdisc0,6,"GD0,L,DG","discf(x)=discriminant of the number field defined by the polynomial x using round 4."},
     351                 :            : {"discf2",1,(void*)nfdisc0,6,"GD2,L,DG","discf2(x)=discriminant of the number field defined by the polynomial x using round 2."},
     352                 :            : {"discrayabs",62,(void*)bnrdisc0,6,"GD0,G,D0,G,D0,L,","discrayabs(bnr,subgroup)=absolute [N,R1,disc] of the subfield of the ray class field bnr given by buchrayinit, defined by the HNF matrix subgroup."},
     353                 :            : {"discrayabscond",62,(void*)bnrdisc0,6,"GD0,G,D0,G,D2,L,","discrayabscond(bnr,subgroup)=absolute [N,R1,disc] of the subfield of the ray class field bnr given by buchrayinit, defined by the HNF matrix subgroup. Result is zero if fmodule is not the conductor."},
     354                 :            : {"discrayabslist",2,(void*)discrayabslist,6,"GG","discrayabslist(bnf,listes)=if listes is a 2-component vector as output by ideallistunit or similar, gives list of corresponding discrayabscond."},
     355                 :            : {"discrayabslistarch",32,(void*)discrayabslistarch,6,"GGL","discrayabslistarch(bnf,arch,bound)=gives list of discrayabscond of all modules up to norm bound with archimedean places arch, in a longvector format."},
     356                 :            : {"discrayabslistarchall",32,(void*)discrayabslistarch,6,"GL","discrayabslistarchall(bnf,bound)=gives list of discrayabscond of all modules up to norm bound with all possible archimedean places arch in reverse lexicographic order, in a longvector format."},
     357                 :            : {"discrayabslistlong",21,(void*)discrayabslistlong,6,"GL","discrayabslistlong(bnf,bound)=gives list of discrayabscond of all modules up to norm bound without archimedean places, in a longvector format."},
     358                 :            : {"discrayrel",62,(void*)bnrdisc0,6,"GD0,G,D0,G,D1,L,","discrayrel(bnr,subgroup)=relative [N,R1,rnfdisc] of the subfield of the ray class field bnr given by buchrayinit, defined by the HNF matrix subgroup."},
     359                 :            : {"discrayrelcond",62,(void*)bnrdisc0,6,"GD0,G,D0,G,D3,L,","discrayrelcond(bnr,subgroup)=relative [N,R1,rnfdisc] of the subfield of the ray class field bnr given by buchrayinit, defined by the HNF matrix subgroup. Result is zero if module is not the conductor."},
     360                 :            : {"divisors",1,(void*)divisors,4,"G","divisors(x)=gives a vector formed by the divisors of x in increasing order."},
     361                 :            : {"divres",2,(void*)gdiventres,1,"GG","divres(x,y)=euclidean division of x by y giving as a 2-dimensional column vector the quotient and the remainder."},
     362                 :            : {"divsum",22,(void*)sumdivexpr,9,"GVE","divsum(n,X,expr)=sum of expression expr, X running over the divisors of n."},
     363                 :            : {"eigen",1,(void*)eigen,8,"Gp","eigen(x)=eigenvectors of the matrix x given as columns of a matrix."},
     364                 :            : {"eint1",1,(void*)eint1,3,"Gp","eint1(x)=exponential integral E1(x)."},
     365                 :            : {"erfc",1,(void*)gerfc,3,"Gp","erfc(x)=complementary error function."},
     366                 :            : {"eta",1,(void*)eta,3,"Gp","eta(x)=eta function without the q^(1/24)."},
     367                 :            : {"euler",0,(void*)mpeuler,3,"p","euler=euler()=euler's constant with current precision."},
     368                 :            : {"eval",1,(void*)geval_gp,7,"GC","eval(x)=evaluation of x, replacing variables by their value."},
     369                 :            : {"exp",1,(void*)gexp,3,"Gp","exp(x)=exponential of x."},
     370                 :            : {"extract",2,(void*)extract0,8,"GGDG","extract(x,y)=extraction of the components of the vector x according to the vector or mask y, from left to right (1, 2, 4, 8, ...for the first, second, third, fourth,...component)."},
     371                 :            : {"fact",11,(void*)mpfactr,4,"Lp","fact(x)=factorial of x (x C-integer), the result being given as a real number."},
     372                 :            : {"factcantor",2,(void*)factcantor,4,"GG","factcantor(x,p)=factorization mod p of the polynomial x using Cantor-Zassenhaus."},
     373                 :            : {"factfq",3,(void*)factorff,4,"GGG","factfq(x,p,a)=factorization of the polynomial x in the finite field F_p[X]/a(X)F_p[X]."},
     374                 :            : {"factmod",2,(void*)factmod,4,"GG","factmod(x,p)=factorization mod p of the polynomial x using Berlekamp."},
     375                 :            : {"factor",1,(void*)factor,4,"G","factor(x)=factorization of x."},
     376                 :            : {"factoredbasis",28,(void*)factoredbase,6,"GG","factoredbasis(x,p)=integral basis of the maximal order defined by the polynomial x, where p is the matrix of the factorization of the discriminant of x."},
     377                 :            : {"factoreddiscf",2,(void*)factoreddiscf,6,"GG","factoreddiscf(x,p)=discriminant of the maximal order defined by the polynomial x, where p is the matrix of the factorization of the discriminant of x."},
     378                 :            : {"factoredpolred",2,(void*)factoredpolred,6,"GG","factoredpolred(x,p)=reduction of the polynomial x, where p is the matrix of the factorization of the discriminant of x (gives minimal polynomials only)."},
     379                 :            : {"factoredpolred2",2,(void*)factoredpolred2,6,"GG","factoredpolred2(x,p)=reduction of the polynomial x, where p is the matrix of the factorization of the discriminant of x (gives elements and minimal polynomials)."},
     380                 :            : {"factornf",2,(void*)polfnf,6,"GG","factornf(x,t)=factorization of the polynomial x over the number field defined by the polynomial t."},
     381                 :            : {"factorpadic",32,(void*)factorpadic,7,"GGL","factorpadic(x,p,r)=p-adic factorization of the polynomial x to precision r, using the round 4 algorithm."},
     382                 :            : {"factorpadic2",32,(void*)factorpadic0,7,"GGLD1,L,","factorpadic2(x,p,r)=p-adic factorization of the polynomial x to precision r, using Buchmann-Lenstra."},
     383                 :            : {"factpol",33,(void*)_factpol,7,"GLL","factpol(x,l,hint)=factorization over Z of the polynomial x up to degree l (complete if l=0) using Hensel lift, knowing that the degree of each factor is a multiple of hint."},
     384                 :            : {"factpol2",0,(void*)suppressed,6,"GL","factpol2(x,l)=factorization over Z of the polynomial x up to degree l (complete if l=0) using root finding."},
     385                 :            : {"fibo",11,(void*)fibo,4,"L","fibo(x)=fibonacci number of index x (x C-integer)."},
     386                 :            : {"floor",1,(void*)gfloor,2,"G","floor(x)=floor of x=largest integer<=x."},
     387                 :            : {"for",83,(void*)forpari,11,"vV=GGI","for(X=a,b,seq)=the sequence is evaluated, X going from a up to b."},
     388                 :            : {"fordiv",84,(void*)fordiv,11,"vGVI","fordiv(n,X,seq)=the sequence is evaluated, X running over the divisors of n."},
     389                 :            : {"forprime",83,(void*)forprime,11,"vV=GGI","forprime(X=a,b,seq)=the sequence is evaluated, X running over the primes between a and b."},
     390                 :            : {"forstep",86,(void*)forstep,11,"vV=GGGI","forstep(X=a,b,s,seq)=the sequence is evaluated, X going from a to b in steps of s."},
     391                 :            : {"forvec",87,(void*)forvec,11,"vV=GID0,L,","forvec(x=v,seq)=v being a vector of two-component vectors of length n, the sequence is evaluated with x[i] going from v[i][1] to v[i][2] for i=n,..,1."},
     392                 :            : {"fpn",21,(void*)ffinit,2,"GLDn","fpn(p,n)=monic irreducible polynomial of degree n over F_p[x]."},
     393                 :            : {"frac",1,(void*)gfrac,2,"G","frac(x)=fractional part of x=x-floor(x)."},
     394                 :            : {"galois",1,(void*)polgalois,6,"Gp","galois(x)=Galois group of the polynomial x (see manual for group coding)."},
     395                 :            : {"galoisapply",3,(void*)galoisapply,6,"GGG","galoisapply(nf,aut,x)=Apply the Galois automorphism sigma (polynomial or polymod) to the object x (element or ideal) in the number field nf."},
     396                 :            : {"galoisconj",1,(void*)galoisconj,6,"GDG","galoisconj(nf)=list of conjugates of a root of the polynomial x=nf[1] in the same number field, using p-adics, LLL on integral basis (not always complete)."},
     397                 :            : {"galoisconj1",0,(void*)suppressed,6,"G","galoisconj1(nf)=list of conjugates of a root of the polynomial x=nf[1] in the same number field nf, using complex numbers, LLL on integral basis (not always complete)."},
     398                 :            : {"galoisconjforce",0,(void*)suppressed,6,"G","galoisconjforce(nf)=list of conjugates of a root of the polynomial x=nf[1] in the Galois number field nf, using p-adics, LLL on integral basis. Guaranteed to be complete if the field is Galois, otherwise there is an infinite loop."},
     399                 :            : {"gamh",1,(void*)ggammah,3,"Gp","gamh(x)=gamma of x+1/2 (x integer)."},
     400                 :            : {"gamma",1,(void*)ggamma,3,"Gp","gamma(x)=gamma function at x."},
     401                 :            : {"gauss",2,(void*)gauss,8,"GG","gauss(a,b)=gaussian solution of ax=b (a matrix,b vector)."},
     402                 :            : {"gaussmodulo",3,(void*)gaussmodulo,8,"GGG","gaussmodulo(M,D,Y)=(long)gen_1 solution of system of congruences MX=Y mod D."},
     403                 :            : {"gaussmodulo2",3,(void*)gaussmodulo2,8,"GGG","gaussmodulo2(M,D,Y)=all solutions of system of congruences MX=Y mod D."},
     404                 :            : {"gcd",2,(void*)ggcd,4,"GG","gcd(x,y)=greatest common divisor of x and y."},
     405                 :            : {"getheap",0,(void*)getheap,2,"","getheap()=2-component vector giving the current number of objects in the heap and the space they occupy."},
     406                 :            : {"getrand",0,(void*)getrand,2,"","getrand()=current value of random number seed."},
     407                 :            : {"getstack",0,(void*)getstack,2,"l","getstack()=current value of stack pointer avma."},
     408                 :            : {"gettime",0,(void*)gettime,2,"l","gettime()=time (in milliseconds) since last call to gettime."},
     409                 :            : {"globalred",1,(void*)ellglobalred,5,"G","globalred(e)=e being an elliptic curve, returns [N,[u,r,s,t],c], where N is the conductor of e, [u,r,s,t] leads to the standard model for e, and c is the product of the local Tamagawa numbers c_p."},
     410                 :            : {"goto",0,(void*)suppressed,11,"s*","goto(n)=THIS FUNCTION HAS BEEN SUPPRESSED."},
     411                 :            : {"hclassno",1,(void*)hclassno,4,"G","hclassno(x)=Hurwitz-Kronecker class number of x>0."},
     412                 :            : {"hell",2,(void*)ghell,5,"GGp","hell(e,x)=canonical height of point x on elliptic curve E defined by the vector e computed using theta-functions."},
     413                 :            : {"hell2",2,(void*)ghell2,5,"GGp","hell2(e,x)=canonical height of point x on elliptic curve E defined by the vector e computed using Tate's method."},
     414                 :            : {"hermite",1,(void*)ZM_hnf,8,"G","hermite(x)=(upper triangular) Hermite normal form of x, basis for the lattice formed by the columns of x, using a naive algorithm."},
     415                 :            : {"hermite2",1,(void*)hnfall,8,"G","hermite2(x)=2-component vector [H,U] such that H is an (upper triangular) Hermite normal form of x, basis for the lattice formed by the columns of x, and U is a unimodular matrix such that xU=H, using Batut's algorithm."},
     416                 :            : {"hermitehavas",0,(void*)suppressed,8,"G","hermitehavas(x)=3-component vector [H,U,P] such that H is an (upper triangular) Hermite normal form of x with extra zero columns, U is a unimodular matrix and P is a permutation of the rows such that P applied to xU gives H, using Havas's algorithm."},
     417                 :            : {"hermitemod",2,(void*)hnfmod,8,"GG","hermitemod(x,d)=(upper triangular) Hermite normal form of x, basis for the lattice formed by the columns of x, where d is the non-zero determinant of this lattice."},
     418                 :            : {"hermitemodid",2,(void*)hnfmodid,8,"GG","hermitemodid(x,d)=(upper triangular) Hermite normal form of x concatenated with d times the identity matrix."},
     419                 :            : {"hermiteperm",1,(void*)hnfperm,8,"G","hermiteperm(x)=3-component vector [H,U,P] such that H is an (upper triangular) Hermite normal form of x with extra zero columns, U is a unimodular matrix and P is a permutation of the rows such that P applied to xU gives H, using Batut's algorithm."},
     420                 :            : {"hess",1,(void*)hess,8,"G","hess(x)=Hessenberg form of x."},
     421                 :            : {"hilb",30,(void*) hilbert,4,"lGGG","hilb(x,y,p)=Hilbert symbol at p of x,y (integers or fractions)."},
     422                 :            : {"hilbert",11,(void*)mathilbert,8,"L","hilbert(n)=Hilbert matrix of order n (n C-integer)."},
     423                 :            : {"hilbp",20,(void*) hilbert,4,"lGGDG","hilbp(x,y)=Hilbert symbol of x,y (where x or y is integermod or p-adic)."},
     424                 :            : {"hvector",22,(void*)vecteur,9,"GVE","hvector(n,X,expr)=row vector with n components of expression expr, the variable X ranging from 1 to n."},
     425                 :            : {"hyperu",3,(void*)hyperu,3,"GGGp","hyperu(a,b,x)=U-confluent hypergeometric function."},
     426                 :            : {"i",0,(void*)gen_I,2,"","i=i()=square root of -1."},
     427                 :            : {"idealadd",3,(void*)idealadd,6,"GGG","idealadd(nf,x,y)=sum of two ideals x and y in the number field defined by nf."},
     428                 :            : {"idealaddmultone",2,(void*)idealaddmultoone,6,"GG","idealaddone(nf,x,y)=when the sum of two ideals x and y in the number field K defined by nf is equal to Z_K, gives a two-component vector [a,b] such that a is in x, b is in y and a+b=1."},
     429                 :            : {"idealaddone",3,(void*)idealaddtoone,6,"GGG","idealaddmultone(nf,list)=when the sum of the ideals in the number field K defined by nf and given in the vector list is equal to Z_K, gives a vector of elements of the corresponding ideals who sum to 1."},
     430                 :            : {"idealappr",2,(void*)idealappr,6,"GGp","idealappr(nf,x)=x being a fractional ideal, gives an element b such that v_p(b)=v_p(x) for all prime ideals p dividing x, and v_p(b)>=0 for all other p."},
     431                 :            : {"idealapprfact",2,(void*)idealapprfact,6,"GG","idealapprfact(nf,x)=x being a prime ideal factorization with possibly zero or negative exponents, gives an element b such that v_p(b)=v_p(x) for all prime ideals p dividing x, and v_p(b)>=0 for all other p."},
     432                 :            : {"idealchinese",3,(void*)idealchinese,6,"GGG","idealchinese(nf,x,y)=x being a prime ideal factorization and y a vector of elements, gives an element b such that v_p(b-y_p)>=v_p(x) for all prime ideals p dividing x, and v_p(b)>=0 for all other p."},
     433                 :            : {"idealcoprime",3,(void*)idealcoprime,6,"GGG","idealcoprime(nf,x,y)=gives an element b in nf such that b.x is an integral ideal coprime to the integral ideal y."},
     434                 :            : {"idealdiv",3,(void*)idealdiv,6,"GGG","idealdiv(nf,x,y)=quotient x/y of two ideals x and y in HNF in the number field nf."},
     435                 :            : {"idealdivexact",3,(void*)idealdivexact,6,"GGG","idealdivexact(nf,x,y)=quotient x/y of two ideals x and y in HNF in the number field nf when the quotient is known to be an integral ideal."},
     436                 :            : {"idealfactor",2,(void*)idealfactor,6,"GG","idealfactor(nf,x)=factorization of the ideal x given in HNF into prime ideals in the number field nf."},
     437                 :            : {"idealhermite",2,(void*)idealhnf,6,"GG","idealhermite(nf,x)=hermite normal form of the ideal x in the number field nf, whatever form x may have."},
     438                 :            : {"idealhermite2",3,(void*)idealhnf0,6,"GGG","idealhermite2(nf,a,b)=hermite normal form of the ideal aZ_K+bZ_K in the number field K defined by nf, where a and b are elements."},
     439                 :            : {"idealintersect",3,(void*)idealintersect,6,"GGG","idealintersect(nf,x,y)=intersection of two ideals x and y in HNF in the number field defined by nf."},
     440                 :            : {"idealinv",2,(void*)idealinv,6,"GG","idealinv(nf,x)=inverse of the ideal x in the number field nf not using the different."},
     441                 :            : {"idealinv2",2,(void*)idealinv,6,"GG","idealinv2(nf,x)=inverse of the ideal x in the number field nf using the different."},
     442                 :            : {"ideallist",21,(void*)ideallist,6,"GL","ideallist(nf,bound)=vector of vectors of all ideals of norm<=bound in nf."},
     443                 :            : {"ideallistarch",3,(void*)ideallistarch,6,"GGG","ideallistarch(nf,list,arch)=vector of vectors of all zidealstarinits of all modules in list with archimedean arch added, without generators."},
     444                 :            : {"ideallistarchgen",3,(void*)ideallistarch,6,"GGG","ideallistarchgen(nf,list,arch)=vector of vectors of all zidealstarinits of all modules in list with archimedean arch added, with generators."},
     445                 :            : {"ideallistunit",21,(void*)ideallist0,6,"GLD2,L,","ideallistunit(bnf,bound)=2-component vector [L,U] where L is as ideallistzstar, and U is a vector of vector of zinternallogs of the units, without generators."},
     446                 :            : {"ideallistunitarch",3,(void*)ideallistarch,6,"GGG","ideallistunitarch(bnf,lists,arch)=adds the archimedean arch to the lists output by ideallistunit."},
     447                 :            : {"ideallistunitarchgen",3,(void*)ideallistarch,6,"GGG","ideallistunitarchgen(bnf,lists,arch)=adds the archimedean arch to the lists output by ideallistunitgen."},
     448                 :            : {"ideallistunitgen",21,(void*)ideallist0,6,"GLD3,L,","ideallistunitgen(bnf,bound)=2-component vector [L,U] where L is as ideallistzstar, and U is a vector of vector of zinternallogs of the units, with generators."},
     449                 :            : {"ideallistzstar",21,(void*)ideallist0,6,"GLD0,L,","ideallistzstar(nf,bound)=vector of vectors of all zidealstarinits of all ideals of norm<=bound, without generators."},
     450                 :            : {"ideallistzstargen",21,(void*)ideallist0,6,"GLD1,L,","ideallistzstargen(nf,bound)=vector of vectors of all zidealstarinits of all ideals of norm<=bound, with generators."},
     451                 :            : {"ideallllred",3,(void*)idealred0,6,"GGGp","ideallllred(nf,x,vdir)=LLL reduction of the ideal x in the number field nf along direction vdir, in HNF."},
     452                 :            : {"idealmul",3,(void*)idealmul,6,"GGG","idealmul(nf,x,y)=product of the two ideals x and y in the number field nf."},
     453                 :            : {"idealmulred",3,(void*)idealmulred,6,"GGGp","idealmulred(nf,x,y)=reduced product of the two ideals x and y in the number field nf."},
     454                 :            : {"idealnorm",2,(void*)idealnorm,6,"GG","idealnorm(nf,x)=norm of the ideal x in the number field nf."},
     455                 :            : {"idealpow",3,(void*)idealpow,6,"GGG","idealpow(nf,x,n)=n-th power of the ideal x in HNF in the number field nf."},
     456                 :            : {"idealpowred",3,(void*)idealpowred,6,"GGGp","idealpowred(nf,x,n)=reduced n-th power of the ideal x in HNF in the number field nf."},
     457                 :            : {"idealtwoelt",2,(void*)idealtwoelt,6,"GG","idealtwoelt(nf,x)=2-element representation of an ideal x in the number field nf."},
     458                 :            : {"idealtwoelt2",3,(void*)idealtwoelt2,6,"GGG","idealtwoelt2(nf,x,a)=2-element representation of an ideal x in the number field nf, with the first element equal to a."},
     459                 :            : {"idealval",30,(void*)idealval,6,"lGGG","idealval(nf,x,p)=valuation at p given in primedec format of the ideal x in the number field nf."},
     460                 :            : {"idmat",11,(void*)matid,8,"L","idmat(n)=identity matrix of order n (n C-integer)."},
     461                 :            : {"if",0,(void*)ifpari,11,"GDEDE","if(a,seq1,seq2): if a is nonzero, seq1 is evaluated, otherwise seq2. seq1 and seq2 are optional, and if seq2 is omitted, the preceding comma can be omitted also."},
     462                 :            : {"imag",1,(void*)gimag,2,"G","imag(x)=imaginary part of x."},
     463                 :            : {"image",1,(void*)image,8,"G","image(x)=basis of the image of the matrix x."},
     464                 :            : {"image2",1,(void*)image2,8,"G","image2(x)=basis of the image of the matrix x."},
     465                 :            : {"imagecompl",1,(void*)imagecompl,8,"G","imagecompl(x)=vector of column indices not corresponding to the indices given by the function image."},
     466                 :            : {"incgam",2,(void*)incgam,3,"GGp","incgam(s,x)=incomplete gamma function."},
     467                 :            : {"incgam1",2,(void*)suppressed,3,"GGp","incgam1(s,x)=incomplete gamma function (for debugging only)."},
     468                 :            : {"incgam2",2,(void*)suppressed,3,"GGp","incgam2(s,x)=incomplete gamma function (for debugging only)."},
     469                 :            : {"incgam3",2,(void*)incgamc,3,"GGp","incgam3(s,x)=complementary incomplete gamma function."},
     470                 :            : {"incgam4",3,(void*)incgam0,3,"GGGp","incgam4(s,x,y)=incomplete gamma function where y=gamma(s) is precomputed."},
     471                 :            : {"indexrank",1,(void*)indexrank,8,"G","indexrank(x)=gives two extraction vectors (rows and columns) for the matrix x such that the exracted matrix is square of maximal rank."},
     472                 :            : {"indsort",1,(void*)indexsort,8,"G","indsort(x)=indirect sorting of the vector x."},
     473                 :            : {"initalg",1,(void*)nfinit,6,"Gp","initalg(x)=x being a nonconstant irreducible polynomial, gives the vector: [x,[r1,r2],nfdisc,index,[M,MC,T2,T,different] (see manual),r1+r2 first roots, integral basis, matrix of power basis in terms of integral basis, multiplication table of basis]."},
     474                 :            : {"initalgred",1,(void*)nfinitred,6,"Gp","initalgred(x)=x being a nonconstant irreducible polynomial, finds (using polred) a simpler polynomial pol defining the same number field, and gives the vector: [pol,[r1,r2],nfdisc,index,[M,MC,T2,T,different] (see manual), r1+r2 first roots, integral basis, matrix of power basis in terms of integral basis, multiplication table of basis]."},
     475                 :            : {"initalgred2",1,(void*)nfinitred2,6,"Gp","initalgred2(P)=P being a nonconstant irreducible polynomial, gives a two-element vector [nf,mod(a,pol)], where nf is as output by nfinitred and mod(a,pol) is a polymod equal to mod(x,P) and pol=nf[1]."},
     476                 :            : {"initell",1,(void*)ellinit,5,"GDGp","initell(x)=x being the vector [a1,a2,a3,a4,a6], gives the vector: [a1,a2,a3,a4,a6,b2,b4,b6,b8,c4,c6,delta,j,[e1,e2,e3],w1,w2,eta1,eta2,q,area]."},
     477                 :            : {"initzeta",1,(void*)initzeta,6,"Gp","initzeta(x)=compute number field information necessary to use zetak, where x is an irreducible polynomial."},
     478                 :            : {"integ",14,(void*)integ,7,"Gn","integ(x,y)=formal integration of x with respect to the main variable of y."},
     479                 :            : {"intersect",2,(void*)intersect,8,"GG","intersect(x,y)=intersection of the vector spaces whose bases are the columns of x and y."},
     480                 :            : {"intgen",99,(void*)intnumromb0,9,"V=GGED1,L,p","intgen(X=a,b,s)=general numerical integration of s from a to b with respect to X, to be used after removing singularities."},
     481                 :            : {"intinf",99,(void*)intnumromb0,9,"V=GGED2,L,p","intinf(X=a,b,s)=numerical integration of s from a to b with respect to X, where a or b can be plus or minus infinity (1.0e4000), but of same sign."},
     482                 :            : {"intnum",99,(void*)intnumromb0,9,"V=GGED0,L,p","intnum(X=a,b,s)=numerical integration of s from a to b with respect to X."},
     483                 :            : {"intopen",99,(void*)intnumromb0,9,"V=GGED3,L,p","intopen(X=a,b,s)=numerical integration of s from a to b with respect to X, where s has only limits at a or b."},
     484                 :            : {"inverseimage",2,(void*)inverseimage,8,"GG","inverseimage(x,y)=an element of the inverse image of the vector y by the matrix x if one exists, the empty vector otherwise."},
     485                 :            : {"isdiagonal",10,(void*)isdiagonal,8,"lG","isdiagonal(x)=true(1) if x is a diagonal matrix, false(0) otherwise."},
     486                 :            : {"isfund",1,(void*)isfundamental,4,"lG","isfund(x)=true(1) if x is a fundamental discriminant (including 1), false(0) if not."},
     487                 :            : {"isideal",20,(void*)isideal,6,"lGG","isideal(nf,x)=true(1) if x is an ideal in the number field nf, false(0) if not."},
     488                 :            : {"isincl",2,(void*)nfisincl,6,"GG","isincl(x,y)=tests whether the number field defined by the polynomial x is isomorphic to a subfield of the one defined by y; 0 if not, otherwise all the isomorphisms."},
     489                 :            : {"isinclfast",2,(void*)nfisincl,6,"GG","isinclfast(nf1,nf2)=tests whether the number nf1 is isomorphic to a subfield of nf2 or not. If it gives a non-zero result, this proves that this is the case. However if it gives zero, nf1 may still be isomorphic to a subfield of nf2 so you have to use the much slower isincl to be sure."},
     490                 :            : {"isirreducible",1,(void*)isirreducible,7,"lG","isirreducible(x)=true(1) if x is an irreducible non-constant polynomial, false(0) if x is reducible or constant."},
     491                 :            : {"isisom",2,(void*)nfisisom,6,"GG","isisom(x,y)=tests whether the number field defined by the polynomial x is isomorphic to the one defined by y; 0 if not, otherwise all the isomorphisms."},
     492                 :            : {"isisomfast",2,(void*)nfisisom,6,"GG","isisomfast(nf1,nf2)=tests whether the number fields nf1 and nf2 are isomorphic or not. If it gives a non-zero result, this proves that they are isomorphic. However if it gives zero, nf1 and nf2 may still be isomorphic so you have to use the much slower isisom to be sure."},
     493                 :            : {"isoncurve",20,(void*)oncurve,5,"iGG","isoncurve(e,x)=true(1) if x is on elliptic curve e, false(0) if not."},
     494                 :            : {"isprime",1,(void*)gisprime,4,"GD0,L,","isprime(x)=true(1) if x is a strong pseudoprime for 10 random bases, false(0) if not."},
     495                 :            : {"isprincipal",2,(void*)isprincipal,6,"GG","isprincipal(bnf,x)=bnf being output by buchinit, gives the vector of exponents on the class group generators of x. In particular x is principal if and only if the result is the zero vector."},
     496                 :            : {"isprincipalforce",2,(void*)isprincipalforce,6,"GG","isprincipalforce(bnf,x)=same as isprincipal, except that the precision is doubled until the result is obtained."},
     497                 :            : {"isprincipalgen",2,(void*)isprincipalgen,6,"GG","isprincipalgen(bnf,x)=bnf being output by buchinit, gives [v,alpha,bitaccuracy], where v is the vector of exponents on the class group generators and alpha is the generator of the resulting principal ideal. In particular x is principal if and only if v is the zero vector."},
     498                 :            : {"isprincipalgenforce",2,(void*)isprincipalgenforce,6,"GG","isprincipalgenforce(bnf,x)=same as isprincipalgen, except that the precision is doubled until the result is obtained."},
     499                 :            : {"isprincipalray",2,(void*)isprincipalray,6,"GG","isprincipalray(bnf,x)=bnf being output by buchrayinit, gives the vector of exponents on the ray class group generators of x. In particular x is principal if and only if the result is the zero vector."},
     500                 :            : {"isprincipalraygen",2,(void*)isprincipalraygen,6,"GG","isprincipalraygen(bnf,x)=bnf being output by buchrayinit, gives [v,alpha,bitaccuracy], where v is the vector of exponents on the class group generators and alpha is the generator of the resulting principal ideal. In particular x is principal if and only if v is the zero vector."},
     501                 :            : {"ispsp",1,(void*)gispseudoprime,4,"GD1,L,","ispsp(x)=true(1) if x is a strong pseudoprime, false(0) if not."},
     502                 :            : {"isqrt",1,(void*)sqrtint,4,"G","isqrt(x)=integer square root of x (x integer)."},
     503                 :            : {"isset",10,(void*)setisset,8,"lG","isset(x)=true(1) if x is a set (row vector with strictly increasing entries), false(0) if not."},
     504                 :            : {"issqfree",1,(void*)issquarefree,4,"lG","issqfree(x)=true(1) if x is squarefree, false(0) if not."},
     505                 :            : {"issquare",1,(void*)issquare,4,"lG","issquare(x)=true(1) if x is a square, false(0) if not."},
     506                 :            : {"isunit",2,(void*)bnfisunit,6,"GG","isunit(bnf,x)=bnf being output by buchinit, gives the vector of exponents of x on the fundamental units and the roots of unity if x is a unit, the empty vector otherwise."},
     507                 :            : {"jacobi",1,(void*)jacobi,8,"Gp","jacobi(x)=eigenvalues and orthogonal matrix of eigenvectors of the real symmetric matrix x."},
     508                 :            : {"jbesselh",2,(void*)jbesselh,3,"GGp","jbesselh(n,x)=J-bessel function of index n+1/2 and argument x, where n is a non-negative integer."},
     509                 :            : {"jell",1,(void*)jell,3,"Gp","jell(x)=elliptic j invariant of x."},
     510                 :            : {"karamul",0,(void*)suppressed,7,"GGL","karamul(x,y,k)=THIS FUNCTION HAS BEEN SUPPRESSED."},
     511                 :            : {"kbessel",2,(void*)kbessel,3,"GGp","kbessel(nu,x)=K-bessel function of index nu and argument x (x positive real of type real, nu of any scalar type)."},
     512                 :            : {"kbessel2",2,(void*)kbessel,3,"GGp","kbessel2(nu,x)=K-bessel function of index nu and argument x (x positive real of type real, nu of any scalar type)."},
     513                 :            : {"ker",1,(void*)ker,8,"G","ker(x)=basis of the kernel of the matrix x."},
     514                 :            : {"keri",1,(void*)keri,8,"G","keri(x)=basis of the kernel of the matrix x with integer entries."},
     515                 :            : {"kerint",1,(void*)matkerint0,8,"GD0,L,","kerint(x)=LLL-reduced Z-basis of the kernel of the matrix x with integral entries using a modified LLL."},
     516                 :            : {"kerint1",1,(void*)matkerint0,8,"GD1,L,","kerint1(x)=LLL-reduced Z-basis of the kernel of the matrix x with rational entries using matrixqz3 and the HNF."},
     517                 :            : {"kerint2",1,(void*)suppressed,8,"G","kerint2(x)=LLL-reduced Z-basis of the kernel of the matrix x with integral entries using a modified LLL."},
     518                 :            : {"kro",2,(void*)kronecker,4,"lGG","kro(x,y)=kronecker symbol (x/y)."},
     519                 :            : {"label",0,(void*)suppressed,11,"s*","label(n)=THIS FUNCTION HAS BEEN SUPPRESSED."},
     520                 :            : {"lambdak",2,(void*)glambdak,6,"GGp","lambdak(nfz,s)=Dedekind lambda function of the number field nfz at s, where nfz is the vector computed by initzeta (NOT by nfinit)."},
     521                 :            : {"laplace",1,(void*)laplace,7,"G","laplace(x)=replaces the power series sum of a_n*x^n/n! by sum of a_n*x^n."},
     522                 :            : {"lcm",2,(void*)glcm,4,"GG","lcm(x,y)=least common multiple of x and y=x*y/gcd(x,y)."},
     523                 :            : {"legendre",11,(void*)pollegendre,7,"LDn","legendre(n)=legendre polynomial of degree n (n C-integer)."},
     524                 :            : {"length",1,(void*)glength,2,"lG","length(x)=number of non code words in x."},
     525                 :            : {"lex",20,(void*)lexcmp,2,"iGG","lex(x,y)=compare x and y lexicographically (1 if x>y, 0 if x=y, -1 if x<y)."},
     526                 :            : {"lexsort",1,(void*)lexsort,8,"G","lexsort(x)=sort the elements of the vector x in ascending lexicographic order."},
     527                 :            : {"lift",1,(void*)lift,2,"G","lift(x)=lifts every element of Z/nZ to Z or Z[x]/PZ[x] to Z[x]."},
     528                 :            : {"lindep",1,(void*)lindep,8,"G","lindep(x)=Z-linear dependencies between components of x (Hastad et al)."},
     529                 :            : {"lindep2",23,(void*)lindep2,8,"GL","lindep2(x,dec)=Z-linear dependencies between components of x using LLL, where dec should be about one half the number of decimal digits of precision."},
     530                 :            : {"lll",1,(void*)lll,8,"Gp","lll(x)=lll reduction of the vectors forming the matrix x (gives the unimodular transformation matrix)."},
     531                 :            : {"lll1",1,(void*)suppressed,8,"Gp","lll1(x)=old version of lll reduction of the vectors forming the matrix x (gives the unimodular transformation matrix)."},
     532                 :            : {"lllgen",1,(void*)lllgen,8,"Gp","lllgen(x)=lll reduction of the vectors forming the matrix x with polynomial coefficients (gives the unimodular transformation matrix)."},
     533                 :            : {"lllgram",1,(void*)lllgram,8,"Gp","lllgram(x)=lll reduction of the lattice whose gram matrix is x (gives the unimodular transformation matrix)."},
     534                 :            : {"lllgram1",1,(void*)suppressed,8,"Gp","lllgram1(x)=old version of lll reduction of the lattice whose gram matrix is x (gives the unimodular transformation matrix)."},
     535                 :            : {"lllgramgen",1,(void*)lllgramgen,8,"G","lllgramgen(x)=lll reduction of the lattice whose gram matrix is x with polynomial coefficients (gives the unimodular transformation matrix)."},
     536                 :            : {"lllgramint",1,(void*)lllgramint,8,"G","lllgramint(x)=lll reduction of the lattice whose gram matrix is the integral matrix x (gives the unimodular transformation matrix)."},
     537                 :            : {"lllgramkerim",1,(void*)lllgramkerim,8,"G","lllgramkerim(x)=kernel and lll reduction of the lattice whose gram matrix is the integral matrix x."},
     538                 :            : {"lllgramkerimgen",1,(void*)lllgramkerimgen,8,"G","lllgramkerimgen(x)=kernel and lll reduction of the lattice whose gram matrix is the matrix x with polynomial coefficients."},
     539                 :            : {"lllint",1,(void*)lllint,8,"G","lllint(x)=lll reduction of the vectors forming the matrix x when the gram matrix is integral (gives the unimodular transformation matrix)."},
     540                 :            : {"lllintpartial",1,(void*)lllintpartial,8,"G","lllintpartial(x)=partial (hence faster) lll reduction of the vectors forming the matrix x when the gram matrix is integral (gives the unimodular transformation matrix)."},
     541                 :            : {"lllkerim",1,(void*)lllkerim,8,"G","lllkerim(x)=kernel and lll reduction of the vectors forming the integral matrix x."},
     542                 :            : {"lllkerimgen",1,(void*)lllkerimgen,8,"G","lllkerimgen(x)=kernel and lll reduction of the vectors forming the matrix x with polynomial coefficients."},
     543                 :            : {"lllrat",1,(void*)suppressed,8,"G","lllrat(x)=lll reduction of the vectors forming the matrix x, computations done with rational numbers (gives the unimodular transformation matrix)."},
     544                 :            : {"ln",1,(void*)glog,3,"Gp","ln(x)=log(x)=natural logarithm of x."},
     545                 :            : {"lngamma",1,(void*)glngamma,3,"Gp","lngamma(x)=logarithm of the gamma function of x."},
     546                 :            : {"localred",2,(void*)elllocalred,5,"GG","localred(e,p)=e being an ellliptic curve, returns [f,kod,[u,r,s,t],c], where f is the conductor's exponent, kod is the kodaira type for e at p, [u,r,s,t] is the change of variable needed to make e minimal at p, and c is the local Tamagawa number c_p."},
     547                 :            : {"log",1,(void*)glog,3,"Gp","log(x)=ln(x)=natural logarithm of x."},
     548                 :            : {"logagm",1,(void*)glog,3,"Gp","logagm(x)=natural logarithm of x, computed using agm (faster than log for more than a few hundred decimal digits)."},
     549                 :            : {"lseriesell",4,(void*)lseriesell0,5,"GGGGp","lseriesell(e,s,N,A)=L-series at s of the elliptic curve e, where |N| is the conductor, sign(N) the sign of the functional equation, and A a cut-off point close to 1."},
     550                 :            : {"makebigbnf",1,(void*)bnfinit0,6,"GD0,L,DGp","makebigbnf(sbnf)=transforms small sbnf as output by smallbuchinit into a true big bnf."},
     551                 :            : {"mat",1,(void*)gtomat,8,"G","mat(x)=transforms any GEN x into a matrix."},
     552                 :            : {"matextract",3,(void*)extract0,8,"GGG","matextract(x,y,z)=extraction of the components of the matrix x according to the vector or masks y (for the rows) and z (for the columns) from left to right (1,2,4,8,...for the first, second, third, fourth, ...rows or columns)."},
     553                 :            : {"mathell",2,(void*)mathell,5,"GGp","mathell(e,x)=gives the height matrix for vector of points x on elliptic curve e using theta functions."},
     554                 :            : {"matrix",49,(void*)matrice,9,"GGVVE","matrix(m,n,X,Y,expr)=mXn matrix of expression expr, the row variable X going  from 1 to m and the column variable Y going from 1 to n."},
     555                 :            : {"matrixqz",2,(void*)QM_minors_coprime,8,"GG","matrixqz(x,p)=transforms the rational or integral mxn (m>=n) matrix x into an integral matrix with gcd of maximal determinants equal to 1 if p is equal to 0, not divisible by p otherwise."},
     556                 :            : {"matrixqz2",1,(void*)QM_ImZ_hnf,8,"G","matrixqz2(x)=finds a basis of the intersection with Z^n of the lattice spanned by the columns of x."},
     557                 :            : {"matrixqz3",1,(void*)QM_ImQ_hnf,8,"G","matrixqz3(x)=finds a basis of the intersection with Z^n of the Q-vector space spanned by the columns of x."},
     558                 :            : {"matsize",1,(void*)matsize,2,"G","matsize(x)=number of rows and columns of the vector/matrix x as a 2-vector."},
     559                 :            : {"max",2,(void*)gmax,1,"GG","max(x,y)=maximum of x and y."},
     560                 :            : {"min",2,(void*)gmin,1,"GG","min(x,y)=minimum of x and y."},
     561                 :            : {"minideal",3,(void*)idealmin,6,"GGG","idealmin(nf,ix,vdir)=minimum of the ideal ix in the direction vdir in the number field nf."},
     562                 :            : {"minim",33,(void*)minim,8,"GGG","minim(x,bound,maxnum)=number of vectors of square norm <= bound, maximum norm and list of vectors for the integral and definite quadratic form x; minimal non-zero vectors if bound=0."},
     563                 :            : {"minim2",23,(void*)minim2,8,"GG","minim2(x,bound)=looks for vectors of square norm <= bound, return the first one and its norm."},
     564                 :            : {"mod",25,(void*)gmodulo,2,"GG","mod(x,y)=creates the integer x modulo y on the PARI stack."},
     565                 :            : {"modp",25,(void*)gmodulo,2,"GG","modp(x,y)=creates the integer x modulo y as a permanent object (on the heap)."},
     566                 :            : {"modreverse",1,(void*)modreverse,6,"G","modreverse(x)=reverse polymod of the polymod x, if it exists."},
     567                 :            : {"modulargcd",2,(void*)QX_gcd,2,"GG","modulargcd(x,y)=gcd of the polynomials x and y using the modular method."},
     568                 :            : {"mu",1,(void*)moebius,4,"lG","mu(x)=Moebius function of x."},
     569                 :            : {"newtonpoly",2,(void*)newtonpoly,6,"GG","newtonpoly(x,p)=Newton polygon of polynomial x with respect to the prime p."},
     570                 :            : {"nextprime",1,(void*)nextprime,4,"G","nextprime(x)=smallest prime number>=x."},
     571                 :            : {"nfdetint",2,(void*)nfdetint,6,"GG","nfdetint(nf,x)=multiple of the ideal determinant of the pseudo generating set x."},
     572                 :            : {"nfdiv",3,(void*)nfdiv,6,"GGG","nfdiv(nf,a,b)=element a/b in nf."},
     573                 :            : {"nfdiveuc",3,(void*)nfdiveuc,6,"GGG","nfdiveuc(nf,a,b)=gives algebraic integer q such that a-bq is small."},
     574                 :            : {"nfdivres",3,(void*)nfdivrem,6,"GGG","nfdivres(nf,a,b)=gives [q,r] such that r=a-bq is small."},
     575                 :            : {"nfhermite",2,(void*)nfhnf,6,"GG","nfhermite(nf,x)=if x=[A,I], gives a pseudo-basis of the module sum A_jI_j."},
     576                 :            : {"nfhermitemod",3,(void*)nfhnfmod,6,"GGG","nfhermitemod(nf,x,detx)=if x=[A,I], and detx is a multiple of the ideal determinant of x, gives a pseudo-basis of the module sum A_jI_j."},
     577                 :            : {"nfmod",3,(void*)nfmod,6,"GGG","nfmod(nf,a,b)=gives r such that r=a-bq is small with q algebraic integer."},
     578                 :            : {"nfmul",3,(void*)nfmul,6,"GGG","nfmul(nf,a,b)=element a.b in nf."},
     579                 :            : {"nfpow",3,(void*)nfpow,6,"GGG","nfpow(nf,a,k)=element a^k in nf."},
     580                 :            : {"nfreduce",3,(void*)nfreduce,6,"GGG","nfreduce(nf,a,id)=gives r such that a-r is the ideal id and r is small."},
     581                 :            : {"nfsmith",2,(void*)nfsnf,6,"GG","nfsmith(nf,x)=if x=[A,I,J], outputs [c_1,...c_n] Smith normal form of x."},
     582                 :            : {"nfval",30,(void*)nfval,6,"lGGG","nfval(nf,a,pr)=valuation of element a at the prime pr."},
     583                 :            : {"norm",1,(void*)gnorm,2,"G","norm(x)=norm of x."},
     584                 :            : {"norml2",1,(void*)gnorml2,2,"G","norml2(x)=square of the L2-norm of the vector x."},
     585                 :            : {"nucomp",3,(void*)nucomp,4,"GGG","nucomp(x,y,l)=composite of primitive positive definite quadratic forms x and y using nucomp and nudupl, where l=[|D/4|^(1/4)] is precomputed."},
     586                 :            : {"numdiv",1,(void*)numdiv,4,"G","numdiv(x)=number of divisors of x."},
     587                 :            : {"numer",1,(void*)numer,2,"G","numer(x)=numerator of x."},
     588                 :            : {"nupow",2,(void*)nupow,4,"GG","nupow(x,n)=n-th power of primitive positive definite quadratic form x using nucomp and nudupl."},
     589                 :            : {"o",0,(void*)ggrando,7,"GD1,L,","o(a^b): p-adic or power series zero with precision given by b."},
     590                 :            : {"omega",1,(void*)omega,4,"lG","omega(x)=number of unrepeated prime divisors of x."},
     591                 :            : {"ordell",2,(void*)ellordinate,5,"GGp","ordell(e,x)=y-coordinates corresponding to x-ordinate x on elliptic curve e."},
     592                 :            : {"order",1,(void*)order,4,"G","order(x)=order of the integermod x in (Z/nZ)*."},
     593                 :            : {"orderell",2,(void*)orderell,5,"GG","orderell(e,p)=order of the point p on the elliptic curve e over Q, 0 if non-torsion."},
     594                 :            : {"ordred",1,(void*)polredord,6,"Gp","ordred(x)=reduction of the polynomial x, staying in the same order."},
     595                 :            : {"padicprec",20,(void*)padicprec,2,"lGG","padicprec(x,p)=absolute p-adic precision of object x."},
     596                 :            : {"pascal",99,(void*)matqpascal,8,"LDG","pascal(n)=pascal triangle of order n (n C-integer)."},
     597                 :            : {"perf",10,(void*)perf,8,"G","perf(a)=rank of matrix of xx~ for x minimal vectors of a gram matrix a."},
     598                 :            : {"permutation",24,(void*)numtoperm,2,"LG","permutation(n,k)=permutation number k (mod n!) of n letters (n C-integer)."},
     599                 :            : {"permutation2num",1,(void*)permtonum,2,"G","permutation2num(vect)=ordinal (between 1 and n!) of permutation vect."},
     600                 :            : {"pf",2,(void*)primeform,4,"GGp","pf(x,p)=returns the prime form whose first coefficient is p, of discriminant x."},
     601                 :            : {"phi",1,(void*)eulerphi,4,"G","phi(x)=Euler's totient function of x."},
     602                 :            : {"pi",0,(void*)mppi,3,"p","pi=pi()=the constant pi, with current precision."},
     603                 :            : {"pnqn",1,(void*)pnqn,4,"G","pnqn(x)=[p_n,p_{n-1};q_n,q_{n-1}] corresponding to the continued fraction x."},
     604                 :            : {"pointell",2,(void*)pointell,5,"GGp","pointell(e,z)=coordinates of point on the curve e corresponding to the complex number z."},
     605                 :            : {"polint",31,(void*)polint,7,"GGGD&","polint(xa,ya,x)=polynomial interpolation at x according to data vectors xa, ya."},
     606                 :            : {"polred",1,(void*)polred,6,"G","polred(x)=reduction of the polynomial x (gives minimal polynomials only)."},
     607                 :            : {"polred2",1,(void*)polred2,6,"G","polred2(x)=reduction of the polynomial x (gives elements and minimal polynomials)."},
     608                 :            : {"polredabs",1,(void*)polredabs,6,"G","polredabs(x)=a smallest generating polynomial of the number field for the T2 norm on the roots, with smallest index for the minimal T2 norm."},
     609                 :            : {"polredabs2",1,(void*)polredabs2,6,"G","polredabs2(x)=gives [pol,a] where pol is as in polredabs, and alpha is the element whose characteristic polynomial is pol."},
     610                 :            : {"polredabsall",1,(void*)polredabsall,6,"G","polredabsall(x)=complete list of the smallest generating polynomials of the number field for the T2 norm on the roots."},
     611                 :            : {"polredabsfast",0,(void*)suppressed,6,"G","polredabsfast(x)=a smallest generating polynomial of the number field for the T2 norm on the roots."},
     612                 :            : {"polredabsnored",1,(void*)polredabs,6,"G","polredabsnored(x)=a smallest generating polynomial of the number field for the T2 norm on the roots without initial polred."},
     613                 :            : {"polsym",21,(void*)polsym,7,"GL","polsym(x,n)=vector of symmetric powers of the roots of x up to n."},
     614                 :            : {"polvar",1,(void*)gpolvar,2,"G","polvar(x)=main variable of object x. Gives p for p-adic x, error for scalars."},
     615                 :            : {"poly",14,(void*)gtopoly,2,"Gn","poly(x,v)=convert x (usually a vector or a power series) into a polynomial with variable v, starting with the leading coefficient."},
     616                 :            : {"polylog",24,(void*)gpolylog,3,"LGp","polylog(m,x)=m-th polylogarithm of x."},
     617                 :            : {"polylogd",24,(void*)polylogd,3,"LGp","polylogd(m,x)=D_m~-modified m-th polylog of x."},
     618                 :            : {"polylogdold",24,(void*)polylogdold,3,"LGp","polylogdold(m,x)=D_m-modified m-th polylog of x."},
     619                 :            : {"polylogp",24,(void*)polylogp,3,"LGp","polylogp(m,x)=P_m-modified m-th polylog of x."},
     620                 :            : {"polyrev",14,(void*)gtopolyrev,2,"Gn","polyrev(x,v)=convert x (usually a vector or a power series) into a polynomial with variable v, starting with the constant term."},
     621                 :            : {"polzag",21,(void*)polzag,9,"LL","polzag(n,m)=Zagier's polynomials of index n,m."},
     622                 :            : {"powell",3,(void*)ellmul,5,"GGGp","powell(e,x,n)=n times the point x on elliptic curve e (n in Z)."},
     623                 :            : {"powrealraw",23,(void*)qfrpowraw,4,"GL","powrealraw(x,n)=n-th power without reduction of the binary quadratic form x of positive discriminant."},
     624                 :            : {"prec",21,(void*)gprec,2,"GL","prec(x,n)=change the precision of x to be n (n C-integer)."},
     625                 :            : {"precision",1,(void*)precision0,2,"GD0,L,","precision(x)=real precision of object x."},
     626                 :            : {"prime",11,(void*)prime,4,"L","prime(n)=returns the n-th prime (n C-integer)."},
     627                 :            : {"primedec",2,(void*)idealprimedec,6,"GG","primedec(nf,p)=prime ideal decomposition of the prime number p in the number field nf as a vector of 5 component vectors [p,a,e,f,b] representing the prime ideals pZ_K+a.Z_K, e,f as usual, a as vector of components on the  integral basis, b Lenstra's constant."},
     628                 :            : {"primes",11,(void*)primes,4,"L","primes(n)=returns the vector of the first n primes (n C-integer)."},
     629                 :            : {"primroot",1,(void*)znprimroot,4,"G","primroot(n)=returns a primitive root of n when it exists."},
     630                 :            : {"principalideal",2,(void*)principalideal,6,"GG","principalideal(nf,x)=returns the principal ideal generated by the algebraic number x in the number field nf."},
     631                 :            : {"principalidele",2,(void*)suppressed,6,"GG","principalidele(nf,x)=returns the principal idele generated by the algebraic number x in the number field nf."},
     632                 :            : {"prod",48,(void*)prod0,9,"GV=GGE","prod(x,X=a,b,expr)=x times the product (X runs from a to b) of expression."},
     633                 :            : {"prodeuler",37,(void*)prodeuler0,9,"V=GGEp","prodeuler(X=a,b,expr)=Euler product (X runs over the primes between a and b) of real or complex expression."},
     634                 :            : {"prodinf",27,(void*)prodinf0,9,"V=GED0,L,p","prodinf(X=a,expr)=infinite product (X goes from a to infinity) of real or complex expression."},
     635                 :            : {"prodinf1",27,(void*)prodinf0,9,"V=GED1,L,p","prodinf1(X=a,expr)=infinite product (X goes from a to infinity) of real or complex 1+expression."},
     636                 :            : {"psi",1,(void*)gpsi,3,"Gp","psi(x)=psi-function at x."},
     637                 :            : {"qfi",3,(void*)qfi,4,"GGG","qfi(a,b,c)=binary quadratic form a*x^2+b*x*y+c*y^2 with b^2-4*a*c<0."},
     638                 :            : {"qfr",4,(void*)qfr,4,"GGGG","qfr(a,b,c,d)=binary quadratic form a*x^2+b*x*y+c*y^2 with b^2-4*a*c>0 and distance d."},
     639                 :            : {"quaddisc",1,(void*)quaddisc,4,"G","quaddisc(x)=discriminant of the quadratic field Q(sqrt(x))."},
     640                 :            : {"quadgen",1,(void*)quadgen,2,"G","quadgen(x)=standard generator of quadratic order of discriminant x."},
     641                 :            : {"quadpoly",1,(void*)quadpoly,2,"G","quadpoly(x)=quadratic polynomial corresponding to the discriminant x."},
     642                 :            : {"random",0,(void*)genrand,2,"DG","random()=random integer between 0 and 2^31-1."},
     643                 :            : {"rank",10,(void*)rank,8,"lG","rank(x)=rank of the matrix x."},
     644                 :            : {"rayclassno",2,(void*)bnrclassno,6,"GG","rayclassno(bnf,x)=ray class number of the module x for the big number field bnf. Faster than buchray if only the ray class number is wanted."},
     645                 :            : {"rayclassnolist",2,(void*)bnrclassnolist,6,"GG","rayclassnolist(bnf,liste)=if listes is as output by idealisunit or similar, gives list of corresponding ray class numbers."},
     646                 :            : {"real",1,(void*)greal,2,"G","real(x)=real part of x."},
     647                 :            : {"recip",1,(void*)polrecip,7,"G","recip(x)=reciprocal polynomial of x."},
     648                 :            : {"redimag",1,(void*)redimag,4,"G","redimag(x)=reduction of the binary quadratic form x with D<0."},
     649                 :            : {"redreal",1,(void*)redreal,4,"G","redreal(x)=reduction of the binary quadratic form x with D>0."},
     650                 :            : {"redrealnod",2,(void*)redrealnod,4,"GG","redrealnod(x,sq)=reduction of the binary quadratic form x with D>0 without distance function where sq=[sqrt D]."},
     651                 :            : {"reduceddisc",1,(void*)reduceddiscsmith,7,"G","reduceddisc(f)=vector of elementary divisors of Z[a]/f'(a)Z[a], where a is a root of the polynomial f."},
     652                 :            : {"regula",1,(void*)quadregulator,4,"Gp","regula(x)=regulator of the real quadratic field of discriminant x."},
     653                 :            : {"reorder",0,(void*)suppressed,11,"G","reorder(x)=THIS FUNCTION HAS BEEN SUPPRESSED."},
     654                 :            : {"resultant",2,(void*)resultant_all,7,"GGD&","resultant(x,y)=resultant of the polynomials x and y with exact entries."},
     655                 :            : {"resultant2",2,(void*)resultant2,7,"GG","resultant2(x,y)=resultant of the polynomials x and y."},
     656                 :            : {"reverse",1,(void*)serreverse,7,"G","reverse(x)=reversion of the power series x."},
     657                 :            : {"rhoreal",1,(void*)rhoreal,4,"G","rhoreal(x)=single reduction step of the binary quadratic form x of positive discriminant."},
     658                 :            : {"rhorealnod",2,(void*)rhorealnod,4,"GG","rhorealnod(x,sq)=single reduction step of the binary quadratic form x with D>0 without distance function where sq=[sqrt D]."},
     659                 :            : {"rndtoi",13,(void*)grndtoi,2,"Gf","rndtoi(x)=take the nearest integer to all the coefficients of x, without taking into account loss of integer part precision."},
     660                 :            : {"rnfbasis",2,(void*)rnfbasis,6,"GG","rnfbasis(bnf,order)=given an order as output by rnfpseudobasis or rnfsteinitz, gives either a basis of the order if it is free, or an n+1-element generating set."},
     661                 :            : {"rnfdiscf",2,(void*)rnfdiscf,6,"GG","rnfdiscf(nf,pol)=given a pol with coefficients in nf, gives a 2-component vector [D,d], where D is the relative ideal discriminant, and d is the relative discriminant in nf^*/nf*^2."},
     662                 :            : {"rnfequation",2,(void*)rnfequation,6,"GG","rnfequation(nf,pol)=given a pol with coefficients in nf, gives the absolute equation of the number field defined by pol."},
     663                 :            : {"rnfequation2",2,(void*)rnfequation2,6,"GG","rnfequation2(nf,pol)=given a pol with coefficients in nf, gives [apol,th], where apol is the absolute equation of the number field defined by pol and th expresses the root of nf[1] in terms of the root of apol."},
     664                 :            : {"rnfhermitebasis",2,(void*)rnfhnfbasis,6,"GG","rnfhermitebasis(bnf,order)=given an order as output by rnfpseudobasis, gives either a true HNF basis of the order if it exists, zero otherwise."},
     665                 :            : {"rnfisfree",20,(void*)rnfisfree,6,"lGG","rnfisfree(bnf,order)=given an order as output by rnfpseudobasis or rnfsteinitz, outputs true (1) or false (0) according to whether the order is free or not."},
     666                 :            : {"rnflllgram",3,(void*)rnflllgram,6,"GGG","rnflllgram(nf,pol,order)=given a pol with coefficients in nf and an order as output by rnfpseudobasis or similar, gives [[neworder],U], where neworder is a reduced order and U is the unimodular transformation matrix."},
     667                 :            : {"rnfpolred",2,(void*)rnfpolred,6,"GG","rnfpolred(nf,pol)=given a pol with coefficients in nf, finds a list of polynomials defining some subfields, hopefully simpler."},
     668                 :            : {"rnfpseudobasis",2,(void*)rnfpseudobasis,6,"GG","rnfpseudobasis(nf,pol)=given a pol with coefficients in nf, gives a 4-component vector [A,I,D,d] where [A,I] is a pseudo basis of the maximal order in HNF on the power basis, D is the relative ideal discriminant, and d is the relative discriminant in nf^*/nf*^2."},
     669                 :            : {"rnfsteinitz",2,(void*)rnfsteinitz,6,"GG","rnfsteinitz(nf,order)=given an order as output by rnfpseudobasis, gives [A,I,..] where (A,I) is a pseudo basis where all the ideals except perhaps the last are trivial."},
     670                 :            : {"rootmod",2,(void*)rootmod,7,"GG","rootmod(x,p)=roots mod p of the polynomial x."},
     671                 :            : {"rootmod2",2,(void*)rootmod2,7,"GG","rootmod2(x,p)=roots mod p of the polynomial x, when p is small."},
     672                 :            : {"rootpadic",32,(void*)rootpadic,7,"GGL","rootpadic(x,p,r)=p-adic roots of the polynomial x to precision r."},
     673                 :            : {"roots",1,(void*)roots,7,"Gp","roots(x)=roots of the polynomial x using Schonhage's method modified by Gourdon."},
     674                 :            : {"rootsof1",1,(void*)rootsof1,6,"G","rootsof1(nf)=number of roots of unity and primitive root of unity in the number field nf."},
     675                 :            : {"rootsold",0,(void*)suppressed,11,"G","rootsold(x)=THIS FUNCTION HAS BEEN SUPPRESSED."},
     676                 :            : {"round",1,(void*)ground,2,"G","round(x)=take the nearest integer to all the coefficients of x."},
     677                 :            : {"rounderror",10,(void*)rounderror,2,"lG","rounderror(x)=maximum error found in rounding x."},
     678                 :            : {"series",14,(void*)gtoser,2,"GnDP","series(x,v)=convert x (usually a vector) into a power series with variable v, starting with the constant coefficient."},
     679                 :            : {"set",1,(void*)gtoset,8,"G","set(x)=convert x into a set, i.e. a row vector with strictly increasing coefficients."},
     680                 :            : {"setintersect",2,(void*)setintersect,8,"GG","setintersect(x,y)=intersection of the sets x and y."},
     681                 :            : {"setminus",2,(void*)setminus,8,"GG","setminus(x,y)=set of elements of x not belonging to y."},
     682                 :            : {"setrand",11,(void*)setrand,2,"vG","setrand(n)=reset the seed of the random number generator to n."},
     683                 :            : {"setsearch",20,(void*)setsearch,8,"lGGD0,L,","setsearch(x,y)=looks if y belongs to the set x. Returns 0 if it is not, otherwise returns the index j such that y==x[j]."},
     684                 :            : {"setunion",2,(void*)setunion,8,"GG","setunion(x,y)=union of the sets x and y."},
     685                 :            : {"shift",21,(void*)gshift,1,"GL","shift(x,n)=shift x left n bits if n>=0, right -n bits if n<0."},
     686                 :            : {"shiftmul",21,(void*)gmul2n,1,"GL","shiftmul(x,n)=multiply x by 2^n (n>=0 or n<0)."},
     687                 :            : {"sigma",1,(void*)sumdiv,4,"G","sigma(x)=sum of the divisors of x."},
     688                 :            : {"sigmak",24,(void*)sigmak0,4,"LG","sigmak(k,x)=sum of the k-th powers of the divisors of x (k C-integer)."},
     689                 :            : {"sign",10,(void*)gsigne,1,"iG","sign(x)=sign of x, of type integer, real or fraction."},
     690                 :            : {"signat",1,(void*)qfsign,8,"G","signat(x)=signature of the symmetric matrix x."},
     691                 :            : {"signunit",1,(void*)signunits,6,"G","signunit(bnf)=matrix of signs of the real embeddings of the system of fundamental units found by buchinit."},
     692                 :            : {"simplefactmod",2,(void*)simplefactmod,4,"GG","simplefactmod(x,p)=same as factmod except that only the degrees of the irreducible factors are given."},
     693                 :            : {"simplify",1,(void*)simplify,2,"G","simplify(x)=simplify the object x as much as possible."},
     694                 :            : {"sin",1,(void*)gsin,3,"Gp","sin(x)=sine of x."},
     695                 :            : {"sinh",1,(void*)gsinh,3,"Gp","sinh(x)=hyperbolic sine of x."},
     696                 :            : {"size",10,(void*)sizedigit,2,"lG","size(x)=maximum number of decimal digits minus one of (the coefficients of) x."},
     697                 :            : {"smallbasis",13,(void*)nfbasis0,6,"GD1,L,DG","smallbasis(x)=integral basis of the field Q[a], where a is a root of the polynomial x where one assumes that no square of a prime>primelimit divides the discriminant of x."},
     698                 :            : {"smallbuchinit",93,(void*)smallbuchinit,6,BUCH_PROTO,"smallbuchinit(pol)=small buchinit, which can be converted to a big one using makebigbnf."},
     699                 :            : {"smalldiscf",1,(void*)nfdisc0,6,"GD1,L,DG","smalldiscf(x)=discriminant of the number field defined by the polynomial x where one assumes that no square of a prime>primelimit divides the discriminant of x."},
     700                 :            : {"smallfact",1,(void*)boundfact,4,"GD0,L,","smallfact(x)=partial factorization of the integer x (using only the stored primes)."},
     701                 :            : {"smallinitell",1,(void*)ellinit,5,"GDGp","smallinitell(x)=x being the vector [a1,a2,a3,a4,a6], gives the vector: [a1,a2,a3,a4,a6,b2,b4,b6,b8,c4,c6,delta,j]."},
     702                 :            : {"smallpolred",1,(void*)smallpolred,6,"G","smallpolred(x)=partial reduction of the polynomial x (gives minimal polynomials only)."},
     703                 :            : {"smallpolred2",1,(void*)smallpolred2,6,"G","smallpolred2(x)=partial reduction of the polynomial x (gives elements and minimal polynomials)."},
     704                 :            : {"smith",1,(void*)smith,8,"G","smith(x)=Smith normal form (i.e. elementary divisors) of the matrix x, expressed as a vector."},
     705                 :            : {"smith2",1,(void*)smithall,8,"G","smith2(x)=gives a three element vector [u,v,d] where u and v are square unimodular matrices such that d=u*x*v=diagonal(smith(x))."},
     706                 :            : {"smithclean",1,(void*)smithclean,8,"G","smithclean(z)=if z=[u,v,d] as output by smith2, removes from u,v,d the rows and columns corresponding to entries equal to 1 in d."},
     707                 :            : {"smithpol",1,(void*)gsmith,8,"G","smithpol(x)=Smith normal form (i.e. elementary divisors) of the matrix x with polynomial coefficients, expressed as a vector."},
     708                 :            : {"solve",37,(void*)zbrent0,9,"V=GGEp","solve(X=a,b,expr)=real root of expression expr (X between a and b), where expr(a)*expr(b)<=0."},
     709                 :            : {"sort",1,(void*)sort,8,"G","sort(x)=sort in ascending order of the vector x."},
     710                 :            : {"sqr",1,(void*)gsqr,3,"G","sqr(x)=square of x. NOT identical to x*x."},
     711                 :            : {"sqred",1,(void*)qfgaussred,8,"G","sqred(x)=square reduction of the (symmetric) matrix x ( returns a square matrix whose i-th diagonal term is the coefficient of the i-th square in which the coefficient of the i-th variable is 1)."},
     712                 :            : {"sqrt",1,(void*)gsqrt,3,"Gp","sqrt(x)=square root of x."},
     713                 :            : {"srgcd",2,(void*)RgX_gcd,7,"GG","srgcd(x,y)=polynomial gcd of x and y using the subresultant algorithm."},
     714                 :            : {"sturm",10,(void*)sturm0,7,"lG","sturm(x)=number of real roots of the polynomial x."},
     715                 :            : {"sturmpart",30,(void*)sturmpart,7,"lGGG","sturmpart(x,a,b)=number of real roots of the polynomial x in the interval (a,b]."},
     716                 :            : {"subcyclo",2,(void*)polsubcyclo,6,"LLDn","subcyclo(p,d)=finds an equation for the d-th degree subfield of Q(zeta_p), where p must be a prime power."},
     717                 :            : {"subell",3,(void*)ellsub,5,"GGGp","subell(e,z1,z2)=difference of the points z1 and z2 on elliptic curve e."},
     718                 :            : {"subst",26,(void*)gsubst,7,"GnG","subst(x,y,z)=in expression x, replace the variable y by the expression z."},
     719                 :            : {"sum",48,(void*)sum0,9,"GV=GGE","sum(x,X=a,b,expr)=x plus the sum (X goes from a to b) of expression expr."},
     720                 :            : {"sumalt",27,(void*)sumalt0,9,"V=GED0,L,p","sumalt(X=a,expr)=Villegas-Zagier's acceleration of alternating series expr, X starting at a."},
     721                 :            : {"sumalt2",27,(void*)sumalt0,9,"V=GED1,L,p","sumalt2(X=a,expr)=Cohen-Villegas-Zagier's acceleration of alternating series expr, X starting at a."},
     722                 :            : {"suminf",27,(void*)suminf0,9,"V=GEp","suminf(X=a,expr)=infinite sum (X goes from a to infinity) of real or complex expression expr."},
     723                 :            : {"sumpos",27,(void*)sumpos0,9,"V=GED0,L,p","sumpos(X=a,expr)=sum of positive series expr, the formal variable X starting at a."},
     724                 :            : {"sumpos2",27,(void*)sumpos0,9,"V=GED1,L,p","sumpos2(X=a,expr)=sum of positive series expr, the formal variable X starting at a, using Zagier's polynomials."},
     725                 :            : {"supplement",1,(void*)suppl,8,"G","supplement(x)=supplement the columns of the matrix x to an invertible matrix."},
     726                 :            : {"sylvestermatrix",2,(void*)sylvestermatrix,7,"GG","sylvestermatrix(x,y)=forms the sylvester matrix associated to the two polynomials x and y. Warning: the polynomial coefficients are in columns, not in rows."},
     727                 :            : {"system",70,(void*)gpsystem,11,"vs","system(str): str being a string, execute the system command str"},
     728                 :            : {"tan",1,(void*)gtan,3,"Gp","tan(x)=tangent of x."},
     729                 :            : {"tanh",1,(void*)gtanh,3,"Gp","tanh(x)=hyperbolic tangent of x."},
     730                 :            : {"taniyama",1,(void*)elltaniyama,5,"GP","taniyama(e)=modular parametrization of elliptic curve e."},
     731                 :            : {"taylor",12,(void*)tayl,7,"GnP","taylor(x,y)=taylor expansion of x with respect to the main variable of y."},
     732                 :            : {"tchebi",11,(void*)polchebyshev,7,"LD1,L,Dn","tchebi(n)=Tchebitcheff polynomial of degree n (n C-integer)."},
     733                 :            : {"teich",1,(void*)teich,3,"Gp","teich(x)=teichmuller character of p-adic number x."},
     734                 :            : {"theta",2,(void*)theta,3,"GGp","theta(q,z)=Jacobi sine theta-function."},
     735                 :            : {"thetanullk",21,(void*)thetanullk,3,"GLp","thetanullk(q,k)=k'th derivative at z=0 of theta(q,z)."},
     736                 :            : {"threetotwo",0,(void*)suppressed,6,"GGGG","threetotwo(nf,a,b,c)=returns a 3-component vector [d,e,U] such that U is a unimodular 3x3 matrix with algebraic integer coefficients such that [a,b,c]*U=[0,d,e]."},
     737                 :            : {"threetotwo2",0,(void*)suppressed,6,"GGGG","threetotwo2(nf,a,b,c)=returns a 3-component vector [d,e,U] such that U is a unimodular 3x3 matrix with algebraic integer coefficients such that [a,b,c]*U=[0,d,e]."},
     738                 :            : {"torsell",1,(void*)elltors,5,"Gp","torsell(e)=torsion subgroup of elliptic curve e: order, structure, generators."},
     739                 :            : {"trace",1,(void*)gtrace,8,"G","trace(x)=trace of x."},
     740                 :            : {"trans",1,(void*)gtrans,8,"G","trans(x)=x~=transpose of x."},
     741                 :            : {"trunc",1,(void*)gtrunc,2,"G","trunc(x)=truncation of x;when x is a power series,take away the O(X^)."},
     742                 :            : {"tschirnhaus",1,(void*)tschirnhaus,6,"G","tschirnhaus(x)=random Tschirnhausen transformation of the polynomial x."},
     743                 :            : {"twototwo",0,(void*)suppressed,6,"GGG","twototwo(nf,a,b)=returns a 3-component vector [d,e,U] such that U is a unimodular 2x2 matrix with algebraic integer coefficients such that [a,b]*U=[d,e] and d,e are hopefully smaller."},
     744                 :            : {"unit",1,(void*)quadunit,4,"G","unit(x)=fundamental unit of the quadratic field of discriminant x where x must be positive."},
     745                 :            : {"until",0,(void*)untilpari,11,"vEI","until(a,seq): evaluate the expression sequence seq until a is nonzero."},
     746                 :            : {"valuation",20,(void*)gvaluation,2,"lGG","valuation(x,p)=valuation of x with respect to p."},
     747                 :            : {"vec",1,(void*)gtovec,2,"G","vec(x)=transforms the object x into a vector. Used mainly if x is a polynomial or a power series."},
     748                 :            : {"vecindexsort",2,(void*)indexsort,8,"G","vecindexsort(x): indirect sorting of the vector x."},
     749                 :            : {"veclexsort",2,(void*)lexsort,8,"G","veclexsort(x): sort the elements of the vector x in ascending lexicographic order."},
     750                 :            : {"vecmax",1,(void*)vecmax,2,"G","vecmax(x)=maximum of the elements of the vector/matrix x."},
     751                 :            : {"vecmin",1,(void*)vecmin,2,"G","vecmin(x)=minimum of the elements of the vector/matrix x."},
     752                 :            : {"vecsort",2,(void*)vecsort0,8,"GGD0,L,","vecsort(x,k)=sorts the vector of vector (or matrix) x according to the value of its k-th component."},
     753                 :            : {"vector",22,(void*)vecteur,9,"GVE","vector(n,X,expr)=row vector with n components of expression expr (X ranges from 1 to n)."},
     754                 :            : {"vvector",22,(void*)vvecteur,9,"GVE","vvector(n,X,expr)=column vector with n components of expression expr (X ranges from 1 to n)."},
     755                 :            : {"weipell",1,(void*)weipell,5,"GP","weipell(e)=formal expansion in x=z of Weierstrass P function."},
     756                 :            : {"wf",1,(void*)weberf,3,"Gp","weberf(x)=Weber's f function of x (j=(f^24-16)^3/f^24)."},
     757                 :            : {"wf2",1,(void*)weberf2,3,"Gp","weberf2(x)=Weber's f2 function of x (j=(f2^24+16)^3/f2^24)."},
     758                 :            : {"while",0,(void*)whilepari,11,"vEI","while(a,seq): while a is nonzero evaluate the expression sequence seq. Otherwise 0."},
     759                 :            : {"zell",2,(void*)zell,5,"GGp","zell(e,z)=In the complex case, lattice point corresponding to the point z on the elliptic curve e."},
     760                 :            : {"zeta",1,(void*)gzeta,3,"Gp","zeta(s)=Riemann zeta function at s."},
     761                 :            : {"zetak",2,(void*)gzetak,6,"GGp","zetak(nfz,s)=Dedekind zeta function of the number field nfz at s, where nfz is the vector computed by initzeta (NOT by nfinit)."},
     762                 :            : {"zideallog",3,(void*)ideallog,6,"GGG","zideallog(nf,x,bid)=if bid is a big ideal as given by zidealstarinit or zidealstarinitgen , gives the vector of exponents on the generators bid[2][3] (even if these generators have not been computed)."},
     763                 :            : {"zidealstar",2,(void*)idealstar0,6,"GGD0,L,","zidealstar(nf,I)=3-component vector v, giving the structure of (Z_K/I)^*. v[1] is  the order (i.e. phi(I)), v[2] is a vector of cyclic components, and v[3]  is a vector giving the corresponding generators."},
     764                 :            : {"zidealstarinit",2,(void*)idealstar0,6,"GGD1,L,","zidealstarinit(nf,I)=6-component vector [I,v,fa,f2,U,V] where v is as in zidealstar without the generators, fa is the prime ideal factorisation of I and f2, U and V are technical but essential to work in (Z_K/I)^*."},
     765                 :            : {"zidealstarinitgen",2,(void*)idealstar0,6,"GGD2,L,","zidealstarinitgen(nf,I)=6-component vector [I,v,fa,f2,U,V] where v is as in zidealstar fa is the prime ideal factorisation of I and f2, U and V are technical but essential to work in (Z_K/I)^*."},
     766                 :            : {"znstar",1,(void*)znstar,4,"G","znstar(n)=3-component vector v, giving the structure of (Z/nZ)^*. v[1] is  the order (i.e. phi(n)), v[2] is a vector of cyclic components, and v[3]  is a vector giving the corresponding generators."},
     767                 :            : 
     768                 :            : {NULL,0,NULL,0,NULL,NULL} /* sentinel */
     769                 :            : };

Generated by: LCOV version 1.9