/* This file is autogenerated from the database. */
/* See src/desc/gen_proto */
/* Do not edit*/
entree functions_basic[]={
{"!_",0,(void*)gnot,25,"G","!a: boolean operator \"not\"."},
{"#_",0,(void*)glength,25,"lG","#x: number of non code words in x, number of characters for a string."},
{"#_~",0,(void*)gtranslength,25,"lG","#x~: number of non code words in x~"},
{"%",0,(void*)pari_get_hist,25,"D0,L,","last history item."},
{"%#",0,(void*)pari_histtime,25,"D0,L,","time to compute last history item."},
{"+_",0,NULL,25,NULL,"+_: copy and return its argument"},
{"-_",0,(void*)gneg,25,"G","-_: negate argument"},
{"Catalan",0,(void*)mpcatalan,12,"p","Catalan=Catalan(): Catalan's number with current precision."},
{"Col",0,(void*)gtocol0,6,"GD0,L,","Col(x,{n}): transforms the object x into a column vector of dimension n."},
{"Colrev",0,(void*)gtocolrev0,6,"GD0,L,","Colrev(x,{n}): transforms the object x into a column vector of dimension n in reverse order with respect to Col(x,{n}). Empty vector if x is omitted."},
{"Euler",0,(void*)mpeuler,12,"p","Euler=Euler(): Euler's constant with current precision."},
{"I",0,(void*)gen_I,12,"","I=I(): square root of -1."},
{"List",0,(void*)gtolist,6,"DG","List({x=[]}): transforms the vector or list x into a list. Empty list if x is omitted."},
{"Map",0,(void*)gtomap,6,"DG","Map({x}): converts the matrix [a_1,b_1;a_2,b_2;...;a_n,b_n] to the map a_i->b_i."},
{"Mat",0,(void*)gtomat,6,"DG","Mat({x=[]}): transforms any GEN x into a matrix. Empty matrix if x is omitted."},
{"Mod",0,(void*)gmodulo,6,"GG","Mod(a,b): create 'a modulo b'."},
{"O",0,NULL,10,NULL,"O(p^e): p-adic or power series zero with precision given by e."},
{"O(_^_)",0,(void*)ggrando,27,"GD1,L,","O(p^e): p-adic or power series zero with precision given by e."},
{"Pi",0,(void*)mppi,12,"p","Pi=Pi(): the constant pi, with current precision."},
{"Pol",0,(void*)gtopoly,6,"GDn","Pol(t,{v='x}): convert t (usually a vector or a power series) into a polynomial with variable v, starting with the leading coefficient."},
{"Polrev",0,(void*)gtopolyrev,6,"GDn","Polrev(t,{v='x}): convert t (usually a vector or a power series) into a polynomial with variable v, starting with the constant term."},
{"Qfb",0,(void*)Qfb0,6,"GDGDG","Qfb(a,{b},{c}): binary quadratic form a*x^2+b*x*y+c*y^2."},
{"Ser",0,(void*)Ser0,6,"GDnDGDP","Ser(s,{v='x},{d=seriesprecision}): convert s into a power series with variable v and precision d, starting with the constant coefficient."},
{"Set",0,(void*)gtoset,6,"DG","Set({x=[]}): convert x into a set, i.e. a row vector with strictly increasing coefficients. Empty set if x is omitted."},
{"Str",0,(void*)Str,6,"s*","Str({x}*): concatenates its (string) argument into a single string."},
{"Strchr",0,(void*)pari_strchr,2,"G","Strchr(x): deprecated alias for strchr."},
{"Strexpand",0,(void*)strexpand,2,"s*","Strexpand({x}*): deprecated alias for strexpand"},
{"Strprintf",0,(void*)strprintf,2,"ss*","Strprintf(fmt,{x}*): deprecated alias for strprintf."},
{"Strtex",0,(void*)strtex,2,"s*","Strtex({x}*): deprecated alias for strtex."},
{"Vec",0,(void*)gtovec0,6,"GD0,L,","Vec(x,{n}): transforms the object x into a vector of dimension n."},
{"Vecrev",0,(void*)gtovecrev0,6,"GD0,L,","Vecrev(x,{n}): transforms the object x into a vector of dimension n in reverse order with respect to Vec(x,{n})."},
{"Vecsmall",0,(void*)gtovecsmall0,6,"GD0,L,","Vecsmall(x,{n}): transforms the object x into a VECSMALL of dimension n."},
{"[_.._]",0,(void*)vecrange,27,"GG","[a..b] = [a,a+1,...,b]"},
{"[_|_<-_,_;_]",0,(void*)vecexpr1,27,"mGVDEDE","[a(x)|x<-b,c(x);...]"},
{"[_|_<-_,_]",0,(void*)vecexpr0,27,"GVDEDE","[a(x)|x<-b,c(x)] = apply(a,select(c,b))"},
{"[_|_=_,_;_]",0,(void*)vecexpreq1,27,"mGVDEDE","[a(x)|x=b,c(x);...]"},
{"[_|_=_,_]",0,(void*)vecexpreq0,27,"GVDEDE","[a(x)|x=b,c(x)]"},
{"_!",0,(void*)mpfact,25,"L","n!: factorial of n."},
{"_!=_",0,(void*)gne,25,"GG","a!=b: true if a and b are not equal."},
{"_#",0,(void*)mpprimorial,25,"L","n#: primorial of n."},
{"_%=_",0,(void*)gmode,25,"&G","x%=y: shortcut for x=x%y."},
{"_%_",0,(void*)gmod,25,"GG","x%y: Euclidean remainder of x and y."},
{"_&&_",0,(void*)andpari,25,"GE","a&&b: boolean operator \"and\"."},
{"_'",0,(void*)deriv,25,"GDn","x': derivative of x with respect to the main variable."},
{"_'_",0,(void*)derivn,25,"GLDn","x': derivative of x with respect to the main variable."},
{"_(_)",0,NULL,25,NULL,"f(a,b,...): evaluate the function f on a,b,..."},
{"_*=_",0,(void*)gmule,25,"&G","x*=y: shortcut for x=x*y."},
{"_*_",0,(void*)gmul,25,"GG","x*y: product of x and y."},
{"_++",0,(void*)gadd1e,25,"&","x++: set x to x+1."},
{"_+=_",0,(void*)gadde,25,"&G","x+=y: shortcut for x=x+y."},
{"_+_",0,(void*)gadd,25,"GG","x+y: sum of x and y."},
{"_--",0,(void*)gsub1e,25,"&","x--: set x to x-1."},
{"_-=_",0,(void*)gsube,25,"&G","x-=y: shortcut for x=x-y."},
{"_-_",0,(void*)gsub,25,"GG","x-y: difference of x and y."},
{"_.a1",0,(void*)member_a1,26,"mG","_.a1"},
{"_.a2",0,(void*)member_a2,26,"mG","_.a2"},
{"_.a3",0,(void*)member_a3,26,"mG","_.a3"},
{"_.a4",0,(void*)member_a4,26,"mG","_.a4"},
{"_.a6",0,(void*)member_a6,26,"mG","_.a6"},
{"_.area",0,(void*)member_area,26,"mG","_.area"},
{"_.b2",0,(void*)member_b2,26,"mG","_.b2"},
{"_.b4",0,(void*)member_b4,26,"mG","_.b4"},
{"_.b6",0,(void*)member_b6,26,"mG","_.b6"},
{"_.b8",0,(void*)member_b8,26,"mG","_.b8"},
{"_.bid",0,(void*)member_bid,26,"mG","_.bid"},
{"_.bnf",0,(void*)member_bnf,26,"mG","_.bnf"},
{"_.c4",0,(void*)member_c4,26,"mG","_.c4"},
{"_.c6",0,(void*)member_c6,26,"mG","_.c6"},
{"_.clgp",0,(void*)member_clgp,26,"mG","_.clgp"},
{"_.codiff",0,(void*)member_codiff,26,"mG","_.codiff"},
{"_.cyc",0,(void*)member_cyc,26,"mG","_.cyc"},
{"_.diff",0,(void*)member_diff,26,"mG","_.diff"},
{"_.disc",0,(void*)member_disc,26,"mG","_.disc"},
{"_.e",0,(void*)member_e,26,"mG","_.e"},
{"_.eta",0,(void*)member_eta,26,"mG","_.eta"},
{"_.f",0,(void*)member_f,26,"mG","_.f"},
{"_.fu",0,(void*)member_fu,26,"G","_.fu"},
{"_.gen",0,(void*)member_gen,26,"mG","_.gen"},
{"_.group",0,(void*)member_group,26,"mG","_.group"},
{"_.index",0,(void*)member_index,26,"mG","_.index"},
{"_.j",0,(void*)member_j,26,"mG","_.j"},
{"_.mod",0,(void*)member_mod,26,"mG","_.mod"},
{"_.nf",0,(void*)member_nf,26,"mG","_.nf"},
{"_.no",0,(void*)member_no,26,"mG","_.no"},
{"_.normfu",0,(void*)member_normfu,26,"mG","_.normfu"},
{"_.omega",0,(void*)member_omega,26,"mG","_.omega"},
{"_.orders",0,(void*)member_orders,26,"mG","_.orders"},
{"_.p",0,(void*)member_p,26,"mG","_.p"},
{"_.pol",0,(void*)member_pol,26,"mG","_.pol"},
{"_.polabs",0,(void*)member_polabs,26,"mG","_.polabs"},
{"_.r1",0,(void*)member_r1,26,"mG","_.r1"},
{"_.r2",0,(void*)member_r2,26,"mG","_.r2"},
{"_.reg",0,(void*)member_reg,26,"mG","_.reg"},
{"_.roots",0,(void*)member_roots,26,"mG","_.roots"},
{"_.sign",0,(void*)member_sign,26,"mG","_.sign"},
{"_.t2",0,(void*)member_t2,26,"G","_.t2"},
{"_.tate",0,(void*)member_tate,26,"mG","_.tate"},
{"_.tu",0,(void*)member_tu,26,"G","_.tu"},
{"_.zk",0,(void*)member_zk,26,"mG","_.zk"},
{"_.zkst",0,(void*)member_zkst,26,"mG","_.zkst"},
{"_/=_",0,(void*)gdive,25,"&G","x/=y: shortcut for x=x/y."},
{"_/_",0,(void*)gdiv,25,"GG","x/y: quotient of x and y."},
{"_<<=_",0,(void*)gshiftle,25,"&L","x<<=y: shortcut for x=x<<y."},
{"_<<_",0,(void*)gshift,25,"GL","x<<y: compute shift(x,y)."},
{"_<=_",0,(void*)gle,25,"GG","x<=y: return 1 if x is less or equal to y, 0 otherwise."},
{"_<_",0,(void*)glt,25,"GG","x<y: return 1 if x is strictly less than y, 0 otherwise."},
{"_===_",0,(void*)gidentical,25,"iGG","x===y: return 1 if x and y are identical, 0 otherwise."},
{"_==_",0,(void*)geq,25,"GG","x==y: return 1 if x and y are equal, 0 otherwise."},
{"_>=_",0,(void*)gge,25,"GG","x>=y: return 1 if x is greater or equal to y, 0 otherwise."},
{"_>>=_",0,(void*)gshiftre,25,"&L","x>>=y: shortcut for x=x>>y."},
{"_>>_",0,(void*)gshift_right,25,"GL","x>>y: compute shift(x,-y)."},
{"_>_",0,(void*)ggt,25,"GG","x>y: return 1 if x is strictly greater than y, 0 otherwise."},
{"_F2xq_log_Coppersmith_worker",0,(void*)F2xq_log_Coppersmith_worker,27,"GLGG","F2xq_log_Coppersmith_worker: worker for F2xq_log_Coppersmith"},
{"_Flxq_log_Coppersmith_worker",0,(void*)Flxq_log_Coppersmith_worker,27,"GLGG","Flxq_log_Coppersmith_worker: worker for Flxq_log_Coppersmith"},
{"_FpM_ratlift_worker",0,(void*)FpM_ratlift_worker,27,"GGG","worker for FpM_ratlift"},
{"_Fp_log_sieve_worker",0,(void*)Fp_log_sieve_worker,27,"LLGGGGGG","Fp_log_sieve_worker: worker for Fp_log_sieve"},
{"_QM_charpoly_ZX_worker",0,(void*)QM_charpoly_ZX_worker,27,"GGG","worker for QM_charpoly_ZX"},
{"_QXQ_div_worker",0,(void*)QXQ_div_worker,27,"GGGG","worker for QXQ_div"},
{"_QXQ_inv_worker",0,(void*)QXQ_inv_worker,27,"GGG","worker for QXQ_inv"},
{"_RgM_ZM_mul_worker",0,(void*)RgM_ZM_mul_worker,27,"GG","worker for RgM_ZM_mul"},
{"_ZM_det_worker",0,(void*)ZM_det_worker,27,"GG","worker for ZM_det"},
{"_ZM_gauss_worker",0,(void*)ZM_gauss_worker,27,"GGG","worker for ZM_gauss"},
{"_ZM_inv_worker",0,(void*)ZM_inv_worker,27,"GG","worker for ZM_inv"},
{"_ZM_ker_worker",0,(void*)ZM_ker_worker,27,"GG","worker for ZM_ker"},
{"_ZM_mul_worker",0,(void*)ZM_mul_worker,27,"GGG","worker for ZM_mul"},
{"_ZM_sqr_worker",0,(void*)ZM_sqr_worker,27,"GG","worker for ZM_sqr"},
{"_ZXQXQ_minpoly_worker",0,(void*)ZXQXQ_minpoly_worker,27,"GGGGGL","worker for ZXQXQ_minpoly"},
{"_ZXQX_composedsum_worker",0,(void*)ZXQX_composedsum_worker,27,"GGGG","worker for ZXQX_composedsum"},
{"_ZXQX_resultant_worker",0,(void*)ZXQX_resultant_worker,27,"GGGGG","worker for ZXQX_resultant"},
{"_ZXQ_minpoly_worker",0,(void*)ZXQ_minpoly_worker,27,"GGGGL","worker for ZXQ_minpoly"},
{"_ZXX_resultant_worker",0,(void*)ZXX_resultant_worker,27,"GGGG","worker for ZXX_resultant"},
{"_ZX_ZXY_resultant_worker",0,(void*)ZX_ZXY_resultant_worker,27,"GGGGG","worker for ZX_ZXY_resultant"},
{"_ZX_composedsum_worker",0,(void*)ZX_composedsum_worker,27,"GGG","worker for ZX_composedsum"},
{"_ZX_gcd_worker",0,(void*)ZX_gcd_worker,27,"GGGG","worker for ZX_gcd"},
{"_ZX_resultant_worker",0,(void*)ZX_resultant_worker,27,"GGGG","worker for ZX_resultant"},
{"_ZabM_inv_worker",0,(void*)ZabM_inv_worker,27,"GGG","worker for ZabM_inv"},
{"_[_,]",0,NULL,25,NULL,"x[y,]: y-th row of x."},
{"_[_,_]",0,NULL,25,NULL,"x[i{,j}]: i coefficient of a vector, i,j coefficient of a matrix"},
{"_[_.._,_.._]",0,(void*)matslice0,25,"GD0,L,D0,L,D0,L,D0,L,","x[a..b,c..d] = [x[a,  c], x[a,  c+1], ..., x[a,  d];                      x[a+1,c], x[a+1,c+1], ..., x[a+1,d];                        ...      ...              ...                      x[b,  c], x[b,  c+1], ..., x[b,  d]]"},
{"_[_.._]",0,(void*)vecslice0,25,"GD0,L,L","x[a..b] = [x[a], x[a+1], ..., x[b]]"},
{"_\\/=_",0,(void*)gdivrounde,25,"&G","x\\/=y: shortcut for x=x\\/y."},
{"_\\/_",0,(void*)gdivround,25,"GG","x\\/y: rounded Euclidean quotient of x and y."},
{"_\\=_",0,(void*)gdivente,25,"&G","x\\=y: shortcut for x=x\\y."},
{"_\\_",0,(void*)gdivent,25,"GG","x\\y: Euclidean quotient of x and y."},
{"_^_",0,(void*)gpow,25,"GGp","x^y: compute x to the power y."},
{"_^s",0,(void*)gpowgs,27,"GL","return x^n where n is a small integer"},
{"__",0,NULL,25,NULL,"__: integral concatenation of strings."},
{"_aprcl_step4_worker",0,(void*)aprcl_step4_worker,27,"UGGG","worker for isprime (APRCL step 4)"},
{"_aprcl_step6_worker",0,(void*)aprcl_step6_worker,27,"GLGGG","worker for isprime (APRCL step 6)"},
{"_bnfinit_FP_worker",0,(void*)bnfinit_FP_worker,27,"GGGLGLLU","worker for bnfinit"},
{"_chinese_unit_worker",0,(void*)chinese_unit_worker,27,"GGGGGG","worker for _.fu"},
{"_derivfun",0,(void*)derivfun0,27,"GGGD1,L,p","_derivfun(args,def,closure,k) numerical kth-derivation of closure with respect to the first variable at args"},
{"_dirartin_worker",0,(void*)dirartin_worker,27,"GUGGGG","lfunartin worker"},
{"_direllnf_worker",0,(void*)direllnf_worker,27,"GUG","ellan worker"},
{"_direllsympow_worker",0,(void*)direllsympow_worker,27,"GUGU","lfunsympow worker"},
{"_dirgenus2_worker",0,(void*)dirgenus2_worker,27,"GLG","lfungenus2 worker"},
{"_dirhgm_worker",0,(void*)dirhgm_worker,27,"GUGG","worker for hgmcoefs"},
{"_ecpp_ispsp_worker",0,(void*)ecpp_ispsp_worker,27,"G","worker for isprime (ECPP ispseudoprime step)"},
{"_ecpp_sqrt_worker",0,(void*)ecpp_sqrt_worker,27,"GGG","worker for isprime (ECPP sqrt step)"},
{"_ecpp_step2_worker",0,(void*)ecpp_step2_worker,27,"GGGL","worker for isprime (step 2)"},
{"_eisker_worker",0,(void*)eisker_worker,27,"GGGGG","worker for eisker"},
{"_ellQ_factorback_worker",0,(void*)ellQ_factorback_worker,27,"GGGGU","worker for ellQ_factorback"},
{"_ellapQ_zv_worker",0,(void*)ellapQ_zv_worker,27,"GLG","ellan worker"},
{"_eval_mnemonic",0,(void*)eval_mnemonic,27,"lGs","Convert a mnemonic string to a flag."},
{"_factor_Aurifeuille",0,(void*)factor_Aurifeuille,27,"GL","_factor_Aurifeuille(a,d): return an algebraic factor of Phi_d(a), a != 0"},
{"_factor_Aurifeuille_prime",0,(void*)factor_Aurifeuille_prime,27,"GL","_factor_Aurifeuille_prime(p,d): return an algebraic factor of Phi_d(p), p prime"},
{"_heegnersum_worker",0,(void*)heegnersum_worker,27,"GGLL","worker for heegnersum"},
{"_inv",0,(void*)ginv,27,"G","return x^-1 where n is a small integer"},
{"_lerch_worker",0,(void*)lerch_worker,27,"GG","_lerch_worker(E,t): worker for lerchzeta"},
{"_lfuninit_theta2_worker",0,(void*)lfuninit_theta2_worker,27,"LGGGGGG","worker for lfuninit using theta2"},
{"_lfuninit_worker",0,(void*)lfuninit_worker,27,"LGGGGGGGG","worker for lfuninit"},
{"_multi_if",0,(void*)ifpari_multi,27,"GE*","internal variant of if() that allows more than 3 arguments."},
{"_nf_multable_worker",0,(void*)nf_multable_worker,27,"GGGG","worker for nfinit (multiplication table)"},
{"_nflist_A462_worker",0,(void*)nflist_A462_worker,27,"GGGGG","nflist_A462_worker(P3,X,Xinf,listarch,GAL): auxiliary."},
{"_nflist_A46S46P_worker",0,(void*)nflist_A46S46P_worker,27,"GGGG","nflist_A46S46P_worker(P3,Xinf,sqX,cards): auxiliary."},
{"_nflist_A4S4_worker",0,(void*)nflist_A4S4_worker,27,"GGGG","nflist_A4S4_worker(P3,X,Xinf,cardsprec): auxiliary."},
{"_nflist_C32C4_worker",0,(void*)nflist_C32C4_worker,27,"GGGG","nflist_C32C4_worker(P4,X,Xinf,GAL): auxiliary."},
{"_nflist_C32D4_worker",0,(void*)nflist_C32D4_worker,27,"GGGG","nflist_C32D4_worker(P,X,Xinf,gs): auxiliary."},
{"_nflist_C3C3_worker",0,(void*)nflist_C3C3_worker,27,"GGGG","nflist_C3C3_worker(gi,V3,V3D,X): auxiliary."},
{"_nflist_C3_worker",0,(void*)nflist_C3_worker,27,"GG","nflist_C3_worker(gv,T): auxiliary."},
{"_nflist_C4vec_worker",0,(void*)nflist_C4vec_worker,27,"GGGG","nflist_C4vec_worker(gm,X,Xinf,X2,gs): auxiliary."},
{"_nflist_C5_worker",0,(void*)nflist_C5_worker,27,"GG","nflist_C5_worker(N,bnfC5): auxiliary."},
{"_nflist_C6_worker",0,(void*)nflist_C6_worker,27,"GGGGG","nflist_C6_worker(P3,X,Xinf,M,T): auxiliary."},
{"_nflist_C9_worker",0,(void*)nflist_C9_worker,27,"GGG","nflist_C9_worker(P,X,Xinf): auxiliary."},
{"_nflist_CL_worker",0,(void*)nflist_CL_worker,27,"GGG","nflist_CL_worker(Fcond,bnf,ellprec): auxiliary."},
{"_nflist_D4_worker",0,(void*)nflist_D4_worker,27,"GGGG","nflist_D4_worker(D,X,Xinf,listarch): auxiliary."},
{"_nflist_D612_worker",0,(void*)nflist_D612_worker,27,"GGGG","nflist_D612_worker(P3,X,Xinf,X2,limd2s2): auxiliary."},
{"_nflist_D9_worker",0,(void*)nflist_D9_worker,27,"GGG","nflist_D9_worker(P2,X,Xinf): auxiliary."},
{"_nflist_DL_worker",0,(void*)nflist_DL_worker,27,"GGGGGG","nflist_DL_worker(P2,X1p,X0p,X,Xinf,ells): auxiliary."},
{"_nflist_Mgen_worker",0,(void*)nflist_Mgen_worker,27,"GGGG","nflist_Mgen_worker(field,X,Xinf,ella): auxiliary."},
{"_nflist_S32_worker",0,(void*)nflist_S32_worker,27,"GGGGG","nflist_S32_worker(all1,X,Xinf,V3,sprec): auxiliary."},
{"_nflist_S36_worker",0,(void*)nflist_S36_worker,27,"GGG","nflist_S36_worker(pol,X,Xinf,X2): auxiliary."},
{"_nflist_S3C3_worker",0,(void*)nflist_S3C3_worker,27,"GGG","nflist_S3C3_worker(D2,X,Xinf,X2): auxiliary."},
{"_nflist_S3I_worker",0,(void*)nflist_S3I_worker,27,"GG","nflist_S3I_worker(ga,ALLCTS): auxiliary."},
{"_nflist_S3R_worker",0,(void*)nflist_S3R_worker,27,"GG","nflist_S3R_worker(ga,ALLCTS): auxiliary."},
{"_nflist_S462_worker",0,(void*)nflist_S462_worker,27,"GGGGG","nflist_S462_worker(P3,X,Xinf,listarch,GAL): auxiliary."},
{"_nflist_S46M_worker",0,(void*)nflist_S46M_worker,27,"GGGG","nflist_S46M_worker(P3,X,Xinf,sprec): auxiliary."},
{"_nflist_V4_worker",0,(void*)nflist_V4_worker,27,"GGGG","nflist_V4_worker(D1,X,Xinf,gs): auxiliary."},
{"_nfroots_worker",0,(void*)nfroots_worker,27,"GGGGL","_nfroots_worker"},
{"_nxMV_polint_worker",0,(void*)nxMV_polint_center_tree_worker,27,"GGGGG","used for parallel chinese"},
{"_parapply_slice_worker",0,(void*)parapply_slice_worker,27,"GG","_parapply_slice_worker(v,C): return [C(x) | x<-v]."},
{"_pareval_worker",0,(void*)pareval_worker,27,"G","_pareval_worker(C): evaluate the closure C."},
{"_parfor_worker",0,(void*)parfor_worker,27,"GG","_parfor_worker(i,C): evaluate the closure C on i and return [i,C(i)]"},
{"_parmatrix_worker",0,(void*)parmatrix_worker,27,"GGG","_parmatrix_worker(i,j,C): evaluate the closure C on i,j"},
{"_parsqf_worker",0,(void*)parsqf_worker,27,"GGG","_parsqf_worker(gk,vR,data): auxiliary."},
{"_parsum_slice_worker",0,(void*)parsum_slice_worker,27,"GGGG","_parsum_slice_worker(a,b,m,C): return sum(k=0,(b-a)\\m,C(a+k*m)). a and m must be integers and m must be positive."},
{"_parsumprimefun_worker",0,(void*)parsumprimefun_worker,27,"GGGGGG","_parsumprimefun_worker(gk,s,zerf,data,vW,f): auxiliary"},
{"_partmap_reverse_frac_worker",0,(void*)partmap_reverse_frac_worker,27,"GGGGGL","worker for partmap_reverse_frac"},
{"_parvector_worker",0,(void*)parvector_worker,27,"GG","_parvector_worker(i,C): evaluate the closure C on i."},
{"_polclass_worker",0,(void*)polclass_worker,27,"GGG","used by polclass"},
{"_polint_worker",0,(void*)nmV_polint_center_tree_worker,27,"GGGGG","used for parallel chinese"},
{"_polmodular_worker",0,(void*)polmodular_worker,27,"GUGGGGLGGGG","used by polmodular"},
{"_primecertisvalid_ecpp_worker",0,(void*)primecertisvalid_ecpp_worker,27,"G","worker for primecertisvalid"},
{"_ramanujantau_worker",0,(void*)ramanujantau_worker,27,"GGGG","worker for ramanujantau"},
{"_safecoeff",0,NULL,25,NULL,"safe version of x[a], x[,a] and x[a,b]. Must be lvalues."},
{"_serh_worker",0,(void*)serh_worker,27,"GGGGG","_serh_worker(gk,V,a,ns,gprec): auxiliary."},
{"_taugen_n_worker",0,(void*)taugen_n_worker,27,"GGG","worker for ramanujantau"},
{"_void_if",0,(void*)ifpari_void,27,"vGDIDI","internal variant of if() that does not return a value."},
{"_||_",0,(void*)orpari,25,"GE","a||b: boolean operator \"or\" (inclusive)."},
{"_~",0,(void*)gtrans,25,"G","x~: transpose of x."},
{"abs",0,(void*)gabs,12,"Gp","abs(x): absolute value (or modulus) of x."},
{"acos",0,(void*)gacos,12,"Gp","acos(x): arc cosine of x."},
{"acosh",0,(void*)gacosh,12,"Gp","acosh(x): inverse hyperbolic cosine of x."},
{"addhelp",0,(void*)addhelp,2,"vrs","addhelp(sym,str): add/change help message for the symbol sym."},
{"addprimes",0,(void*)addprimes,8,"DG","addprimes({x=[]}): add primes in the vector x to the prime table to be used in trial division. x may also be a single integer. Composite \"primes\" are NOT allowed."},
{"agm",0,(void*)agm,12,"GGp","agm(x,y): arithmetic-geometric mean of x and y."},
{"airy",0,(void*)airy,12,"Gp","airy(z): Airy [Ai,Bi] function of argument z."},
{"alarm",0,(void*)gp_alarm,2,"D0,L,DE","alarm({s = 0},{code}): if code is omitted, trigger an \"e_ALARM\" exception after s seconds (wall-clock time), cancelling any previously set alarm; stop a pending alarm if s = 0 or is omitted. Otherwise, evaluate code, aborting after s seconds."},
{"algadd",0,(void*)algadd,17,"DGGG","algadd({al},x,y): element x+y in al (Hamilton quaternions if omitted)."},
{"algalgtobasis",0,(void*)algalgtobasis,17,"GG","algalgtobasis(al,x): transforms the element x of the algebra al into a column vector on the integral basis of al."},
{"algaut",0,(void*)algaut,17,"mG","algaut(al): the stored automorphism of the splitting field of the cyclic algebra al."},
{"algb",0,(void*)algb,17,"mG","algb(al): the element b of the center of the cyclic algebra al used to define it."},
{"algbasis",0,(void*)algbasis,17,"mG","algbasis(al): basis of the stored order of the central simple algebra al."},
{"algbasistoalg",0,(void*)algbasistoalg,17,"GG","algbasistoalg(al,x): transforms the column vector x on the integral basis of al into an element of al in algebraic form."},
{"algbasistoquat",0,(void*)algbasistoquat,17,"GG","algbasistoquat(al,x): transforms the column vector x on the integral basis of al into a quaternion x expressed on the basis (1,i,j,ij)."},
{"algcenter",0,(void*)algcenter,17,"mG","algcenter(al): center of the algebra al."},
{"algcentralproj",0,(void*)alg_centralproj,17,"GGD0,L,","algcentralproj(al,z,{maps=0}): projections of the algebra al on the orthogonal central idempotents z[i]."},
{"algchar",0,(void*)algchar,17,"mG","algchar(al): characteristic of the algebra al."},
{"algcharpoly",0,(void*)algcharpoly,17,"DGGDnD0,L,","algcharpoly({al},b,{v='x},{abs=0}): (reduced) characteristic polynomial of b in al (Hamilton quaternions if omitted), with respect to the variable v."},
{"algdegree",0,(void*)algdegree,17,"lG","algdegree(al): degree of the central simple algebra al."},
{"algdep",0,(void*)algdep0,11,"GLD0,L,","algdep(z,k,{flag=0}): algebraic relations up to degree k of z, using lindep([1,z,...,z^k], flag)."},
{"algdim",0,(void*)algdim,17,"lGD0,L,","algdim(al,{abs=0}): dimension of the algebra al."},
{"algdisc",0,(void*)algdisc,17,"G","algdisc(al): discriminant of the stored order of the algebra al."},
{"algdivl",0,(void*)algdivl,17,"DGGG","algdivl({al},x,y): element x\\y in al (Hamilton quaternions if omitted)."},
{"algdivr",0,(void*)algdivr,17,"DGGG","algdivr({al},x,y): element x/y in al (Hamilton quaternions if omitted)."},
{"algeichlerbasis",0,(void*)algeichlerbasis,17,"GG","algeichlerbasis(al,N): basis of Eichler order of level N in al."},
{"algeltfromnf",0,(void*)algeltfromnf,17,"GG","algeltfromnf(al,x): returns x as an element of al, where x belongs to the center of al, a number field."},
{"alggroup",0,(void*)alggroup,17,"GDG","alggroup(gal,{p=0}): constructs the group algebra of gal over Q (resp. Fp)."},
{"alggroupcenter",0,(void*)alggroupcenter,17,"GDGD&","alggroupcenter(gal,{p=0},{&cc}): constructs the center of the group algebra of gal over Q (resp. Fp), and sets cc to the conjugacy classes of gal."},
{"alghasse",0,(void*)alghasse,17,"GDG","alghasse(al,{pl}): the hasse invariant of the central simple algebra al at the place pl."},
{"alghassef",0,(void*)alghassef,17,"mG","alghassef(al): the hasse invariant of the central simple algebra al at finite places."},
{"alghassei",0,(void*)alghassei,17,"mG","alghassei(al): the hasse invariant of the central simple algebra al at infinite places."},
{"algindex",0,(void*)algindex,17,"lGDG","algindex(al,{pl}): the index of the central simple algebra al. If pl is set, it should be a prime ideal of the center or an integer between 1 and r1+r2, and in that case return the local index at the place pl instead."},
{"alginit",0,(void*)alginit,17,"GGDnD3,L,","alginit(B,C,{v},{flag=3}): initializes the central simple algebra defined by data B, C. Binary digits of the flag mean 1: compute a maximal order; 2: fully factor the discriminant instead of using a lazy factorisation."},
{"alginv",0,(void*)alginv,17,"DGG","alginv({al},x): element 1/x in al (Hamilton quaternions if omitted)."},
{"alginvbasis",0,(void*)alginvbasis,17,"mG","alginvbasis(al): basis of the natural order of the central simple algebra al in terms of the stored order."},
{"alginvol",0,(void*)alginvol,17,"DGDG","alginvol({al},{x}): element s(x) where s is the involution stored in al (Hamilton quaternions if omitted)."},
{"algisassociative",0,(void*)algisassociative,17,"iGDG","algisassociative(mt,{p=0}): true (1) if the multiplication table mt is suitable for algtableinit(mt,p), false (0) otherwise."},
{"algiscommutative",0,(void*)algiscommutative,17,"iG","algiscommutative(al): test whether the algebra al is commutative."},
{"algisdivision",0,(void*)algisdivision,17,"iGDG","algisdivision(al,{pl}): tests whether the central simple algebra al is a division algebra. If pl is set, it should be a prime ideal of the center or an integer between 1 and r1+r2, and in that case tests whether al is locally a division algebra at the place pl instead."},
{"algisdivl",0,(void*)algisdivl,17,"iDGGGD&","algisdivl({al},x,y,{&z}): tests whether y is left divisible by x and sets z to the left quotient x\\y."},
{"algisinv",0,(void*)algisinv,17,"iDGGD&","algisinv({al},x,{&ix}): tests whether x is invertible in al (Hamilton quaternions if omitted) and sets ix to the inverse of x."},
{"algisisom",0,(void*)algisisom,17,"iGGDG","algisisom(al,al2,{pl}): tests whether the central simple algebras al and al2 are isomorphic. If pl is set, test isomorphism locally at the place pl instead."},
{"algisquatalg",0,(void*)algisquatalg,17,"G","algisquatalg(al): returns [a,b] if al was constructed as the quaternion algebra (a,b)_F, and 0 otherwise."},
{"algisramified",0,(void*)algisramified,17,"iGDG","algisramified(al,{pl}): tests whether the central simple algebra al is ramified, i.e. not isomorphic to a matrix ring over its center. If pl is set, it should be a prime ideal of the center or an integer between 1 and r1+r2, and in that case tests whether al is locally ramified at the place pl instead."},
{"algissemisimple",0,(void*)algissemisimple,17,"iG","algissemisimple(al): test whether the algebra al is semisimple."},
{"algissimple",0,(void*)algissimple,17,"iGD0,L,","algissimple(al,{ss=0}): test whether the algebra al is simple."},
{"algissplit",0,(void*)algissplit,17,"iGDG","algissplit(al,{pl}): tests whether the central simple algebra al is split, i.e. isomorphic to a matrix ring over its center. If pl is set, it should be a prime ideal of the center or an integer between 1 and r1+r2, and in that case tests whether al is locally split at the place pl instead."},
{"alglatadd",0,(void*)alglatadd,17,"GGGD&","alglatadd(al,lat1,lat2,{&ptinter}): the sum of the lattices lat1 and lat2. If ptinter is present, sets it to the intersection of the lattices."},
{"alglatcontains",0,(void*)alglatcontains,17,"iGGGD&","alglatcontains(al,lat,x,{&ptc}): tests whether the lattice lat contains the element x. If ptc is present, sets it to the coordinates of x on the basis of lat."},
{"alglatelement",0,(void*)alglatelement,17,"GGG","alglatelement(al,lat,c): returns the element of al whose coordinates on the Z-basis of lat are c."},
{"alglathnf",0,(void*)alglathnf,17,"GGDG","alglathnf(al,m,{d=0}): the lattice generated by the columns of m, assuming that this lattice contains d times the integral basis of al."},
{"alglatindex",0,(void*)alglatindex,17,"GGG","alglatindex(al,lat1,lat2): the generalized index (lat2:lat1)."},
{"alglatinter",0,(void*)alglatinter,17,"GGGD&","alglatinter(al,lat1,lat2,{&ptsum}): the intersection of the lattices lat1 and lat2. If ptsum is present, sets it to the sum of the lattices."},
{"alglatlefttransporter",0,(void*)alglatlefttransporter,17,"GGG","alglatlefttransporter(al,lat1,lat2): the set of x in al such that x*lat1 is contained in lat2."},
{"alglatmul",0,(void*)alglatmul,17,"GGG","alglatmul(al,lat1,lat2): the lattice generated by the products of elements of lat1 and lat2."},
{"alglatrighttransporter",0,(void*)alglatrighttransporter,17,"GGG","alglatrighttransporter(al,lat1,lat2): the set of x in al such that lat1*x is contained in lat2."},
{"alglatsubset",0,(void*)alglatsubset,17,"iGGGD&","alglatsubset(al,lat1,lat2,{&ptindex}): tests whether lat1 is contained in lat2 and if true and ptindex is present, sets it to the index (lat2:lat1)."},
{"algmakeintegral",0,(void*)algmakeintegral,17,"GD0,L,","algmakeintegral(mt,{maps=0}): computes an integral multiplication table for an isomorphic algebra."},
{"algmodpr",0,(void*)algmodpr,17,"GGG","algmodpr(al,x,modP): image of x in al under the reduction map stored in modP, cf algmodprinit."},
{"algmodprinit",0,(void*)algmodprinit,17,"GGDn","algmodprinit(al,pr,{v}): initialises a reduction mod pr map."},
{"algmodprlift",0,(void*)algmodprlift,17,"GGG","algmodprlift(al,x,modP): a preimage of x under the reduction map stored in modP, cf algmodprinit."},
{"algmul",0,(void*)algmul,17,"DGGG","algmul({al},x,y): element x*y in al (Hamilton quaternions if omitted)."},
{"algmultable",0,(void*)algmultable,17,"mG","algmultable(al): multiplication table of al over its prime subfield."},
{"algneg",0,(void*)algneg,17,"DGG","algneg({al},x): element -x in al (Hamilton quaternions if omitted)."},
{"algnewprec",0,(void*)algnewprec,17,"Gp","algnewprec(al): returns a copy of the algebra structure al using the current (usually larger) precision."},
{"algnorm",0,(void*)algnorm,17,"DGGD0,L,","algnorm({al},x,{abs=0}): (reduced) norm of x in al (Hamilton quaternions if omitted)."},
{"algpoleval",0,(void*)algpoleval,17,"DGGG","algpoleval({al},T,b): T in K[X] evaluate T(b) in al (Hamilton quaternions if omitted)."},
{"algpow",0,(void*)algpow,17,"DGGG","algpow({al},x,n): element x^n in al (Hamilton quaternions if omitted)."},
{"algprimesubalg",0,(void*)algprimesubalg,17,"G","algprimesubalg(al): prime subalgebra of the positive characteristic, semisimple algebra al."},
{"algquattobasis",0,(void*)algquattobasis,17,"GG","algquattobasis(al,x): transforms the quaternion x expressed on the basis (1,i,j,ij) to a column vector on the integral basis of the quaternion algebra al."},
{"algquotient",0,(void*)alg_quotient,17,"GGD0,L,","algquotient(al,I,{maps=0}): quotient of the algebra al by the two-sided ideal I."},
{"algradical",0,(void*)algradical,17,"G","algradical(al): Jacobson radical of the algebra al."},
{"algramifiedplaces",0,(void*)algramifiedplaces,17,"G","algramifiedplaces(al): vector of the places of the center of al that ramify in al. Each place is described as an integer between 1 and r1 or as a prime ideal."},
{"algrandom",0,(void*)algrandom,17,"DGG","algrandom({al},b): random element in al (Hamilton quaternions if omitted) with coefficients in [-b,b]."},
{"algrelmultable",0,(void*)algrelmultable,17,"mG","algrelmultable(al): multiplication table of the central simple algebra al over its center."},
{"algsimpledec",0,(void*)algsimpledec,17,"GD0,L,","algsimpledec(al,{maps=0}): [J,dec] where J is the Jacobson radical of al and dec is the decomposition into simple algebras of the semisimple algebra al/J."},
{"algskolemnoether",0,(void*)algskolemnoether,17,"GGG","algskolemnoether(al,a,fa): inner automorphism of central simple algebra al that induces a -> fa."},
{"algsplit",0,(void*)algsplit,17,"GDn","algsplit(al,{v='x}): computes an isomorphism between al and M_d(F_q)."},
{"algsplittingdata",0,(void*)algsplittingdata,17,"mG","algsplittingdata(al): data stored in the central simple algebra al to compute a splitting of al over an extension."},
{"algsplittingfield",0,(void*)algsplittingfield,17,"mG","algsplittingfield(al): the stored splitting field of the central simple algebra al."},
{"algsqr",0,(void*)algsqr,17,"DGG","algsqr({al},x): element x^2 in al (Hamilton quaternions if omitted)."},
{"algsub",0,(void*)algsub,17,"DGGG","algsub({al},x,y): element x-y in al (Hamilton quaternions if omitted)."},
{"algsubalg",0,(void*)algsubalg,17,"GG","algsubalg(al,B): subalgebra of al with basis B."},
{"algtableinit",0,(void*)algtableinit,17,"GDG","algtableinit(mt,{p=0}): initializes the associative algebra over Q (resp. Fp) defined by the multiplication table mt."},
{"algtensor",0,(void*)algtensor,17,"GGD3,L,","algtensor(al1,al2,{flag=3}): tensor product of al1 and al2."},
{"algtomatrix",0,(void*)algtomatrix,17,"DGGD0,L,","algtomatrix({al},x,{abs=0}): left multiplication table of x (table algebra or abs=1) or image of x under a splitting of al (CSA and abs=0)."},
{"algtrace",0,(void*)algtrace,17,"DGGD0,L,","algtrace({al},x,{abs=0}): (reduced) trace of x in al (Hamilton quaternions if omitted)."},
{"algtype",0,(void*)algtype,17,"lG","algtype(al): type of the algebra al."},
{"alias",0,(void*)alias0,2,"vrr","alias(newsym,sym): defines the symbol newsym as an alias for the symbol sym."},
{"allocatemem",0,(void*)gp_allocatemem,2,"vDG","allocatemem({s=0}): allocates a new stack of s bytes. doubles the stack if s is omitted."},
{"apply",0,(void*)apply0,2,"GG","apply(f,A): apply function f to each entry in A."},
{"arg",0,(void*)garg,12,"Gp","arg(x): argument of x, such that -pi<arg(x)<=pi."},
{"arity",0,(void*)arity0,2,"G","arity(C): return the arity of the closure C."},
{"asin",0,(void*)gasin,12,"Gp","asin(x): arc sine of x."},
{"asinh",0,(void*)gasinh,12,"Gp","asinh(x): inverse hyperbolic sine of x."},
{"asympnum",0,(void*)asympnum0,13,"GDGp","asympnum(expr,{alpha = 1}): asymptotic expansion of expr assuming it has rational coefficients with reasonable height; alpha is as in limitnum."},
{"asympnumraw",0,(void*)asympnumraw0,13,"GLDGp","asympnumraw(expr,N,{alpha = 1}): N+1 first terms of asymptotic expansion of expr as floating point numbers; alpha is as in limitnum."},
{"atan",0,(void*)gatan,12,"Gp","atan(x): arc tangent of x."},
{"atanh",0,(void*)gatanh,12,"Gp","atanh(x): inverse hyperbolic tangent of x."},
{"bernfrac",0,(void*)bernfrac,7,"L","bernfrac(n): Bernoulli number B_n, as a rational number."},
{"bernpol",0,(void*)bernpol_eval,7,"LDG","bernpol(n,{a='x}): Bernoulli polynomial B_n, evaluated at a"},
{"bernreal",0,(void*)bernreal,7,"Lp","bernreal(n): Bernoulli number B_n, as a real number with the current precision."},
{"bernvec",0,(void*)bernvec,7,"L","bernvec(n): returns a vector containing, as rational numbers, the Bernoulli numbers B_0, B_2, ..., B_{2n}."},
{"besselh1",0,(void*)hbessel1,12,"GGp","besselh1(nu,x): H^1-bessel function of index nu and argument x."},
{"besselh2",0,(void*)hbessel2,12,"GGp","besselh2(nu,x): H^2-bessel function of index nu and argument x."},
{"besseli",0,(void*)ibessel,12,"GGp","besseli(nu,x): I-bessel function of index nu and argument x."},
{"besselj",0,(void*)jbessel,12,"GGp","besselj(nu,x): J-bessel function of index nu and argument x."},
{"besseljh",0,(void*)jbesselh,12,"GGp","besseljh(n,x): J-bessel function of index n+1/2 and argument x, where n is a nonnegative integer."},
{"besseljzero",0,(void*)besseljzero,12,"GD1,L,b","besseljzero(nu,{k=1}): k-th zero of the J-bessel function of index nu. Works for real and complex ordrers but the result is guaranteed only if nu is nonnegative."},
{"besselk",0,(void*)kbessel,12,"GGp","besselk(nu,x): K-bessel function of index nu and argument x."},
{"besseln",0,(void*)ybessel,12,"GGp","besseln(nu,x): deprecated alias for bessely."},
{"bessely",0,(void*)ybessel,12,"GGp","bessely(nu,x): Y-bessel function of index nu and argument x."},
{"besselyzero",0,(void*)besselyzero,12,"GD1,L,b","besselyzero(nu,{k=1}): k-th zero of the Y-bessel function of index nu. Works for real and complex ordrers but the result is guaranteed only if nu is nonnegative."},
{"bestappr",0,(void*)bestappr,5,"GDG","bestappr(x,{B}): return a rational approximation to x, whose denominator is limited by B, if present. This function applies to reals, intmods, p-adics, and rationals of course. Otherwise it applies recursively to all components."},
{"bestapprPade",0,(void*)bestapprPade0,5,"GD-1,L,D-1,L,","bestapprPade(x,{B},{Q}): returns a rational function approximation to x. This function applies to series, polmods, and rational functions of course. Otherwise it applies recursively to all components."},
{"bestapprnf",0,(void*)bestapprnf,5,"GGDGp","bestapprnf(V,T,{rootT}): T being an integral polynomial and V being a scalar, vector, or matrix, return a reasonable approximation of V with polmods modulo T. The rootT argument, if present, must be an element of polroots(T), i.e. a root of T fixing a complex embedding of Q[x]/(T)."},
{"bezout",0,(void*)gcdext0,5,"GG","bezout(x,y): deprecated alias for gcdext."},
{"bezoutres",0,(void*)polresultantext0,10,"GGDn","bezoutres(A,B,{v}): deprecated alias for polresultantext."},
{"bigomega",0,(void*)bigomega,8,"lG","bigomega(x): number of prime divisors of x, counted with multiplicity."},
{"binary",0,(void*)binaire,6,"G","binary(x): gives the vector formed by the binary digits of x (x integer)."},
{"binomial",0,(void*)binomial0,7,"GDG","binomial(n,{k}): binomial coefficient n*(n-1)...*(n-k+1)/k! defined for k in Z and any n. If k is omitted and n a nonnegative integer, return the vector [binomial(n,0),...,binomial(n,n)]."},
{"bitand",0,(void*)gbitand,6,"GG","bitand(x,y): bitwise \"and\" of two integers x and y. Negative numbers behave as if modulo big power of 2."},
{"bitclear",0,(void*)bitclear,6,"vWL","bitclear(~x,n): clear bit n of x in place, assuming x >= 2^(n+1)."},
{"bitflip",0,(void*)bitflip,6,"vWL","bitflip(~x,n): flip bit n of x in place, assuming x >= 2^(n+1)."},
{"bitneg",0,(void*)gbitneg,6,"GD-1,L,","bitneg(x,{n=-1}): bitwise negation of an integers x truncated to n bits. n=-1 means represent infinite sequences of bit 1 as negative numbers. Negative numbers behave as if modulo big power of 2."},
{"bitnegimply",0,(void*)gbitnegimply,6,"GG","bitnegimply(x,y): bitwise \"negated imply\" of two integers x and y, in other words, x BITAND BITNEG(y). Negative numbers behave as if modulo big power of 2."},
{"bitor",0,(void*)gbitor,6,"GG","bitor(x,y): bitwise \"or\" of two integers x and y. Negative numbers behave as if modulo big power of 2."},
{"bitprecision",0,(void*)bitprecision00,6,"GDG","bitprecision(x,{n}): if n is present and positive, return x at precision n bits. If n is omitted, return real precision of object x in bits."},
{"bitset",0,(void*)bitset,6,"vWL","bitset(~x,n): set bit n of x in place, assuming x >= 2^n."},
{"bittest",0,(void*)gbittest,6,"GL","bittest(x,n): gives bit number n (coefficient of 2^n) of the integer x. Negative numbers behave as if modulo big power of 2."},
{"bitxor",0,(void*)gbitxor,6,"GG","bitxor(x,y): bitwise \"exclusive or\" of two integers x and y. Negative numbers behave as if modulo big power of 2."},
{"bnfcertify",0,(void*)bnfcertify0,14,"lGD0,L,","bnfcertify(bnf,{flag = 0}): certify the correctness (i.e. remove the GRH) of the bnf data output by bnfinit. If flag is present, only certify that the class group is a quotient of the one computed in bnf (much simpler in general)."},
{"bnfdecodemodule",0,(void*)decodemodule,14,"GG","bnfdecodemodule(nf,m): given a coded module m as in bnrdisclist, gives the true module."},
{"bnfinit",0,(void*)bnfinit0,14,"GD0,L,DGp","bnfinit(P,{flag=0},{tech=[]}): compute the necessary data for future use in ideal and unit group computations, including fundamental units if they are not too large. flag and tech are both optional. flag can be any of 0: default, 1: include all data in algebraic form (compact units). See manual for details about tech."},
{"bnfisintnorm",0,(void*)bnfisintnorm0,14,"GGD0,L,","bnfisintnorm(bnf,b,{flag=0}): computes a complete system of solutions (modulo units of positive norm) of the absolute norm equation N(a)=b, where a belongs to the maximal order of big number field bnf (if bnf is not certified, this depends on GRH). If (optional) flag is set, allows returning solutions in factored form."},
{"bnfisnorm",0,(void*)bnfisnorm,14,"GGD1,L,","bnfisnorm(bnf,x,{flag=1}): tries to tell whether x (in Q) is the norm of some fractional y (in bnf). Returns a vector [a,b] where x=Norm(a)*b. Looks for a solution which is a S-unit, with S a certain list of primes (in bnf) containing (among others) all primes dividing x. If bnf is known to be Galois, you may set flag=0 (in this case, x is a norm iff b=1). If flag is nonzero the program adds to S all the primes: dividing flag if flag<0, or less than flag if flag>0. The answer is guaranteed (i.e x norm iff b=1) under GRH, if S contains all primes less than 4log(disc(Bnf))^2, where Bnf is the Galois closure of bnf."},
{"bnfisprincipal",0,(void*)bnfisprincipal0,14,"GGD1,L,","bnfisprincipal(bnf,x,{flag=1}): bnf being output by bnfinit, gives [e,t], where e is the vector of exponents on the class group generators and t is the generator of the resulting principal ideal. In particular x is principal if and only if e is the zero vector. flag is optional, whose binary digits mean 1: output [e,t] (only e if unset); 2: increase precision until t can be computed (do not insist if unset); 4: return t in factored form (compact representation)."},
{"bnfissunit",0,(void*)bnfissunit,14,"GGG","bnfissunit(bnf,sfu,x): this function is obsolete, use bnfisunit."},
{"bnfisunit",0,(void*)bnfisunit0,14,"GGDG","bnfisunit(bnf,x,{U}): bnf being output by bnfinit, give the column vector of exponents of x on the fundamental units and the roots of unity if x is a unit, the empty vector otherwise. If U is present, as given by bnfunits, decompose x on the attached S-units generators."},
{"bnflog",0,(void*)bnflog,14,"GG","bnflog(bnf,l): let bnf be attached to a number field F and let l be a prime number. Return the subgroup of degree 0 classes in the logarithmic l-class group Cl~_F."},
{"bnflogdegree",0,(void*)bnflogdegree,14,"GGG","bnflogdegree(nf,A,l): let A be an ideal, return exp(deg_F A) the exponential of the l-adic logarithmic degree."},
{"bnflogef",0,(void*)bnflogef,14,"GG","bnflogef(nf,pr): return [e~, f~] the logarithmic ramification and residue degrees for the maximal ideal pr."},
{"bnfnarrow",0,(void*)bnfnarrow,14,"G","bnfnarrow(bnf): given a big number field as output by bnfinit, gives as a 3-component vector the structure of the narrow class group."},
{"bnfsignunit",0,(void*)signunits,14,"G","bnfsignunit(bnf): matrix of signs of the real embeddings of the system of fundamental units found by bnfinit."},
{"bnfsunit",0,(void*)bnfsunit,14,"GGp","bnfsunit(bnf,S): compute the fundamental S-units of the number field bnf output by bnfinit, S being a list of prime ideals. res[1] contains the S-units, res[5] the S-classgroup."},
{"bnfunits",0,(void*)bnfunits,14,"GDG","bnfunits(bnf,{S}): return the fundamental units of the number field bnf output by bnfinit; if S is present and is a list of prime ideals, compute fundamental S-units instead. The first component of the result contains the S-units, followed by fundamental units, followed by the torsion unit. The result may be used as an optional argument to bnfisunit."},
{"bnrL1",0,(void*)bnrL1,15,"GDGD0,L,p","bnrL1(bnr,{H},{flag=0}): bnr being output by bnrinit and H being a square matrix defining a congruence subgroup of bnr (the trivial subgroup if omitted), for each character of bnr trivial on this subgroup, compute L(1, chi) (or equivalently the first nonzero term c(chi) of the expansion at s = 0). The binary digits of flag mean 1: if 0 then compute the term c(chi) and return [r(chi), c(chi)] where r(chi) is the order of L(s, chi) at s = 0, or if 1 then compute the value at s = 1 (and in this case, only for nontrivial characters), 2: if 0 then compute the value of the primitive L-function attached to chi, if 1 then compute the value of the L-function L_S(s, chi) where S is the set of places dividing the modulus of bnr (and the infinite places), 3: return also the characters."},
{"bnrchar",0,(void*)bnrchar,15,"GGDG","bnrchar(G,g,{v}): returns all characters chi on G such that chi(g[i]) = e(v[i]); if v is omitted, returns all characters that are trivial on the g[i]."},
{"bnrclassfield",0,(void*)bnrclassfield,15,"GDGD0,L,p","bnrclassfield(bnr,{subgp},{flag=0}): bnr being as output by bnrinit, find a relative equation for the class field corresponding to the congruence subgroup described by (bnr,subgp). If flag=0, return a vector of polynomials such that the compositum of the corresponding fields is the class field; if flag=1 return a single relative polynomial; if flag=2 return a single absolute polynomial."},
{"bnrclassno",0,(void*)bnrclassno0,15,"GDGDG","bnrclassno(A,{B},{C}): relative degree of the class field defined by A,B,C. [A,{B},{C}] is of type [bnr], [bnr,subgroup], [bnf,modulus], or [bnf,modulus,subgroup]. Faster than bnrinit if only the ray class number is wanted."},
{"bnrclassnolist",0,(void*)bnrclassnolist,15,"GG","bnrclassnolist(bnf,list): if list is as output by ideallist or similar, gives list of corresponding ray class numbers."},
{"bnrcompositum",0,(void*)bnrcompositum,15,"GG","bnrcompositum(A,B): compositum [bnr,H] of the two abelian extensions given by A = [bnr1,H1] and B = [bnr2,H2], where bnr1 and bnr2 are attached to the same base field."},
{"bnrconductor",0,(void*)bnrconductor0,15,"GDGDGD0,L,","bnrconductor(A,{B},{C},{flag=0}): conductor f of the subfield of the ray class field given by A,B,C. flag is optional and can be 0: default, 1: returns [f, Cl_f, H], H subgroup of the ray class group modulo f defining the extension, 2: returns [f, bnr(f), H]."},
{"bnrconductorofchar",0,(void*)bnrconductorofchar,15,"GG","bnrconductorofchar(bnr,chi): this function is obsolete, use bnrconductor."},
{"bnrdisc",0,(void*)bnrdisc0,15,"GDGDGD0,L,","bnrdisc(A,{B},{C},{flag=0}): absolute or relative [N,R1,discf] of the field defined by A,B,C. [A,{B},{C}] is of type [bnr], [bnr,subgroup], [bnf, modulus] or [bnf,modulus,subgroup], where bnf is as output by bnfinit, bnr by bnrinit, and subgroup is the HNF matrix of a subgroup of the corresponding ray class group (if omitted, the trivial subgroup). flag is optional whose binary digits mean 1: give relative data; 2: return 0 if modulus is not the conductor."},
{"bnrdisclist",0,(void*)bnrdisclist0,15,"GGDG","bnrdisclist(bnf,bound,{arch}): list of discriminants of ray class fields of all conductors up to norm bound. The ramified Archimedean places are given by arch; all possible values are taken if arch is omitted. Supports the alternative syntax bnrdisclist(bnf,list), where list is as output by ideallist or ideallistarch (with units)."},
{"bnrgaloisapply",0,(void*)bnrgaloisapply,15,"GGG","bnrgaloisapply(bnr,mat,H): apply the automorphism given by its matrix mat to the congruence subgroup H given as a HNF matrix. The matrix mat can be computed with bnrgaloismatrix."},
{"bnrgaloismatrix",0,(void*)bnrgaloismatrix,15,"GG","bnrgaloismatrix(bnr,aut): return the matrix of the action of the automorphism aut of the base field bnf.nf on the generators of the ray class field bnr.gen; aut can be given as a polynomial, or a vector of automorphisms or a galois group as output by galoisinit, in which case a vector of matrices is returned (in the later case, only for the generators aut.gen)."},
{"bnrinit",0,(void*)bnrinitmod,15,"GGD0,L,DG","bnrinit(bnf,f,{flag=0},{cycmod}): given a bnf as output by bnfinit and a modulus f, initializes data linked to the ray class group structure corresponding to this module. flag is optional, and can be 0: default, 1: compute also the generators. If the positive integer cycmod is present, only compute the ray class group modulo cycmod-th powers."},
{"bnrisconductor",0,(void*)bnrisconductor0,15,"lGDGDG","bnrisconductor(A,{B},{C}): returns 1 if the modulus is the conductor of the subfield of the ray class field given by A,B,C (see bnrdisc), and 0 otherwise. Slightly faster than bnrconductor if this is the only desired result."},
{"bnrisgalois",0,(void*)bnrisgalois,15,"lGGG","bnrisgalois(bnr,gal,H): check whether the class field attached to the subgroup H is Galois over the subfield of bnr.nf fixed by the Galois group gal, which can be given as output by galoisinit, or as a matrix or a vector of matrices as output by bnrgaloismatrix. The ray class field attached to bnr need to be Galois, which is not checked."},
{"bnrisprincipal",0,(void*)bnrisprincipal,15,"GGD1,L,","bnrisprincipal(bnr,x,{flag=1}): bnr being output by bnrinit and x being an ideal coprime to bnr.mod, returns [v,alpha], where v is the vector of exponents on the ray class group generators and alpha is the generator of the resulting principal ideal. If (optional) flag is set to 0, output only v."},
{"bnrmap",0,(void*)bnrmap,15,"GG","bnrmap(A,B): if A and B are bnr structures for the same bnf attached to moduli mA and mB with mB | mA, return the canonical surjection from A to B. Alternatively, if A is a map from bnrmap and B is a congruence subgroup or ray class character modulo mA, return the corresponding object on Cl(mB)."},
{"bnrrootnumber",0,(void*)bnrrootnumber,15,"GGD0,L,p","bnrrootnumber(bnr,chi,{flag=0}): returns the so-called Artin Root Number, i.e. the constant W appearing in the functional equation of the Hecke L-function attached to chi. Set flag = 1 if the character is known to be primitive."},
{"bnrstark",0,(void*)bnrstark,15,"GDGp","bnrstark(bnr,{subgroup}): bnr being as output by bnrinit, finds a relative equation for the class field corresponding to the module in bnr and the given congruence subgroup (the trivial subgroup if omitted) using Stark's units. The ground field and the class field must be totally real."},
{"bnrstarkunit",0,(void*)bnrstarkunit,15,"GDG","bnrstarkunit(bnr,{subgroup}): bnr being as output by bnrinit, returns the characteristic polynomial of the (conjectural) Stark unit corresponding to the module in bnr and the given congruence subgroup (the trivial subgroup if omitted). The ground field must be totally real and all but one infinite place must become complex in the class field."},
{"break",0,(void*)break0,1,"D1,L,","break({n=1}): interrupt execution of current instruction sequence, and exit from the n innermost enclosing loops."},
{"breakpoint",0,(void*)pari_breakpoint,1,"v","breakpoint(): interrupt the program and enter the breakloop. The program continues when the breakloop is exited."},
{"call",0,(void*)call0,2,"GG","call(f,A): A being a vector, evaluates f(A[1],...,A[#A])."},
{"ceil",0,(void*)gceil,6,"G","ceil(x): ceiling of x = smallest integer >= x."},
{"centerlift",0,(void*)centerlift0,6,"GDn","centerlift(x,{v}): centered lift of x. Same as lift except for intmod and padic components."},
{"characteristic",0,(void*)characteristic,6,"mG","characteristic(x): characteristic of the base ring over which x is defined."},
{"charconj",0,(void*)charconj0,9,"GG","charconj(cyc,chi): given a finite abelian group (by its elementary divisors cyc) and a character chi, return the conjugate character."},
{"chardiv",0,(void*)chardiv0,9,"GGG","chardiv(cyc,a,b): given a finite abelian group (by its elementary divisors cyc) and two characters a and b, return the character a/b."},
{"chareval",0,(void*)chareval,9,"GGGDG","chareval(G,chi,x,{z}): given an abelian group structure affording a discrete logarithm method, e.g. G = znstar(N,1) or a bnr structure, let x be an element of G and let chi be a character of G. This function returns the value of chi at x, where the encoding depends on the optional argument z; if z is omitted, we fix a canonical o-th root of 1, zeta_o, where o is the character order and return the rational number c/o where chi(x) = (zeta_o)^c."},
{"chargalois",0,(void*)chargalois,9,"GDG","chargalois(cyc,{ORD}): let cyc represent a finite abelian group G by its elementary divisors cyc, return a list of representatives for the Galois orbits of characters of G. If ORD is present, select characters depending on their orders: if ORD is a t_INT, restrict to orders less than this bound; if ORD is a t_VEC or t_VECSMALL, restrict to orders in the list."},
{"charker",0,(void*)charker0,9,"GG","charker(cyc,chi): given a finite abelian group (by its elementary divisors cyc) and a character chi, return its kernel."},
{"charmul",0,(void*)charmul0,9,"GGG","charmul(cyc,a,b): given a finite abelian group (by its elementary divisors cyc) and two characters a and b, return the product character ab."},
{"charorder",0,(void*)charorder0,9,"GG","charorder(cyc,chi): given a finite abelian group (by its elementary divisors cyc) and a character chi, return the order of chi."},
{"charpoly",0,(void*)charpoly0,11,"GDnD5,L,","charpoly(A,{v='x},{flag=5}): det(v*Id-A)=characteristic polynomial of the matrix or polmod A. flag is optional and ignored unless A is a matrix; it may be set to 0 (Le Verrier), 1 (Lagrange interpolation), 2 (Hessenberg form), 3 (Berkowitz), 4 (modular) if A is integral, or 5 (default, choose best method). Algorithms 0 (Le Verrier) and 1 (Lagrange) assume that n! is invertible, where n is the dimension of the matrix."},
{"charpow",0,(void*)charpow0,9,"GGG","charpow(cyc,a,n): given a finite abelian group (by its elementary divisors cyc) a character a and an integer n return the character a^n."},
{"chinese",0,(void*)chinese,5,"GDG","chinese(x,{y}): x,y being both intmods (or polmods) computes z in the same residue classes as x and y."},
{"cmp",0,(void*)cmp_universal,5,"iGG","cmp(x,y): compare two arbitrary objects x and y (1 if x>y, 0 if x=y, -1 if x<y). The function is used to implement sets, and has no useful mathematical meaning."},
{"component",0,(void*)compo,6,"GL","component(x,n): the n'th component of the internal representation of x. For vectors or matrices, it is simpler to use x[]. For list objects such as nf, bnf, bnr or ell, it is much easier to use member functions starting with \".\"."},
{"concat",0,(void*)gconcat,11,"GDG","concat(x,{y}): concatenation of x and y, which can be scalars, vectors or matrices, or lists (in this last case, both x and y have to be lists). If y is omitted, x has to be a list or row vector and its elements are concatenated."},
{"conj",0,(void*)gconj,6,"G","conj(x): the algebraic conjugate of x."},
{"conjvec",0,(void*)conjvec,6,"Gp","conjvec(z): conjugate vector of the algebraic number z."},
{"content",0,(void*)content0,5,"GDG","content(x,{D}): gcd of all the components of x, when this makes sense."},
{"contfrac",0,(void*)contfrac0,5,"GDGD0,L,","contfrac(x,{b},{nmax}): continued fraction expansion of x (x rational,real or rational function). b and nmax are both optional, where b is the vector of numerators of the continued fraction, and nmax is a bound for the number of terms in the continued fraction expansion."},
{"contfraceval",0,(void*)contfraceval,13,"GGD-1,L,","contfraceval(CF,t,{lim=-1}): given a continued fraction CF from contfracinit, evaluate the first lim terms of the continued fraction at t (all terms if lim is negative or omitted)."},
{"contfracinit",0,(void*)contfracinit,13,"GD-1,L,","contfracinit(M,{lim = -1}): given M representing the power series S = sum_{n>=0} M[n+1]z^n, transform it into a continued fraction suitable for evaluation."},
{"contfracpnqn",0,(void*)contfracpnqn,5,"GD-1,L,","contfracpnqn(x,{n=-1}): [p_n,p_{n-1}; q_n,q_{n-1}] corresponding to the continued fraction x. If n >= 0 is present, returns all convergents from p_0/q_0 up to p_n/q_n."},
{"core",0,(void*)core0,8,"GD0,L,","core(n,{flag=0}): unique squarefree integer d dividing n such that n/d is a square. If (optional) flag is nonzero, output the two-component row vector [d,f], where d is the unique squarefree integer dividing n such that n/d=f^2 is a square."},
{"coredisc",0,(void*)coredisc0,8,"GD0,L,","coredisc(n,{flag=0}): discriminant of the quadratic field Q(sqrt(n)). If (optional) flag is nonzero, output a two-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."},
{"cos",0,(void*)gcos,12,"Gp","cos(x): cosine of x."},
{"cosh",0,(void*)gcosh,12,"Gp","cosh(x): hyperbolic cosine of x."},
{"cotan",0,(void*)gcotan,12,"Gp","cotan(x): cotangent of x."},
{"cotanh",0,(void*)gcotanh,12,"Gp","cotanh(x): hyperbolic cotangent of x."},
{"dbg_x",0,(void*)dbgGEN,1,"vGD-1,L,","dbg_x(A,{n}): print inner structure of A, complete if n is omitted, up to level n otherwise. Intended for debugging."},
{"default",0,(void*)default0,2,"DrDs","default({key},{val}): returns the current value of the default key. If val is present, set opt to val first. If no argument is given, print a list of all defaults as well as their values."},
{"denominator",0,(void*)denominator,6,"GDG","denominator(f,{D}): denominator of f."},
{"deriv",0,(void*)deriv,10,"GDn","deriv(x,{v}): derivative of x with respect to v, or to the main variable of x if v is omitted."},
{"derivn",0,(void*)derivn,10,"GLDn","derivn(x,n,{v}): n-th derivative of x with respect to v, or to the main variable of x if v is omitted."},
{"derivnum",0,(void*)derivnum0,13,"V=GEDGp","derivnum(X=a,expr,{ind=1}): numerical derivation of expr with respect to X at X = a. The order of derivation is given by parameter 'ind', which can be a vector."},
{"diffop",0,(void*)diffop0,10,"GGGD1,L,","diffop(x,v,d,{n=1}): apply the differential operator D to x, where D is defined by D(v[i])=d[i], where v is a vector of variable names. D is 0 for variables outside of v unless they appear as modulus of a POLMOD. If the optional parameter n is given, return D^n(x) instead."},
{"digits",0,(void*)digits,6,"GDG","digits(x,{b}): gives the vector formed by the digits of x in base b."},
{"dilog",0,(void*)dilog,12,"Gp","dilog(x): dilogarithm of x."},
{"dirdiv",0,(void*)dirdiv,8,"GG","dirdiv(x,y): division of the Dirichlet series x by the Dirichlet series y."},
{"direuler",0,(void*)direuler0,8,"V=GGEDG","direuler(p=a,b,expr,{c}): 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). If c is present, output only the first c terms."},
{"dirmul",0,(void*)dirmul,8,"GG","dirmul(x,y): multiplication of the Dirichlet series x by the Dirichlet series y."},
{"dirpowers",0,(void*)dirpowers,11,"LGp","dirpowers(n,x): return the vector [1^x,2^x,...,n^x]."},
{"dirpowerssum",0,(void*)dirpowerssum0,8,"GGDGD0,L,p","dirpowerssum(N,x,{f},{both=0}): return f(1)1^x + f(2)2^x + ... + f(N)N^x, where f is a completely multiplicative function (= 1 if omitted). If both is set, return the pair for arguments (x, f) and (-1-x, conj(f)). If both=2, assume in addition that f is real-valued."},
{"dirzetak",0,(void*)dirzetak,14,"GG","dirzetak(nf,b): Dirichlet series of the Dedekind zeta function of the number field nf up to the bound b-1."},
{"divisors",0,(void*)divisors0,8,"GD0,L,","divisors(x,{flag=0}): gives a vector formed by the divisors of x in increasing order. If flag = 1, return pairs [d, factor(d)]."},
{"divisorslenstra",0,(void*)divisorslenstra,8,"GGG","divisorslenstra(N,r,s): finds all divisors d of N such that d = r (mod s). Assume that (r,s) = 1 and s^3 > N."},
{"divrem",0,(void*)divrem,5,"GGDn","divrem(x,y,{v}): euclidean division of x by y giving as a 2-dimensional column vector the quotient and the remainder, with respect to v (to main variable if v is omitted)."},
{"eint1",0,(void*)veceint1,12,"GDGp","eint1(x,{n}): exponential integral E1(x). If n is present and x > 0, computes the vector of the first n values of the exponential integral E1(n x)."},
{"ell2cover",0,(void*)ell2cover,18,"Gp","ell2cover(E): if E is an elliptic curve over Q, returns a basis of the set of everywhere locally soluble 2-covers of the curve E. For each cover a pair [R,P] is returned where y^2-R(x) is a quartic curve and P belongs to E(k), where k = Q(x)[y] / (y^2-R(x))."},
{"ellE",0,(void*)ellE,12,"Gp","ellE(k): Complete elliptic integral of the second kind for the complex parameter k using the agm."},
{"ellK",0,(void*)ellK,12,"Gp","ellK(k): Complete elliptic integral of the first kind for the complex parameter k using the agm."},
{"ellL1",0,(void*)ellL1,18,"GD0,L,b","ellL1(E,{r=0}): returns the value at s=1 of the derivative of order r of the L-function of the elliptic curve E."},
{"elladd",0,(void*)elladd,18,"GGG","elladd(E,z1,z2): sum of the points z1 and z2 on elliptic curve E."},
{"ellak",0,(void*)akell,18,"GG","ellak(E,n): computes the n-th Fourier coefficient of the L-function of the elliptic curve E (assumes E is an integral model)."},
{"ellan",0,(void*)ellan,18,"GL","ellan(E,n): computes the first n Fourier coefficients of the L-function of the elliptic curve E defined over a number field."},
{"ellanalyticrank",0,(void*)ellanalyticrank,18,"GDGb","ellanalyticrank(E,{eps}): returns the order of vanishing at s=1 of the L-function of the elliptic curve E and the value of the first nonzero derivative. To determine this order, it is assumed that any value less than eps is zero. If no value of eps is given, 2^(-bitprecision/2) is used."},
{"ellap",0,(void*)ellap,18,"GDG","ellap(E,{p}): given an elliptic curve E defined over a finite field Fq, return the trace of Frobenius a_p = q+1-#E(Fq); for other fields of definition K, p must define a finite residue field, (p prime for K = Qp or Q; p a maximal ideal for K a number field)."},
{"ellbil",0,(void*)bilhell,18,"GGGp","ellbil(E,z1,z2): deprecated alias for ellheight(E,P,Q)."},
{"ellbsd",0,(void*)ellbsd,18,"Gp","ellbsd(E): E being an elliptic curve over a number field, returns a real number c such that the BSD conjecture predicts that lfun(E,1,r)/r! = c*R*S where r is the rank, R is the regulator and S is the cardinal of the Tate-Shafarevich group."},
{"ellcard",0,(void*)ellcard,18,"GDG","ellcard(E,{p}): given an elliptic curve E defined over a finite field Fq, return the order of the group E(Fq); for other fields of definition K, p must define a finite residue field, (p prime for K = Qp or Q; p a maximal ideal for K a number field)."},
{"ellchangecompose",0,(void*)ellchangecompose,18,"GGG","ellchangecompose(E,v,w): composes the transformations given by v=[u,r,s,t] and w=[U,R,S,T]."},
{"ellchangecurve",0,(void*)ellchangecurve,18,"GG","ellchangecurve(E,v): change data on elliptic curve according to v=[u,r,s,t]."},
{"ellchangeinvert",0,(void*)ellchangeinvert,18,"GG","ellchangeinvert(E,v): inverts the transformations given by v=[u,r,s,t]."},
{"ellchangepoint",0,(void*)ellchangepoint0,18,"GGDG","ellchangepoint(E,x,v): change data on point or vector of points x on an elliptic curve according to v=[u,r,s,t]."},
{"ellchangepointinv",0,(void*)ellchangepointinv0,18,"GGDG","ellchangepointinv(E,x,v): change data on point or vector of points x on an elliptic curve according to v=[u,r,s,t], inverse of ellchangepoint."},
{"ellcharpoly",0,(void*)ellcharpoly,18,"GDG","ellcharpoly(E, {p}): given an elliptic curve E defined over a finite field Fq, return the characteristic polynomial of the Frobenius acting on the curve, for other fields of definition K, p must define a finite residue field, (p prime for K = Qp or Q; p a maximal ideal for K a number field), return the characteristic polynomial of the Frobenius acting on the Picard group of the reduction of E."},
{"ellconvertname",0,(void*)ellconvertname,18,"G","ellconvertname(name): convert an elliptic curve name (as found in the elldata database) from a string to a triplet [conductor, isogeny class, index]. It will also convert a triplet back to a curve name."},
{"elldivpol",0,(void*)elldivpol,18,"GLDn","elldivpol(E,n,{v='x}): n-division polynomial f_n for the curve E in the variable v."},
{"elleisnum",0,(void*)elleisnum0,18,"GGp","elleisnum(w,k): k being an even positive integer, computes the numerical value of the Eisenstein series of weight k at the lattice w, as given by ellperiods."},
{"elleta",0,(void*)elleta,18,"Gp","elleta(w): w=[w1,w2], returns the vector [eta1,eta2] of quasi-periods attached to [w1,w2]."},
{"ellformaldifferential",0,(void*)ellformaldifferential,18,"GDPDn","ellformaldifferential(E,{n=seriesprecision},{t='x}) : E elliptic curve, n integer. Returns n terms of the power series [f, g] such that omega = dx/(2y+a_1x+a_3) = f(t) dt and eta = x(t) * omega = g(t) dt in the local parameter t=-x/y."},
{"ellformalexp",0,(void*)ellformalexp,18,"GDPDn","ellformalexp(E,{n=seriesprecision},{z='x}): E elliptic curve, returns n terms of the formal elliptic exponential on E as a series in z."},
{"ellformallog",0,(void*)ellformallog,18,"GDPDn","ellformallog(E,{n=seriesprecision},{v='x}): E elliptic curve, returns n terms of the elliptic logarithm as a series of t =-x/y."},
{"ellformalpoint",0,(void*)ellformalpoint,18,"GDPDn","ellformalpoint(E,{n=seriesprecision},{v='x}): E elliptic curve, n integer; return the coordinates [x(t), y(t)] on the elliptic curve as a formal expansion in the formal parameter t = -x/y."},
{"ellformalw",0,(void*)ellformalw,18,"GDPDn","ellformalw(E,{n=seriesprecision},{t='x}): E elliptic curve, n integer; returns n terms of the formal expansion of w = -1/y in the formal parameter t = -x/y."},
{"ellfromeqn",0,(void*)ellfromeqn0,18,"GDG","ellfromeqn(f,{P}): given a genus 1 plane curve, defined by the affine equation f(x,y) = 0, return the coefficients [a1,a2,a3,a4,a6] of a Weierstrass equation for its Jacobian. This allows to recover a Weierstrass model for an elliptic curve given by a general plane cubic or by a binary quartic or biquadratic model.  If a binary quartic or biquadratic model is given, and if a point P is given, also return the image of P by the map from the curve to its Jacobian."},
{"ellfromj",0,(void*)ellfromj,18,"G","ellfromj(j): returns the coefficients [a1,a2,a3,a4,a6] of a fixed elliptic curve with j-invariant j."},
{"ellgenerators",0,(void*)ellgenerators,18,"G","ellgenerators(E): if E is an elliptic curve over the rationals, return the generators of the Mordell-Weil group attached to the curve. This relies on the curve being referenced in the elldata database. If E is an elliptic curve over a finite field Fq as output by ellinit(), return a minimal set of generators for the group E(Fq)."},
{"ellglobalred",0,(void*)ellglobalred,18,"G","ellglobalred(E): E being an elliptic curve over a number field, returns [N, v, c, faN, L], where N is the conductor of E, c is the product of the local Tamagawa numbers c_p, faN is the factorization of N and L[i] is elllocalred(E, faN[i,1]); v is an obsolete field."},
{"ellgroup",0,(void*)ellgroup0,18,"GDGD0,L,","ellgroup(E,{p},{flag}): given an elliptic curve E defined over a finite field Fq, returns the structure of the group E(Fq); for other fields of definition K, p must define a finite residue field (p prime for K = Qp or Q; p a maximal ideal for K a number field) and we return the structure of the (nonsingular) reduction of E. If flag is 1, also returns generators, but the curve equation must be minimal at p."},
{"ellheegner",0,(void*)ellheegner,18,"G","ellheegner(E): return a rational nontorsion point on the elliptic curve E assumed to be of rank 1."},
{"ellheegnertwist",0,(void*)ellheegnertwist,18,"GDGDG","ellheegnertwist(E,{D=1},{s=1}): return a rational nontorsion point on the twist by D of the elliptic curve E assumed to be of rank 1."},
{"ellheight",0,(void*)ellheight0,18,"GDGDGp","ellheight(E,{P},{Q}): Faltings height of the curve E, resp. canonical height of the point P on elliptic curve E, resp. the value of the attached bilinear form at (P,Q)."},
{"ellheightmatrix",0,(void*)ellheightmatrix,18,"GGp","ellheightmatrix(E,x): gives the height matrix for vector of points x on elliptic curve E."},
{"ellidentify",0,(void*)ellidentify,18,"G","ellidentify(E): look up the elliptic curve E in the elldata database and return [[N, M, ...], C] where N is the name of the curve in Cremona's database, M the minimal model and C the change of coordinates (see ellchangecurve)."},
{"ellinit",0,(void*)ellinit,18,"GDGp","ellinit(x,{D=1}): let x be a vector [a1,a2,a3,a4,a6], or [a4,a6] if a1=a2=a3=0, defining the curve Y^2 + a1.XY + a3.Y = X^3 + a2.X^2 + a4.X + a6; x can also be a string, in which case the curve with matching name is retrieved from the elldata database, if available. This function initializes an elliptic curve over the domain D (inferred from coefficients if omitted)."},
{"ellintegralmodel",0,(void*)ellintegralmodel,18,"GD&","ellintegralmodel(E,{&v}): given an elliptic curve E defined over a number field or Qp, returns an integral model. If v is present, sets the variable v to the corresponding change of variable."},
{"elliscm",0,(void*)elliscm,18,"lG","elliscm(E): return 0 if the elliptic curve E, defined over a number field, is not CM, otherwise return the discriminant of its endomorphism ring."},
{"ellisdivisible",0,(void*)ellisdivisible,18,"lGGGD&","ellisdivisible(E,P,n,{&Q}): given E/K and P in E(K), checks whether P = [n]R for some R in E(K) and sets Q to one such R if so; the integer n >= 0 may be given as ellxn(E,n)."},
{"ellisisom",0,(void*)ellisisom,18,"GG","ellisisom(E,F): return 0 if the elliptic curves E and F defined over the same number field are not isomorphic, otherwise return [u,r,s,t] suitable for ellchangecurve, mapping E to F."},
{"ellisogeny",0,(void*)ellisogeny,18,"GGD0,L,DnDn","ellisogeny(E,G,{only_image=0},{x='x},{y='y}): compute the image and isogeny corresponding to the quotient of E by the subgroup G."},
{"ellisogenyapply",0,(void*)ellisogenyapply,18,"GG","ellisogenyapply(f,g): given an isogeny f and g either a point P (in the domain of f) or an isogeny, apply f to g: return the image of P under f or the composite isogeny f o g."},
{"ellisomat",0,(void*)ellisomat,18,"GD0,L,D0,L,","ellisomat(E,{p=0},{flag=0}): E being an elliptic curve over a number field K, returns a list of representatives of the isomorphism classes of elliptic curves defined over K and K-isogenous to E, with the corresponding isogenies from E and their dual, and the matrix of the isogeny degrees between the curves. If flag is 1, the isogenies are not computed, which saves time. If p is set, it must be a prime number: in this case only isogenies of degree a power of p are considered."},
{"ellisoncurve",0,(void*)ellisoncurve,18,"GG","ellisoncurve(E,z): true(1) if z is on elliptic curve E, false(0) if not."},
{"ellisotree",0,(void*)ellisotree,18,"G","ellisotree(E): E being an elliptic curve over Q or a set of isogenous rational curves as given by ellisomat, return minimal models of the isomorphism classes of elliptic curves isogenous to E (or in the set) and the oriented graph of isogenies of prime degree (adjacency matrix)."},
{"ellissupersingular",0,(void*)ellissupersingular,18,"iGDG","ellissupersingular(E,{p}): return 1 if the elliptic curve E, defined over a number field or a finite field, is supersingular at p, and 0 otherwise."},
{"ellj",0,(void*)jell,18,"Gp","ellj(x): elliptic j invariant of x."},
{"elljacobi",0,(void*)elljacobi,12,"GGp","elljacobi(z,k): returns the vector of the three Jacobi elliptic functions [sn(z,k),cn(z,k),dn(z,k)]."},
{"elllocalred",0,(void*)elllocalred,18,"GDG","elllocalred(E,{p}): E being an elliptic 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 variables needed to make E minimal at p, and c is the local Tamagawa number c_p."},
{"elllog",0,(void*)elllog,18,"GGGDG","elllog(E,P,G,{o}): return the discrete logarithm of the point P of the elliptic curve E in base G. If present, o represents the order of G. If not present, assume that G generates the curve."},
{"elllseries",0,(void*)elllseries,18,"GGDGp","elllseries(E,s,{A=1}): L-series at s of the elliptic curve E, where A a cut-off point close to 1."},
{"ellmaninconstant",0,(void*)ellmaninconstant,18,"GD0,L,","ellmaninconstant(E,{fl=0}): let E be an elliptic curve over Q given by ellinit or a rational isogeny class given by ellisomat. Return the Manin constant of the curve (resp. the Manin constants of the isogeny class). If fl=0, the algorithm is slow but unconditional. If fl=1, use Cremona table or Watkins conjecture."},
{"ellminimaldisc",0,(void*)ellminimaldisc,18,"G","ellminimaldisc(E): E being an elliptic curve defined over a number  field output by ellinit, return the minimal discriminant ideal of E."},
{"ellminimalmodel",0,(void*)ellminimalmodel,18,"GD&","ellminimalmodel(E,{&v}): determines whether the elliptic curve E defined over a number field admits a global minimal model. If so return it and sets v to the corresponding change of variable. Else return the (nonprincipal) Weierstrass class of E."},
{"ellminimaltwist",0,(void*)ellminimaltwist0,18,"GD0,L,","ellminimaltwist(E,{flag=0}): Let E  be an elliptic curve defined over Q, return a fundamental discriminant D such that the twist of E by D is minimal among all possible quadratic twists. If flag = 0, minimal means having the smallest minimal discriminant, if flag = 1, minimal means having the smallest conductor."},
{"ellmoddegree",0,(void*)ellmoddegree,18,"G","ellmoddegree(e): e being an elliptic curve defined over Q output by ellinit, compute the modular degree of e divided by the square of the Manin constant."},
{"ellmodulareqn",0,(void*)ellmodulareqn,18,"LDnDn","ellmodulareqn(N,{x},{y}): given a prime N < 500, return a vector [P, t] where P(x,y) is a modular equation of level N. This requires the package seadata. The equation is either of canonical type (t=0) or of Atkin type (t=1)."},
{"ellmul",0,(void*)ellmul,18,"GGG","ellmul(E,z,n): n times the point z on elliptic curve E (n in Z)."},
{"ellneg",0,(void*)ellneg,18,"GG","ellneg(E,z): opposite of the point z on elliptic curve E."},
{"ellnonsingularmultiple",0,(void*)ellnonsingularmultiple,18,"GG","ellnonsingularmultiple(E,P): given E/Q and P in E(Q), returns the pair [R,n] where n is the least positive integer such that R = [n]P has everywhere good reduction. More precisely, its image in a minimal model is everywhere nonsingular."},
{"ellorder",0,(void*)ellorder,18,"GGDG","ellorder(E,z,{o}): order of the point z on the elliptic curve E over a number field or a finite field, 0 if nontorsion. The parameter o, if present, represents a nonzero multiple of the order of z."},
{"ellordinate",0,(void*)ellordinate,18,"GGp","ellordinate(E,x): y-coordinates corresponding to x-ordinate x on elliptic curve E."},
{"ellpadicL",0,(void*)ellpadicL,18,"GGLDGD0,L,DG","ellpadicL(E,p,n,{s=0},{r=0},{D=1}): returns the value on a character of Z_{p}^* represented by an integer s or a vector [s1,s2] of the derivative of order r of the p-adic L-function of the elliptic curve E (twisted by D, if present)."},
{"ellpadicbsd",0,(void*)ellpadicbsd,18,"GGLDG","ellpadicbsd(E,p,n,{D=1}): returns [r,Lp] where r is the (conjectural) analytic rank of the p-adic L-function attached to the quadratic twist E_D and Lp is (conjecturally) equal to the product of the p-adic regulator and the cardinal of the Tate-Shafarevich group."},
{"ellpadicfrobenius",0,(void*)ellpadicfrobenius,18,"GUL","ellpadicfrobenius(E,p,n): matrix of the Frobenius at p>2 in the standard basis of H^1_dR(E) to absolute p-adic precision p^n."},
{"ellpadicheight",0,(void*)ellpadicheight0,18,"GGLGDG","ellpadicheight(E,p,n,P,{Q}): E elliptic curve/Q, P in E(Q), p prime, n an integer; returns the cyclotomic p-adic heights of P. Resp. the value of the attached bilinear form at (P,Q)."},
{"ellpadicheightmatrix",0,(void*)ellpadicheightmatrix,18,"GGLG","ellpadicheightmatrix(E,p,n,Q): gives the height-pairing matrix for vector of points Q on elliptic curve E."},
{"ellpadiclambdamu",0,(void*)ellpadiclambdamu,18,"GLD1,L,D0,L,","ellpadiclambdamu(E,p,{D=1},{i=0}): returns the Iwasawa invariants for the p-adic L-function attached to E, twisted by (D,.) and the i-th power of the Teichmuller character."},
{"ellpadiclog",0,(void*)ellpadiclog,18,"GGLG","ellpadiclog(E,p,n,P): returns the logarithm of P (in the kernel of reduction) to relative p-adic precision p^n."},
{"ellpadicregulator",0,(void*)ellpadicregulator,18,"GGLG","ellpadicregulator(E,p,n,S): E elliptic curve/Q, S a vector of points in E(Q), p prime, n an integer; returns the p-adic cyclotomic regulator of the points of S at precision p^n."},
{"ellpadics2",0,(void*)ellpadics2,18,"GGL","ellpadics2(E,p,n): returns s2 to absolute p-adic precision p^n."},
{"ellperiods",0,(void*)ellperiods,18,"GD0,L,p","ellperiods(w,{flag=0}): w describes a complex period lattice ([w1,w2] or an ellinit structure). Returns normalized periods [W1,W2] generating the same lattice such that tau := W1/W2 satisfies Im(tau) > 0 and lies in the standard fundamental domain for SL2. If flag is 1, the return value is [[W1,W2], [e1,e2]], where e1, e2 are the quasi-periods attached to [W1,W2], satisfying e2 W1 - e1 W2 = 2 Pi I."},
{"ellpointtoz",0,(void*)zell,18,"GGp","ellpointtoz(E,P): lattice point z corresponding to the point P on the elliptic curve E."},
{"ellpow",0,(void*)ellmul,18,"GGG","ellpow(E,z,n): deprecated alias for ellmul."},
{"ellrank",0,(void*)ellrank,18,"GD0,L,DGp","ellrank(E,{effort=0},{points}): if E is an elliptic curve over Q, attempts to compute the Mordell-Weil group attached to the curve. The output is [r1,r2,s,L], where r1 <= rank(E) <= r2, s gives information on the Tate-Shafarevich group (see documentation), and and L is a list of independent, non-torsion rational points on the curve. E can also be given as the output of ellrankinit(E)."},
{"ellrankinit",0,(void*)ellrankinit,18,"Gp","ellrankinit(E): if E is an elliptic curve over Q, initialize data for further calls to ellrank."},
{"ellratpoints",0,(void*)ellratpoints,18,"GGD0,L,","ellratpoints(E,h,{flag=0}): E being a rational model of an elliptic curve, return a vector containing the affine rational points on the curve of naive height less than h. If fl=1, stop as soon as a point is found."},
{"ellrootno",0,(void*)ellrootno,18,"lGDG","ellrootno(E,{p}): root number for the L-function of the elliptic curve E/Q at a prime p (including 0, for the infinite place); global root number if p is omitted. If p is omitted, the curve can also be defined over a number field."},
{"ellsaturation",0,(void*)ellsaturation,18,"GGLp","ellsaturation(E,V,B): let E be an elliptic curve over Q and V be a vector of independent rational points on E of infinite order that generate a subgroup G of E(Q) of finite index. Return a new set W of the same length that generates a subgroup H of E(Q) containing G and such that [E(Q):H] is not divisible by any prime number less than B."},
{"ellsea",0,(void*)ellsea,18,"GD0,L,","ellsea(E,{tors=0}): computes the order of the group E(Fq) for the elliptic curve E, defined over a finite field, using SEA algorithm, with early abort for curves (or their quadratic twist) with nonprime order."},
{"ellsearch",0,(void*)ellsearch,18,"G","ellsearch(N): returns all curves in the elldata database matching constraint N:  given name (N = \"11a1\" or [11,0,1]), given isogeny class (N = \"11a\" or [11,0]), or given conductor (N = 11, \"11\", or [11])."},
{"ellsigma",0,(void*)ellsigma,18,"GDGD0,L,p","ellsigma(w,{z='x},{flag=0}): computes the value at z of the Weierstrass sigma function attached to the lattice w, as given by ellperiods(,1). If flag = 1, returns an arbitrary determination of the logarithm of sigma."},
{"ellsub",0,(void*)ellsub,18,"GGG","ellsub(E,z1,z2): difference of the points z1 and z2 on elliptic curve E."},
{"ellsupersingularj",0,(void*)ellsupersingularj,18,"G","ellsupersingularj(p): return a random supersingular j-invariant defined over F_p^2 if p is prime number, over the (finite) field of definition of p otherwise"},
{"elltamagawa",0,(void*)elltamagawa,18,"G","elltamagawa(E): E being an elliptic curve over a number field, returns the global Tamagawa number of the curve."},
{"elltaniyama",0,(void*)elltaniyama,18,"GDP","elltaniyama(E,{n=seriesprecision}): modular parametrization of elliptic curve E/Q."},
{"elltatepairing",0,(void*)elltatepairing,18,"GGGG","elltatepairing(E,P,Q,m): computes the Tate pairing of the two points P and Q on the elliptic curve E. The point P must be of m-torsion."},
{"elltors",0,(void*)elltors,18,"G","elltors(E): torsion subgroup of elliptic curve E: order, structure, generators."},
{"elltrace",0,(void*)elltrace,18,"GG","elltrace(E,P): sum of the Galois conjugates of the point P on elliptic curve E."},
{"elltwist",0,(void*)elltwist,18,"GDG","elltwist(E,{P}): returns an ell structure for the twist of the elliptic curve E by the quadratic extension defined by P (when P is a polynomial of degree 2) or quadpoly(P) (when P is an integer). If E is defined over a finite field, then P can be omitted."},
{"ellweilcurve",0,(void*)ellweilcurve,18,"GD&","ellweilcurve(E,{&ms}): let E be an elliptic curve over Q given by ellinit or a rational isogeny class given by ellisomat. Return a list of isomorphism classes of elliptic curves isogenous to E as given by ellisomat and the list of the Smith invariants of the lattice associated to E in H^1(E,Q) in the lattice associated to the modular form. If ms is present, it contains the output of msfromell(Emin,0) where Emin is the list of minimal models attached to the curves in the isogeny class."},
{"ellweilpairing",0,(void*)ellweilpairing,18,"GGGG","ellweilpairing(E,P,Q,m): computes the Weil pairing of the two points of m-torsion P and Q on the elliptic curve E."},
{"ellwp",0,(void*)ellwp0,18,"GDGD0,L,p","ellwp(w,{z='x},{flag=0}): computes the value at z of the Weierstrass P function attached to the lattice w, as given by ellperiods. Optional flag means 0 (default), compute only P(z), 1 compute [P(z),P'(z)]."},
{"ellxn",0,(void*)ellxn,18,"GLDn","ellxn(E,n,{v='x}): return polynomials [A,B] in the variable v such that x([n]P) = (A/B)(t) for any P = [t,u] on E outside of n-torsion."},
{"ellzeta",0,(void*)ellzeta,18,"GDGp","ellzeta(w,{z='x}): computes the value at z of the Weierstrass zeta function attached to the lattice w, as given by ellperiods(,1)."},
{"ellztopoint",0,(void*)pointell,18,"GGp","ellztopoint(E,z): inverse of ellpointtoz. Returns the coordinates of point P on the curve E corresponding to a complex or p-adic z."},
{"erfc",0,(void*)gerfc,12,"Gp","erfc(x): complementary error function."},
{"errname",0,(void*)errname,2,"G","errname(E): returns the type of the error message E."},
{"error",0,(void*)error0,2,"vs*","error({str}*): abort script with error message str."},
{"eta",0,(void*)eta0,12,"GD0,L,p","eta(z,{flag=0}): if flag=0, returns prod(n=1,oo, 1-q^n), where q = exp(2 i Pi z) if z is a complex scalar (belonging to the upper half plane); q = z if z is a p-adic number or can be converted to a power series. If flag is nonzero, the function only applies to complex scalars and returns the true eta function, with the factor q^(1/24) included."},
{"eulerfrac",0,(void*)eulerfrac,7,"L","eulerfrac(n): Euler number E_n, as a rational number."},
{"eulerianpol",0,(void*)eulerianpol,7,"LDn","eulerianpol(n,{v='x}): Eulerian polynomial A_n, in variable v."},
{"eulerphi",0,(void*)eulerphi,8,"G","eulerphi(x): Euler's totient function of x."},
{"eulerpol",0,(void*)eulerpol,7,"LDn","eulerpol(n,{v='x}): Euler polynomial E_n, in variable v."},
{"eulerreal",0,(void*)eulerreal,7,"Lp","eulerreal(n): Euler number E_n, as a real number."},
{"eulervec",0,(void*)eulervec,7,"L","eulervec(n): returns a vector containing the nonzero Euler numbers E_0, E_2, ..., E_{2n}."},
{"eval",0,(void*)geval_gp,10,"GC","eval(x): evaluation of x, replacing variables by their value."},
{"exp",0,(void*)gexp,12,"Gp","exp(x): exponential of x."},
{"expm1",0,(void*)gexpm1,12,"Gp","expm1(x): exp(x)-1."},
{"exponent",0,(void*)gpexponent,6,"G","exponent(x): binary exponent of x"},
{"export",0,NULL,2,NULL,"export(x{=...},...,z{=...}): export the variables x,...,z to the parallel world."},
{"exportall",0,(void*)exportall,2,"v","exportall(): declare all current dynamic variables as exported variables."},
{"extern",0,(void*)gpextern,2,"s","extern(str): execute shell command str, and feeds the result to GP (as if loading from file)."},
{"externstr",0,(void*)externstr,2,"s","externstr(str): execute shell command str, and returns the result as a vector of GP strings, one component per output line."},
{"factor",0,(void*)factor0,8,"GDG","factor(x,{D}): factorization of x over domain D. If x and D are both integers, return partial factorization, using primes < D."},
{"factorback",0,(void*)factorback2,8,"GDG","factorback(f,{e}): given a factorization f, gives the factored object back. If e is present, f has to be a vector of the same length, and we return the product of the f[i]^e[i]."},
{"factorcantor",0,(void*)factmod,8,"GG","factorcantor(x,p): this function is obsolete, use factormod."},
{"factorff",0,(void*)factorff,8,"GDGDG","factorff(x,{p},{a}): obsolete, use factormod."},
{"factorial",0,(void*)mpfactr,8,"Lp","factorial(x): factorial of x, the result being given as a real number."},
{"factorint",0,(void*)factorint,8,"GD0,L,","factorint(x,{flag=0}): factor the integer x. flag is optional, whose binary digits mean 1: avoid MPQS, 2: avoid first-stage ECM (may fall back on it later), 4: avoid Pollard-Brent Rho and Shanks SQUFOF, 8: skip final ECM (huge composites will be declared prime)."},
{"factormod",0,(void*)factormod0,8,"GDGD0,L,","factormod(f,{D},{flag=0}): factors the polynomial f over the finite field defined by the domain D; flag is optional, and can be 0: default or 1: only the degrees of the irreducible factors are given."},
{"factormodDDF",0,(void*)factormodDDF,8,"GDG","factormodDDF(f,{D}): distinct-degree factorization of the squarefree polynomial f over the finite field defined by the domain D."},
{"factormodSQF",0,(void*)factormodSQF,8,"GDG","factormodSQF(f,{D}): squarefree factorization of the polynomial f over the finite field defined by the domain D."},
{"factormodcyclo",0,(void*)factormodcyclo,8,"LGD0,L,Dn","factormodcyclo(n,p,{single=0},{v='x}): factor n-th cyclotomic polynomial mod p."},
{"factornf",0,(void*)polfnf,14,"GG","factornf(x,t): this function is obsolete, use nffactor."},
{"factorpadic",0,(void*)factorpadic,10,"GGL","factorpadic(pol,p,r): p-adic factorization of the polynomial pol to precision r."},
{"ffcompomap",0,(void*)ffcompomap,8,"GG","ffcompomap(f,g): Let k, l, m be three finite fields and f a (partial) map from l to m and g a partial map from k to l, return the (partial) map f o g from k to m."},
{"ffembed",0,(void*)ffembed,8,"GG","ffembed(a,b): given two elements a and b in finite fields, return a map embedding the definition field of a to the definition field of b."},
{"ffextend",0,(void*)ffextend,8,"GGDn","ffextend(a,P,{v}): extend the field K of definition of a by a root of the polynomial P, assumed to be irreducible over K.  Return [r, m] where r is a root of P in the extension field L and m is a map from K to L, see \\kbd{ffmap}. If v is given, the variable name is used to display the generator of L, else the name of the variable of P is used."},
{"fffrobenius",0,(void*)fffrobenius,8,"GD1,L,","fffrobenius(m,{n=1}): return the n-th power of the Frobenius map over the field of definition of m."},
{"ffgen",0,(void*)ffgen,8,"GDn","ffgen(k,{v = 'x}): return a generator of the finite field k (not necessarily a generator of its multiplicative group) as a t_FFELT. k can be given by its order q, the pair [p,f] with q=p^f, by an irreducible polynomial with t_INTMOD coefficients, or by a finite field element. If v is given, the variable name is used to display g, else the variable of the polynomial or finite field element, or x if only the order was given."},
{"ffinit",0,(void*)ffinit,8,"GLDn","ffinit(p,n,{v='x}): monic irreducible polynomial of degree n in F_p[v]."},
{"ffinvmap",0,(void*)ffinvmap,8,"G","ffinvmap(m): given a map m between finite fields, return a partial map that return the pre-images by the map m."},
{"fflog",0,(void*)fflog,8,"GGDG","fflog(x,g,{o}): return the discrete logarithm of the finite field element x in base g. If present, o must represent the multiplicative order of g. If no o is given, assume that g is a primitive root."},
{"ffmap",0,(void*)ffmap,8,"GG","ffmap(m,x): given a (partial) map m between two finite fields, return the image of x by m. The function is applied recursively to the component of vectors, matrices and polynomials. If m is a partial map that is not defined at x, return []"},
{"ffmaprel",0,(void*)ffmaprel,8,"GG","ffmaprel(m,x): given a (partial) map m between two finite fields, express x as an algebraic element over the codomain of m in a way which is compatible with m. The function is applied recursively to the component of vectors, matrices and polynomials."},
{"ffnbirred",0,(void*)ffnbirred0,8,"GLD0,L,","ffnbirred(q,n,{flag=0}): number of monic irreducible polynomials over F_q, of degree n (flag=0, default) or at most n (flag=1)."},
{"fforder",0,(void*)fforder,8,"GDG","fforder(x,{o}): multiplicative order of the finite field element x. Optional o represents a multiple of the order of the element."},
{"ffprimroot",0,(void*)ffprimroot,8,"GD&","ffprimroot(x,{&o}): return a primitive root of the multiplicative group of the definition field of the finite field element x (not necessarily the same as the field generated by x). If present, o is set to [ord, fa], where ord is the order of the group, and fa its factorization (useful in fflog and fforder)."},
{"fft",0,(void*)FFT,10,"GG","fft(w,P): given w from rootsof1, return the discrete Fourier transform of P."},
{"fftinv",0,(void*)FFTinv,10,"GG","fftinv(w,P): given w from rootsof1, return the inverse Fourier transform of P."},
{"fibonacci",0,(void*)fibo,7,"L","fibonacci(x): Fibonacci number of index x."},
{"fileclose",0,(void*)gp_fileclose,2,"vL","fileclose(n): close the file descriptor n."},
{"fileextern",0,(void*)gp_fileextern,2,"lsD\"r\",s,","fileextern(str, {mode=\"r\"}): execute shell command str and returns a file descriptor attached to the command output as if it were read from a file (mode \"r\") or to the command input (mode \"w\")."},
{"fileflush",0,(void*)gp_fileflush0,2,"vDG","fileflush({n}): flush the file descriptor n (all descriptors to output streams if n is omitted)."},
{"fileopen",0,(void*)gp_fileopen,2,"lsD\"r\",s,","fileopen(path,{mode=\"r\"}): open the file pointed to by 'path' and return a file descriptor which can be used with other file functions. The mode is \"r\" (default, read), \"w\" (write, truncate), \"a\" (write, append)."},
{"fileread",0,(void*)gp_fileread,2,"L","fileread(n): read a logical line from the file attached to the descriptor n, opened for reading with fileopen. Return 0 at end of file."},
{"filereadstr",0,(void*)gp_filereadstr,2,"L","filereadstr(n): read a raw line from the file attached to the descriptor n, opened for reading with fileopen. Discard the terminating newline.  Return 0 at end of file."},
{"filewrite",0,(void*)gp_filewrite,2,"vLs","filewrite(n,s): write the string s to file attached to descriptor n, ending with a newline. The file must have been opened with fileopen in \"w\" or \"a\" mode."},
{"filewrite1",0,(void*)gp_filewrite1,2,"vLs","filewrite1(n,s): write the string s to file number n without ending with newline."},
{"fingerprint",0,(void*)fingerprint,2,"GD64,L,","fingerprint(x, {b = 64}): return a b-bit fingerprint of x."},
{"floor",0,(void*)gfloor,6,"G","floor(x): floor of x = largest integer <= x."},
{"fold",0,(void*)fold0,2,"GG","fold(f,A): return f(...f(f(A[1],A[2]),A[3]),...,A[#A])."},
{"for",0,(void*)forpari,1,"vV=GGI","for(X=a,b,seq): the sequence is evaluated, X going from a up to b. If b is set to +oo, the loop will not stop."},
{"forcomposite",0,(void*)forcomposite,1,"vV=GDGI","forcomposite(n=a,{b},seq): the sequence is evaluated, n running over the composite numbers between a and b. Omitting b runs through composites >= a."},
{"fordiv",0,(void*)fordiv,1,"vGVI","fordiv(n,X,seq): the sequence is evaluated, X running over the divisors of n."},
{"fordivfactored",0,(void*)fordivfactored,1,"vGVI","fordivfactored(n,X,seq): the sequence is evaluated, X running over the [d, factor(d)], d a divisor of n."},
{"foreach",0,(void*)foreachpari,1,"vGVI","foreach(V,X,seq): the sequence is evaluated, X running over the components of V."},
{"forell",0,(void*)forell0,1,"vVLLID0,L,","forell(E,a,b,seq,{flag=0}): execute seq for each elliptic curves E of conductor between a and b in the elldata database. If flag is nonzero, select only the first curve in each isogeny class."},
{"forfactored",0,(void*)forfactored,1,"vV=GGI","forfactored(N=a,b,seq): the sequence is evaluated, N is of the form [n, factor(n)], n going from a up to b."},
{"forpart",0,(void*)forpart0,1,"vV=GIDGDG","forpart(X=k,seq,{a=k},{n=k}): evaluate seq where the Vecsmall X iterates over the partitions of k. Optional parameter a (a=amax or a=[amin,amax]) restricts the range of the parts. Optional parameter n (n=nmax or n=[nmin,nmax]) restricts the length of the partition."},
{"forperm",0,(void*)forperm0,1,"vGVI","forperm(a,p,seq): the sequence is evaluated, p going through permutations of a."},
{"forprime",0,(void*)forprime,1,"vV=GDGI","forprime(p=a,{b},seq): the sequence is evaluated, p running over the primes between a and b. Omitting b runs through primes >= a."},
{"forprimestep",0,(void*)forprimestep,1,"vV=GDGGI","forprimestep(p=a,b,q,seq): the sequence is evaluated, p running over the primes less than b in the arithmetic progression a + k*q, k >= 0. The parameter q can be a positive integer or an intmod (start at the first prime above a in the progression)."},
{"forqfvec",0,(void*)forqfvec0,11,"vVGDGI","forqfvec(v,q,b,expr): q being a square and symmetric integral matrix representing an positive definite quadratic form, evaluate expr for all pairs of nonzero vectors (-v, v) such that q(v)<=b."},
{"forsquarefree",0,(void*)forsquarefree,1,"vV=GGI","forsquarefree(N=a,b,seq): the sequence is evaluated, N is of the form [n, factor(n)], n going through squarefree integers from a up to b."},
{"forstep",0,(void*)forstep,1,"vV=GGGI","forstep(X=a,b,s,seq): the sequence is evaluated, X going from a to b in steps of s (can be a positive real number, an intmod for an arithmetic progression, or finally a vector of steps). If b is set to +oo the loop will not stop."},
{"forsubgroup",0,(void*)forsubgroup0,1,"vV=GDGI","forsubgroup(H=G,{bound},seq): execute seq for each subgroup H of the abelian group G, whose index is bounded by bound if not omitted. H is given as a left divisor of G in HNF form."},
{"forsubset",0,(void*)forsubset0,1,"vGVI","forsubset(nk,s,seq): if nk is an integer n, the sequence is evaluated,  s going through all subsets of {1, 2, ..., n}; if nk is a pair [n,k]  of integers s goes through k-subsets of {1, 2, ..., n}.  The order is lexicographic among subsets of the same size and smaller  subsets come first."},
{"forvec",0,(void*)forvec,1,"vV=GID0,L,","forvec(X=v,seq,{flag=0}): v being a 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 if flag is zero or omitted. If flag = 1 (resp. flag = 2), restrict to increasing (resp. strictly increasing) sequences. As a shortcut, v being a vector of nonnegative integers allows to loop over representatives of Z^n/vZ^n."},
{"frac",0,(void*)gfrac,6,"G","frac(x): fractional part of x = x-floor(x)."},
{"fromdigits",0,(void*)fromdigits,6,"GDG","fromdigits(x,{b=10}): gives the integer formed by the elements of x seen as the digits of a number in base b."},
{"galoischardet",0,(void*)galoischardet,15,"GGD1,L,","galoischardet(gal,chi,{o=1}): return the determinant character of the character chi."},
{"galoischarpoly",0,(void*)galoischarpoly,15,"GGD1,L,","galoischarpoly(gal,chi,{o=1}): return the list of characteristic polynomials of the representation attached to the character chi."},
{"galoischartable",0,(void*)galoischartable,15,"G","galoischartable(gal): return the character table of the underlying group of gal."},
{"galoisconjclasses",0,(void*)galoisconjclasses,15,"G","galoisconjclasses(gal): gal being output by galoisinit, return the list of conjugacy classes."},
{"galoisexport",0,(void*)galoisexport,15,"GD0,L,","galoisexport(gal,{flag}): gal being a Galois group as output by galoisinit, output a string representing the underlying permutation group in GAP notation (default) or Magma notation (flag = 1)."},
{"galoisfixedfield",0,(void*)galoisfixedfield,15,"GGD0,L,Dn","galoisfixedfield(gal,perm,{flag},{v=y}): gal being a Galois group as output by galoisinit and perm a subgroup, an element of gal.group or a vector of such elements, return [P,x] such that P is a polynomial defining the fixed field of gal[1] by the subgroup generated by perm, and x is a root of P in gal expressed as a polmod in gal.pol. If flag is 1 return only P. If flag is 2 return [P,x,F] where F is the factorization of gal.pol over the field defined by P, where the variable v stands for a root of P."},
{"galoisgetgroup",0,(void*)galoisgetgroup,15,"LD0,L,","galoisgetgroup(a,{b}): query the galpol package for a group of order a with index b in the GAP4 Small Group library. If b is omitted, return the number of isomorphism classes of groups of order a."},
{"galoisgetname",0,(void*)galoisgetname,15,"LL","galoisgetname(a,b): query the galpol package for a string describing the group of order a with index b in the GAP4 Small Group library."},
{"galoisgetpol",0,(void*)galoisgetpol,15,"LD0,L,D1,L,","galoisgetpol(a,{b},{s}): query the galpol package for a polynomial with Galois group isomorphic to GAP4(a,b), totally real if s=1 (default) and totally complex if s=2.  The output is a vector [pol, den] where pol is the polynomial and den is the common denominator of the conjugates expressed as a polynomial in a root of pol. If b and s are omitted, return the number of isomorphism classes of groups of order a."},
{"galoisidentify",0,(void*)galoisidentify,15,"G","galoisidentify(gal): gal being a Galois group as output by galoisinit, output the isomorphism class of the underlying abstract group as a two-components vector [o,i], where o is the group order, and i is the group index in the GAP4 small group library."},
{"galoisinit",0,(void*)galoisinit,15,"GDG","galoisinit(pol,{den}): pol being a polynomial or a number field as output by nfinit defining a Galois extension of Q, compute the Galois group and all necessary information for computing fixed fields. den is optional and has the same meaning as in nfgaloisconj(,4)(see manual)."},
{"galoisisabelian",0,(void*)galoisisabelian,15,"GD0,L,","galoisisabelian(gal,{flag=0}): gal being as output by galoisinit, return 0 if gal is not abelian, the HNF matrix of gal over gal.gen if flag=0, 1 if flag is 1, and the SNF matrix of gal if flag=2."},
{"galoisisnormal",0,(void*)galoisisnormal,15,"lGG","galoisisnormal(gal,subgrp): gal being as output by galoisinit, and subgrp a subgroup of gal as output by galoissubgroups, return 1 if subgrp is a normal subgroup of gal, else return 0."},
{"galoispermtopol",0,(void*)galoispermtopol,15,"GG","galoispermtopol(gal,perm): gal being a Galois group as output by galoisinit and perm a element of gal.group, return the polynomial defining the corresponding Galois automorphism."},
{"galoissplittinginit",0,(void*)galoissplittinginit,15,"GDG","galoissplittinginit(P,{d}): Galois group over Q of the splitting field of P, for P integral, monic and irreducible or given by a nf structure. If d is given, it must be a multiple of the splitting field degree. The output is compatible with functions expecting a galoisinit structure."},
{"galoissubcyclo",0,(void*)galoissubcyclo,15,"GDGD0,L,Dn","galoissubcyclo(N,H,{flag=0},{v}): computes a polynomial (in variable v) defining the subfield of Q(zeta_n) fixed by the subgroup H of (Z/nZ)*. N can be an integer n, znstar(n) or bnrinit(bnfinit(y),[n,[1]]). H can be given by a generator, a set of generator given by a vector or a HNF matrix (see manual). If flag is 1, outputs only the conductor of the abelian extension. If flag is 2, outputs [pol,f] where pol is the polynomial and f the conductor. If flag is 3, outputs galoisinit(pol)."},
{"galoissubfields",0,(void*)galoissubfields,15,"GD0,L,Dn","galoissubfields(G,{flag=0},{v}): output all the subfields of G; flag has the same meaning as for galoisfixedfield."},
{"galoissubgroups",0,(void*)galoissubgroups,15,"G","galoissubgroups(G): output all the subgroups of G."},
{"gamma",0,(void*)ggamma,12,"Gp","gamma(s): gamma function at s, a complex or p-adic number, or a series."},
{"gammah",0,(void*)ggammah,12,"Gp","gammah(x): gamma of x+1/2 (x integer)."},
{"gammamellininv",0,(void*)gammamellininv,12,"GGD0,L,b","gammamellininv(G,t,{m=0}): returns G(t), where G is as output by gammamellininvinit (its m-th derivative if m is present)."},
{"gammamellininvasymp",0,(void*)gammamellininvasymp,12,"GDPD0,L,","gammamellininvasymp(A,n,{m=0}): return the first n terms of the asymptotic expansion at infinity of the m-th derivative K^m(t) of the inverse Mellin transform of the function f(s)=Gamma_R(s+a_1)*...*Gamma_R(s+a_d), where Vga is the vector [a_1,...,a_d] and Gamma_R(s)=Pi^(-s/2)*gamma(s/2). The result is a vector [M[1]...M[n]] with M[1]=1, such that K^m(t) = (an elementary factor) * sum_n M[n+1] / x^n, where x = pi t^(2n/d)."},
{"gammamellininvinit",0,(void*)gammamellininvinit,12,"GD0,L,b","gammamellininvinit(A,{m=0}): initialize data for the computation by gammamellininv() of the m-th derivative of the inverse Mellin transform of the function f(s) = Gamma_R(s+a1)*...*Gamma_R(s+ad), where A is the vector [a1,...,ad] and Gamma_R(s) = Pi^(-s/2)*gamma(s/2)."},
{"gcd",0,(void*)ggcd0,5,"GDG","gcd(x,{y}): greatest common divisor of x and y."},
{"gcdext",0,(void*)gcdext0,5,"GG","gcdext(x,y): returns [u,v,d] such that d=gcd(x,y) and u*x+v*y=d."},
{"gcharalgebraic",0,(void*)gcharalgebraic,15,"GDG","gcharalgebraic(gc,{typ}): returns a matrix whose columns form a basis of the algebraic Grossencharacters in gc. If typ is specified as a vector of integer exponents [p,q] for each complex place, returns a vector containing an algebraic character of that infinity type (or the empty vector if such a character does not exist)."},
{"gcharconductor",0,(void*)gchar_conductor,15,"GG","gcharconductor(gc,chi): returns the conductor of chi, as a modulus over gc.bnf."},
{"gcharduallog",0,(void*)gcharduallog,15,"GG","gcharduallog(gc,chi): returns logarithm vector of character chi in R^n. We have gchareval(gc,chi,x,0) = gcharduallog(gc,chi)*gcharlog(gc,x) in R/Z."},
{"gchareval",0,(void*)gchareval,15,"GGGD1,L,","gchareval(gc,chi,x,{flag=1}): computes the evaluation chi(x) in C* if flag=1 and in C/Z if flag=0."},
{"gcharidentify",0,(void*)gchar_identify,15,"GGGp","gcharidentify(gc,Lv,Lchiv): returns a Grossencharacter chi belonging to gc  that approximately satisfies the constraints that chi_v is Lchiv[i] at the  place v=Lv[i]."},
{"gcharinit",0,(void*)gcharinit,15,"GGp","gcharinit(bnf,f): given a bnf as output by bnfinit and a modulus f, initializes data related to the group of Grossencharacters of conductor dividing this modulus."},
{"gcharisalgebraic",0,(void*)gcharisalgebraic,15,"iGGD&","gcharisalgebraic(gc,chi,{&typ}): returns 1 if chi is an algebraic (type A0) character. If typ is present, it is set to the infinity type [p,q] of chi."},
{"gcharlocal",0,(void*)gcharlocal,15,"GGGpD&","gcharlocal(gc,chi,v,{&BID}): if v is a place, return the local character chi_v. If v is a prime dividing the modulus and the optional argument 'BID' is present, set BID to the corresponding idealstar structure."},
{"gcharlog",0,(void*)gcharlog,15,"GGp","gcharlog(gc,x): returns the internal representation (logarithm) of the ideal x suitable for computations in gc, as a column vector."},
{"gcharnewprec",0,(void*)gcharnewprec,15,"Gp","gcharnewprec(gc): given a Grossencharacter group \\kbd{gc}, recomputes its invariants to ensure accurate results to current precision."},
{"genus2charpoly",0,(void*)genus2charpoly,19,"GG","genus2charpoly(C, p): C being a genus-2 curve, returns the characteristic polynomial of the action of the Frobenius on the Picard group of C at p."},
{"genus2igusa",0,(void*)genus2igusa,19,"GD0,L,","genus2igusa(PQ,{k}): let PQ be a polynomial P, resp. a vector [P,Q] of polynomials defined over a field F of characteristic != 2. Returns the Igusa invariants of the hyperelliptic curve C/F of genus 2 defined by y^2 = P, resp. y^2 + Q*y = P."},
{"genus2red",0,(void*)genus2red,19,"GDG","genus2red(PQ,{p}): let PQ be a polynomial P, resp. a vector [P,Q] of polynomials, with rational coefficients.  Determines the reduction at p > 2 of the (proper, smooth) hyperelliptic curve C/Q of genus 2 defined by y^2 = P, resp. y^2 + Q*y = P. More precisely, determines the special fiber X_p of the minimal regular model X of C over Z."},
{"getabstime",0,(void*)getabstime,2,"l","getabstime(): milliseconds of CPU time since startup."},
{"getcache",0,(void*)getcache,2,"","getcache(): returns information about various auto-growing caches. For each resource, we report its name, its size, the number of cache misses (since the last extension) and the largest cache miss."},
{"getenv",0,(void*)gp_getenv,2,"s","getenv(s): value of the environment variable s, 0 if it is not defined."},
{"getheap",0,(void*)getheap,2,"","getheap(): 2-component vector giving the current number of objects in the heap and the space they occupy (in long words)."},
{"getlocalbitprec",0,(void*)getlocalbitprec,2,"lb","getlocalbitprec(): returns the current dynamic bit precision."},
{"getlocalprec",0,(void*)getlocalprec,2,"lp","getlocalprec(): returns the current dynamic precision, in decimal digits."},
{"getrand",0,(void*)getrand,2,"","getrand(): current value of random number seed."},
{"getstack",0,(void*)getstack,2,"l","getstack(): current value of stack pointer avma."},
{"gettime",0,(void*)gettime,2,"l","gettime(): milliseconds of CPU time used since the last call to gettime."},
{"getwalltime",0,(void*)getwalltime,2,"","getwalltime(): time (in milliseconds) since the UNIX Epoch."},
{"global",0,NULL,2,NULL,"global(list of variables): Declare global variables for GP2C."},
{"halfgcd",0,(void*)ghalfgcd,5,"GG","halfgcd(x,y): return a vector [M, [a,b]~], where M is an invertible 2x2 matrix such that M*[x,y]~ = [a,b]~, where b is small. More precisely, if x,y are integers, we have b < sqrt(max(|x|,|y|)) <= a. If x,y are polynomials, we have deg b < ceil((max(|x|,|y|))/2) <= deg a."},
{"hammingweight",0,(void*)hammingweight,7,"lG","hammingweight(x): returns the Hamming weight of x."},
{"harmonic",0,(void*)harmonic0,7,"UDG","harmonic(n,{r=1}): generalized harmonic number of index n in power r."},
{"hgmalpha",0,(void*)hgmalpha,21,"G","hgmalpha(H): returns the alpha and beta parameters of the hypergeometric motive template H."},
{"hgmbydegree",0,(void*)hgmbydegree,21,"L","hgmbydegree(n): outputs [L(0),...,L(n-1)] where L(w) is the list of cyclotomic parameters of all possible hypergeometric motive templates of degree n and weight w."},
{"hgmcoef",0,(void*)hgmcoef,21,"GGG","hgmcoef(H,t,n): (H,t) being a hypergeometric motive, returns the n-th coefficient of its L-function."},
{"hgmcoefs",0,(void*)hgmcoefs,21,"GGL","hgmcoefs(H,t,n): (H,t) being a hypergeometric motive, returns the first n coefficients of its L-function, where Euler factors at wild primes are set to 1."},
{"hgmcyclo",0,(void*)hgmcyclo,21,"G","hgmcyclo(H): returns the cyclotomic parameters (D,E) of the hypergeometric motive template H."},
{"hgmeulerfactor",0,(void*)hgmeulerfactor,21,"GGLD&","hgmeulerfactor(H,t,p,{&e}): (H,t) being a hypergeometric motive, returns the Euler factor P_p at the prime p; if present, set e to the valuation of the conductor at p."},
{"hgmgamma",0,(void*)hgmgamma,21,"G","hgmgamma(H): returns the gamma vector of the hypergeometric motive template H."},
{"hgminit",0,(void*)hgminit,21,"GDG","hgminit(a,{b}): Create the template for a hypergeometric motive with parameters a and possibly b. The format of the parameters may be alpha: Galois invariant lists of rational numbers a=alpha and b=beta; or cyclo: lists A and B of positive integers corresponding to alpha and beta; or gamma: list of cn such that the hypergeometric quotient is prod_n(x^n-1)^cn."},
{"hgmissymmetrical",0,(void*)hgmissymmetrical,21,"lG","hgmissymmetrical(H): is the hypergeometric motive template H symmetrical at t=1?"},
{"hgmparams",0,(void*)hgmparams,21,"G","hgmparams(H): H being a hypergeometric motive template, returns [d, w, [P, T], M], where d is the degree, w the weight, P the Hodge polynomial and T the Tate twist number (so that the Hodge function itself is P/x^T); finally M is the so-called M-value."},
{"hgmtwist",0,(void*)hgmtwist,21,"G","hgmtwist(H): twist by 1/2 of alpha and beta of the hypergeometric motive template H."},
{"hilbert",0,(void*)hilbert,8,"lGGDG","hilbert(x,y,{p}): Hilbert symbol at p of x,y."},
{"hyperellauto",0,(void*)hyperellauto,19,"GDG","hyperellauto(C,{nf}): C being a hyperelliptic curve given by a Weierstrass equation, either over the rationals or over the number field nf if given, return the group of automorphisms of C as a vector of changes of coordinates of the form [e, [a,b;c,d], H]."},
{"hyperellchangecompose",0,(void*)hyperellchangecompose,19,"GGG","hyperellchangecompose(C,m1, m2): C being a hyperelliptic curve given by a Weierstrass equation, compose the change of coordinates given by m1 and m2. C can be given either by a squarefree polynomial P such that C:y^2=P(x) or by a vector [P,Q] such that C:y^2+Q(x)*y=P(x) and Q^2+4P is squarefree."},
{"hyperellchangecurve",0,(void*)hyperellchangecurve,19,"GG","hyperellchangecurve(C,m): C being a hyperelliptic curve given by a Weierstrass equation, apply the change of coordinates given by m. C can be given either by a squarefree polynomial P such that C:y^2=P(x) or by a vector [P,Q] such that C:y^2+Q(x)*y=P(x) and Q^2+4P is squarefree."},
{"hyperellchangeinvert",0,(void*)hyperellchangeinvert,19,"GG","hyperellchangeinvert(C,m): C being a hyperelliptic curve given by a Weierstrass equation, invert the change of coordinates given by m. C can be given either by a squarefree polynomial P such that C:y^2=P(x) or by a vector [P,Q] such that C:y^2+Q(x)*y=P(x) and Q^2+4P is squarefree."},
{"hyperellchangepoint",0,(void*)hyperellchangepoint,19,"GGG","hyperellchangepoint(C,p,m): C being a hyperelliptic curve given by a Weierstrass equation, apply the change of coordinates given by m to the point p of C. C can be given either by a squarefree polynomial P such that C:y^2=P(x) or by a vector [P,Q] such that C:y^2+Q(x)*y=P(x) and Q^2+4P is squarefree."},
{"hyperellchangepointinv",0,(void*)hyperellchangepointinv,19,"GGG","hyperellchangepointinv(C,p,m): C being a hyperelliptic curve given by a Weierstrass equation, apply the reverse of the change of coordinates given by m to the point p. C can be given either by a squarefree polynomial P such that C:y^2=P(x) or by a vector [P,Q] such that C:y^2+Q(x)*y=P(x) and Q^2+4P is squarefree."},
{"hyperellcharpoly",0,(void*)hyperellcharpoly,19,"G","hyperellcharpoly(X): X being a nonsingular hyperelliptic curve defined over a finite field, return the characteristic polynomial of the Frobenius automorphism.  X can be given either by a squarefree polynomial P such that X:y^2=P(x) or by a vector [P,Q] such that X:y^2+Q(x)*y=P(x) and Q^2+4P is squarefree."},
{"hyperelldisc",0,(void*)hyperelldisc,19,"G","hyperelldisc(X): X being a nonsingular hyperelliptic model of a curve, defined over a field of characteristic distinct from 2, returns its discriminant. X can be given either by a squarefree polynomial P such that X:y^2=P(x) or by a vector [P,Q] such that X:y^2+Q(x)*y=P(x) and Q^2+4P is squarefree."},
{"hyperellextremalmodels",0,(void*)hyperellextremalmodels,19,"GG","hyperellextremalmodels(C,p): C being a hyperelliptic curve given by an integral Weierstrass equation, compute a maximal chain of minimal Weierstrass models at p. Return a vector [n, V] where n is the length of the chain of minimal Weierstrass models at p, and V is vector of length 1 or 2 containing the extremal models of the chain."},
{"hyperellisisom",0,(void*)hyperellisisom,19,"GGDG","hyperellisisom(C1, C2, {nf}): C1 and C2 being two hyperelliptic curve given by Weierstrass equations, either over the rationals or over the number field nf if given, return the list of isomorphisms from C1 to C2 as changes of coordinates of the form [e, [a,b;c,d], H]."},
{"hyperellisoncurve",0,(void*)hyperellisoncurve,19,"iGG","hyperellisoncurve(X,p): X being a nonsingular hyperelliptic model of a curve, test whether the point p is on the curve. X can be given either by a squarefree polynomial P such that X:y^2=P(x) or by a vector [P,Q] such that X:y^2+Q(x)*y=P(x) and Q^2+4P is squarefree."},
{"hyperellminimaldisc",0,(void*)hyperellminimaldisc,19,"GDG","hyperellminimaldisc(C,{pr}): C being a hyperelliptic curve given by an integral Weierstrass equation, return the minimal discrminant of an integral model of C.  If pr is given, it must be a list of primes and the discriminant is then only guaranteed minimal at the elements of pr. C can be given either by a squarefree polynomial P such that C:y^2=P(x) or by a vector [P,Q] such that C:y^2+Q(x)*y=P(x) and Q^2+4P is squarefree."},
{"hyperellminimalmodel",0,(void*)hyperellminimalmodel,19,"GD&DG","hyperellminimalmodel(C,{&m},{pr}): C being a hyperelliptic curve given by an integral Weierstrass equation, return an integral model of C with minimal discriminant. If pr is given, it must be a list of primes and the model is then only guaranteed minimal at the elements of pr. C can be given either by a squarefree polynomial P such that C:y^2=P(x) or by a vector [P,Q] such that C:y^2+Q(x)*y=P(x) and Q^2+4P is squarefree."},
{"hyperellordinate",0,(void*)hyperellordinate,19,"GG","hyperellordinate(H,x): y-coordinates corresponding to x-coordinate x on hyperelliptic curve H. H can be given either by a squarefree polynomial P such that H:y^2=P(x) or by a vector [P,Q] such that H:y^2+Q(x)*y=P(x) and Q^2+4P is squarefree."},
{"hyperellpadicfrobenius",0,(void*)hyperellpadicfrobenius0,19,"GGL","hyperellpadicfrobenius(Q,q,n): Q being a rational polynomial of degree d and X being the curve defined by y^2=Q(x), return the matrix of the Frobenius at the prime q >= d in the standard basis of H^1_dR(X) to absolute q-adic precision q^n; q may also be of the form [T,p] where T is an integral polynomial which is irreducible mod p."},
{"hyperellperiods",0,(void*)hyperellperiods,19,"GD0,L,p","hyperellperiods(X,{flag}): X being a nonsingular hyperelliptic curve defined over the complex numbers, return a period matrix. X can be given either by a squarefree polynomial P such that X:y^2=P(x) or by a vector [P,Q] such that X:y^2+Q(x)*y=P(x) and Q^2+4P is squarefree. If flag=0 (default), return a reduced period matrix in Siegel space. If flag=1, return the big period matrix of size (g x 2g), If flag=2, return the BSD period."},
{"hyperellratpoints",0,(void*)hyperellratpoints,19,"GGD0,L,","hyperellratpoints(X,h,{flag=0}): X being a nonsingular hyperelliptic curve given by a rational model, return a vector containing the affine rational points on the curve of naive height less than h. If fl=1, stop as soon as a point is found. X can be given either by a squarefree polynomial P such that X:y^2=P(x) or by a vector [P,Q] such that X:y^2+Q(x)y=P(x) and Q^2+4P is squarefree."},
{"hyperellred",0,(void*)hyperellred,19,"GD&","hyperellred(C,{&m}): C being a nonsingular integral hyperelliptic model of a curve, return an integral model of C with the same discriminant but small coefficients. C can be given either by a squarefree polynomial P such that C:y^2=P(x) or by a vector [P,Q] such that C:y^2+Q(x)*y=P(x) and Q^2+4P is squarefree."},
{"hypergeom",0,(void*)hypergeom,12,"DGDGGp","hypergeom({N},{D},z): general hypergeometric function, where N and D are the vector of parameters in the numerator and denominator respectively, evaluated at the argument z."},
{"hyperu",0,(void*)hyperu,12,"GGGp","hyperu(a,b,z): U-confluent hypergeometric function."},
{"idealadd",0,(void*)idealadd,14,"GGG","idealadd(nf,x,y): sum of two ideals x and y in the number field defined by nf."},
{"idealaddtoone",0,(void*)idealaddtoone0,14,"GGDG","idealaddtoone(nf,x,{y}): if y is omitted, when the sum of the ideals in the number field K defined by nf and given in the vector x is equal to Z_K, gives a vector of elements of the corresponding ideals who sum to 1. Otherwise, x and y are ideals, and if they sum up to 1, find one element in each of them such that the sum is 1."},
{"idealappr",0,(void*)idealappr0,14,"GGD0,L,","idealappr(nf,x,{flag}): 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; x may also be a prime ideal factorization with possibly zero exponents. flag is deprecated (ignored), kept for backward compatibility."},
{"idealchinese",0,(void*)idealchinese,14,"GGDG","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. If y is omitted, return a data structure which can be used in place of x in later calls."},
{"idealcoprime",0,(void*)idealcoprime,14,"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."},
{"idealdiv",0,(void*)idealdiv0,14,"GGGD0,L,","idealdiv(nf,x,y,{flag=0}): quotient x/y of two ideals x and y in HNF in the number field nf. If (optional) flag is nonzero, the quotient is supposed to be an integral ideal (slightly faster)."},
{"idealdown",0,(void*)idealdown,14,"GG","idealdown(nf,x): finds the intersection of the ideal x with Q."},
{"idealfactor",0,(void*)gpidealfactor,14,"GGDG","idealfactor(nf,x,{lim}): factorization of the ideal x into prime ideals in the number field nf. If lim is set return partial factorization, using primes < lim."},
{"idealfactorback",0,(void*)idealfactorback,14,"GGDGD0,L,","idealfactorback(nf,f,{e},{flag = 0}): given a factorization f, gives the ideal product back. If e is present, f has to be a vector of the same length, and we return the product of the f[i]^e[i]. If flag is nonzero, perform idealred along the way."},
{"idealfrobenius",0,(void*)idealfrobenius,14,"GGG","idealfrobenius(nf,gal,pr): returns the Frobenius element (pr|nf/Q) attached to the unramified prime ideal pr in prid format, in the Galois group gal of the number field nf."},
{"idealfromgens",0,(void*)idealfromgens,14,"GG","idealfromgens(nf,v): hermite normal form of the (fractional) ideal of the number field nf generated as Z_K module by the components of the vector which must belong to nf."},
{"idealhnf",0,(void*)idealhnf0,14,"GGDG","idealhnf(nf,u,{v}): hermite normal form of the ideal u in the number field nf if v is omitted. If called as idealhnf(nf,u,v), the ideal is given as uZ_K + vZ_K in the number field K defined by nf."},
{"idealintersect",0,(void*)idealintersect,14,"GGG","idealintersect(nf,A,B): intersection of two ideals A and B in the number field defined by nf."},
{"idealinv",0,(void*)idealinv,14,"GG","idealinv(nf,x): inverse of the ideal x in the number field nf."},
{"idealismaximal",0,(void*)idealismaximal,14,"GG","idealismaximal(nf,x): if x is a maximal ideal, return it in prid form, else return 0."},
{"idealispower",0,(void*)idealispower,14,"lGGLD&","idealispower(nf,A,n,{&B}): return 1 if A = B^n is an n-th power else return 0."},
{"ideallist",0,(void*)gideallist,14,"GGD4,L,","ideallist(nf,bound,{flag=4}): vector of vectors L of all idealstar of all ideals of norm<=bound. If (optional) flag is present, its binary digits are toggles meaning 1: give generators; 2: add units; 4: give only the ideals and not the bid; 8: omit ideals which cannot be conductors."},
{"ideallistarch",0,(void*)ideallistarch,14,"GGG","ideallistarch(nf,list,arch): list is a vector of vectors of bid's as output by ideallist. Return a vector of vectors with the same number of components as the original list. The leaves give information about moduli whose finite part is as in original list, in the same order, and Archimedean part is now arch. The information contained is of the same kind as was present in the input."},
{"ideallog",0,(void*)ideallog,14,"DGGG","ideallog({nf},x,bid): if bid is a big ideal, as given by idealstar(nf,D,...), gives the vector of exponents on the generators bid.gen (even if these generators have not been explicitly computed)."},
{"idealmin",0,(void*)idealmin,14,"GGDG","idealmin(nf,ix,{vdir}): pseudo-minimum of the ideal ix in the direction vdir in the number field nf."},
{"idealmul",0,(void*)idealmul0,14,"GGGD0,L,","idealmul(nf,x,y,{flag=0}): product of the two ideals x and y in the number field nf. If (optional) flag is nonzero, reduce the result."},
{"idealnorm",0,(void*)idealnorm,14,"GG","idealnorm(nf,x): norm of the ideal x in the number field nf."},
{"idealnumden",0,(void*)idealnumden,14,"GG","idealnumden(nf,x): returns [A,B], where A,B are coprime integer ideals such that x = A/B."},
{"idealpow",0,(void*)idealpow0,14,"GGGD0,L,","idealpow(nf,x,k,{flag=0}): k-th power of the ideal x in HNF in the number field nf. If (optional) flag is nonzero, reduce the result."},
{"idealprimedec",0,(void*)idealprimedec_limit_f,14,"GGD0,L,","idealprimedec(nf,p,{f=0}): prime ideal decomposition of the prime number p in the number field nf as a vector of prime ideals. If f is present and nonzero, restrict the result to primes of residue degree <= f."},
{"idealprincipalunits",0,(void*)idealprincipalunits,14,"GGL","idealprincipalunits(nf,pr,k): returns the structure [no, cyc, gen] of the multiplicative group (1 + pr) / (1 + pr^k)."},
{"idealramgroups",0,(void*)idealramgroups,14,"GGG","idealramgroups(nf,gal,pr): let pr be a prime ideal in prid format, and gal the Galois group of the number field nf, return a vector g such that g[1] is the decomposition group of pr, g[2] is the inertia group, g[i] is the (i-2)th ramification group of pr, all trivial subgroups being omitted."},
{"idealred",0,(void*)idealred0,14,"GGDG","idealred(nf,I,{v=0}): LLL reduction of the ideal I in the number field nf along direction v, in HNF."},
{"idealredmodpower",0,(void*)idealredmodpower,14,"GGUD0,U,","idealredmodpower(nf,x,n,{B=factorlimit}): return b such that x * b^n = v is small."},
{"idealstar",0,(void*)idealstarmod,14,"DGGD1,L,DG","idealstar({nf},N,{flag=1},{cycmod}): gives the structure of (Z_K/N)^*, where N is a modulus (an ideal in any form or a vector [f0, foo], where f0 is an ideal and foo is a {0,1}-vector with r1 components. If the positive integer cycmod is present,  only compute the group modulo cycmod-th powers. flag is optional, and can be 0: structure as an abelian group [h,d,g] where h is the order, d the orders of the cyclic factors and g the generators; if flag=1 (default), gives a bid structure used in ideallog to compute discrete logarithms; underlying generators are well-defined but not explicitly computed, which saves time; if flag=2, same as with flag=1 except that the generators are also given. If nf is omitted, N must be an integer and we return the structure of (Z/NZ)^*."},
{"idealtwoelt",0,(void*)idealtwoelt0,14,"GGDG","idealtwoelt(nf,x,{a}): two-element representation of an ideal x in the number field nf. If (optional) a is nonzero, first element will be equal to a."},
{"idealval",0,(void*)gpidealval,14,"GGG","idealval(nf,x,pr): valuation at pr given in idealprimedec format of the ideal x in the number field nf."},
{"if",0,(void*)ifpari,1,"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."},
{"iferr",0,(void*)iferrpari,1,"EVEDE","iferr(seq1,E,seq2,{pred}): evaluates the expression sequence seq1. If an error occurs, set the formal parameter E set to the error data. If pred is not present or evaluates to true, catch the error and evaluate seq2. Both pred and seq2 can reference E."},
{"imag",0,(void*)gimag,6,"G","imag(x): imaginary part of x."},
{"incgam",0,(void*)incgam0,12,"GGDGp","incgam(s,x,{g}): incomplete gamma function. g is optional and is the precomputed value of gamma(s)."},
{"incgamc",0,(void*)incgamc,12,"GGp","incgamc(s,x): complementary incomplete gamma function."},
{"inline",0,NULL,2,NULL,"inline(x,...,z): declares x,...,z as inline variables. DEPRECATED, use export."},
{"input",0,(void*)gp_input,2,"","input(): read an expression from the input file or standard input."},
{"install",0,(void*)gpinstall,2,"vrrD\"\",r,D\"\",s,","install(name,code,{gpname},{lib}): load from dynamic library 'lib' the function 'name'. Assign to it the name 'gpname' in this GP session, with prototype 'code'. If 'lib' is omitted, all symbols known to gp (includes the whole 'libpari.so' and possibly others) are available. If 'gpname' is omitted, use 'name'."},
{"intcirc",0,(void*)intcirc0,13,"V=GGEDGp","intcirc(X=a,R,expr,{tab}): numerical integration of expr on the circle |z-a|=R, divided by 2*I*Pi. tab is as in intnum."},
{"intformal",0,(void*)integ,10,"GDn","intformal(x,{v}): formal integration of x with respect to v, or to the main variable of x if v is omitted."},
{"intfuncinit",0,(void*)intfuncinit0,13,"V=GGED0,L,p","intfuncinit(t=a,b,f,{m=0}): initialize tables for integrations from a to b using a weight f(t). For integral transforms such as Fourier or Mellin transforms."},
{"intnum",0,(void*)intnum0,13,"V=GGEDGp","intnum(X=a,b,expr,{tab}): numerical integration of expr from a to b with respect to X. Plus/minus infinity is coded as +oo/-oo. Finally tab is either omitted (let the program choose the integration step), a nonnegative integer m (divide integration step by 2^m), or data precomputed with intnuminit."},
{"intnumgauss",0,(void*)intnumgauss0,13,"V=GGEDGp","intnumgauss(X=a,b,expr,{tab}): numerical integration of expr from a to b, a compact interval, with respect to X using Gauss-Legendre quadrature. tab is either omitted (and will be recomputed) or precomputed with intnumgaussinit."},
{"intnumgaussinit",0,(void*)intnumgaussinit,13,"D0,L,p","intnumgaussinit({n}): initialize tables for n-point Gauss-Legendre integration on a compact interval."},
{"intnuminit",0,(void*)intnuminit,13,"GGD0,L,p","intnuminit(a,b,{m=0}): initialize tables for integrations from a to b. See help for intnum for coding of a and b. Possible types: compact interval, semi-compact (one extremity at + or - infinity) or R, and very slowly, slowly or exponentially decreasing, or sine or cosine oscillating at infinities."},
{"intnumosc",0,(void*)intnumosc0,13,"V=GEGD0,L,DGp","intnumosc(x=a,expr,H,{flag=0},{tab}): numerical integration from a to oo of oscillating quasi-periodic function expr of half-period H. tab is either omitted (and will be recomputed) or precomputed with intnumgaussinit; flag is either 0 (Sidi extrapolation, safe mode), 1 (Sidi extrapolation, unsafe mode), 2 (sumalt), 3 (sumnumlagrange), 4 (sumpos)."},
{"intnumromb",0,(void*)intnumromb0,13,"V=GGED0,L,b","intnumromb(X=a,b,expr,{flag=0}): numerical integration of expr (smooth in ]a,b[) from a to b with respect to X. flag is optional and mean 0: default. expr can be evaluated exactly on [a,b]; 1: general function; 2: a or b can be plus or minus infinity (chosen suitably), but of same sign; 3: expr has only limits at a or b."},
{"isfundamental",0,(void*)isfundamental,8,"lG","isfundamental(D): true(1) if D is a fundamental discriminant (including 1), false(0) if not."},
{"ispolygonal",0,(void*)ispolygonal,8,"lGGD&","ispolygonal(x,s,{&N}): true(1) if x is an s-gonal number, false(0) if not (s > 2). If N is given set it to n if x is the n-th s-gonal number."},
{"ispower",0,(void*)ispower,8,"lGDGD&","ispower(x,{k},{&n}): if k > 0 is given, return true (1) if x is a k-th power, false (0) if not. If k is omitted, return the maximal k >= 2 such that x = n^k is a perfect power, or 0 if no such k exist. If n is present, and the function returns a nonzero result, set n to the k-th root of x."},
{"ispowerful",0,(void*)ispowerful,8,"lG","ispowerful(x): true(1) if x is a powerful integer (valuation at all primes dividing x is greater than 1), false(0) if not."},
{"isprime",0,(void*)gisprime,8,"GD0,L,","isprime(x,{flag=0}): true(1) if x is a (proven) prime number, false(0) if not. If flag is 0 or omitted, use a combination of algorithms. If flag is 1, the primality is certified by the Pocklington-Lehmer Test. If flag is 2, the primality is certified using the APRCL test. If flag is 3, use ECPP."},
{"isprimepower",0,(void*)isprimepower,8,"lGD&","isprimepower(x,{&n}): if x = p^k is a prime power (p prime, k > 0), return k, else return 0. If n is present, and the function returns a nonzero result, set n to p, the k-th root of x."},
{"ispseudoprime",0,(void*)gispseudoprime,8,"GD0,L,","ispseudoprime(x,{flag}): true(1) if x is a strong pseudoprime, false(0) if not. If flag is 0 or omitted, use BPSW test, otherwise use strong Rabin-Miller test for flag randomly chosen bases."},
{"ispseudoprimepower",0,(void*)ispseudoprimepower,8,"lGD&","ispseudoprimepower(x,{&n}): if x = p^k is a pseudo-prime power (p pseudo-prime, k > 0), return k, else return 0. If n is present, and the function returns a nonzero result, set n to p, the k-th root of x."},
{"issquare",0,(void*)issquareall,8,"lGD&","issquare(x,{&n}): true(1) if x is a square, false(0) if not. If n is given puts the exact square root there if it was computed."},
{"issquarefree",0,(void*)issquarefree,8,"lG","issquarefree(x): true(1) if x is squarefree, false(0) if not."},
{"istotient",0,(void*)istotient,8,"lGD&","istotient(x,{&N}): true(1) if x = eulerphi(n) for some integer n, false(0) if not. If N is given, set N = n as well."},
{"kill",0,(void*)kill0,2,"vr","kill(sym): restores the symbol sym to its ``undefined'' status and kill attached help messages."},
{"kronecker",0,(void*)kronecker,9,"lGG","kronecker(x,y): kronecker symbol (x/y)."},
{"lambertw",0,(void*)glambertW,12,"GD0,L,p","lambertw(y,{branch=0}): solution of the implicit equation x*exp(x)=y. In the p-adic case, give a solution of x*exp(x)=y if y has valuation > 1 (or p odd and positive valuation), of log(x)+x=log(y) otherwise."},
{"laurentseries",0,(void*)laurentseries0,13,"GDPDnp","laurentseries(f,{M=seriesprecision},{x='x}): expand f around 0 as a Laurent series in x to order M."},
{"lcm",0,(void*)glcm0,5,"GDG","lcm(x,{y}): least common multiple of x and y, i.e. x*y / gcd(x,y) up to units."},
{"length",0,(void*)glength,6,"lG","length(x): number of non code words in x, number of characters for a string."},
{"lerchphi",0,(void*)lerchphi,12,"GGGp","lerchphi(z,s,a): Lerch transcendent equal to sum for n >= 0 of z^n / (n+a)^s for reasonable values of the arguments."},
{"lerchzeta",0,(void*)lerchzeta,12,"GGGp","lerchzeta(s,a,lam): Lerch zeta function equal to sum for n >= 0 of e^(2 pi i lam n) / (n+a)^s for reasonable values of the arguments."},
{"lex",0,(void*)lexcmp,5,"iGG","lex(x,y): compare x and y lexicographically (1 if x>y, 0 if x=y, -1 if x<y)."},
{"lfun",0,(void*)lfun0,20,"GGD0,L,b","lfun(L,s,{D=0}): compute the L-function value L(s), or if D is set, the derivative of order D at s. L is either an Lmath, an Ldata or an Linit."},
{"lfunan",0,(void*)lfunan,20,"GLp","lfunan(L,n): compute the first n terms of the Dirichlet series  attached to the L-function given by L (Lmath, Ldata or Linit)."},
{"lfunartin",0,(void*)lfunartin,20,"GGGLb","lfunartin(nf,gal,rho,n): returns the Ldata structure attached to the Artin L-function provided by the representation rho of the Galois group of the extension K/Q, defined over the cyclotomic field Q(zeta_n), where nf is the nfinit structure attached to K, gal is the galoisinit structure attached to K/Q, and rho is given either by the values of its character on the conjugacy classes or by the matrices that are the images of the generators. Cyclotomic numbers in rho are represented by polynomials, whose variable is understood as the complex number exp(2*I*Pi/n)."},
{"lfuncheckfeq",0,(void*)lfuncheckfeq,20,"lGDGb","lfuncheckfeq(L,{t}): given an L-function (Lmath, Ldata or Linit), check whether the functional equation is satisfied. If the function has poles, the polar part must be specified. The program returns a bit accuracy which should be a large negative value close to the current bit accuracy. If t is given, it checks the functional equation for the theta function at t and 1/t."},
{"lfunconductor",0,(void*)lfunconductor,20,"GDGD0,L,b","lfunconductor(L,{setN=10000},{flag=0}): gives the conductor of the given L-function, expecting to find it in the interval [1,setN]. If flag=0 (default), gives either the conductor found as an integer, or a vector of conductors found, possibly empty. If flag=1, same but gives the computed floating point approximations to the conductors found, without rounding to integers. If flag=2, gives all the conductors found, even those far from integers. Alternatively, setN can contain a list of possible conductors and we select the best one according to lfuncheckfeq; in this case, flag is ignored and we return [N, lfuncheckfeq for that N]."},
{"lfuncost",0,(void*)lfuncost0,20,"GDGD0,L,b","lfuncost(L,{sdom},{der=0}): estimate the cost of running lfuninit(L,sdom,der) at current bit precision. Returns [t,b], to indicate that t coefficients a_n will be computed at bit accuracy b. Subsequent evaluation of lfun at s evaluates a polynomial of degree t at exp(h s). If L is already an Linit, then sdom and der are ignored."},
{"lfuncreate",0,(void*)lfuncreate,20,"G","lfuncreate(obj): given either an object such as a polynomial, elliptic curve, Dirichlet or Hecke character, eta quotient, etc., or an explicit 6 or 7 component vector [dir,real,Vga,k,N,eps,r], create the Ldata structure necessary for lfun computation."},
{"lfundiv",0,(void*)lfundiv,20,"GGb","lfundiv(L1,L2): creates the Ldata structure (without  initialization) corresponding to the quotient of the Dirichlet series  given by L1 and L2."},
{"lfundual",0,(void*)lfundual,20,"Gb","lfundual(L): creates the Ldata structure (without initialization) corresponding to the dual L-function of L."},
{"lfunetaquo",0,(void*)lfunetaquo,20,"G","lfunetaquo(M): returns the Ldata structure attached to the modular form z->prod(i=1,#M[,1],eta(M[i,1]*z)^M[i,2])."},
{"lfuneuler",0,(void*)lfuneuler,20,"GGp","lfuneuler(L,p): return the Euler factor at p  of the L-function given by L (Lmath, Ldata or Linit) assuming the L-function  admits an Euler product factorization and that it can be determined."},
{"lfungenus2",0,(void*)lfungenus2,20,"G","lfungenus2(F): returns the Ldata structure attached to the L-function attached to the genus-2 curve defined by y^2=F(x) or y^2+Q(x)*y=P(x) if F=[P,Q]. Currently, only odd conductors are supported."},
{"lfunhardy",0,(void*)lfunhardy,20,"GGb","lfunhardy(L,t): variant of the Hardy L-function attached to L, used for plotting on the critical line."},
{"lfunhgm",0,(void*)lfunhgm,21,"GGDGb","lfunhgm(H,t,{hint}): (H,t) being a hypergeometric motive, returns the corresponding lfuncreate data for use with the L function package."},
{"lfuninit",0,(void*)lfuninit0,20,"GGD0,L,b","lfuninit(L,sdom,{der=0}): precompute data for evaluating the L-function given by 'L' (and its derivatives of order der, if set) in rectangular domain sdom = [center,w,h] centered on the real axis, |Re(s)-center| <= w, |Im(s)| <= h, where all three components of sdom are real and w,h are nonnegative. The subdomain [k/2, 0, h] on the critical line can be encoded as [h] for brevity."},
{"lfunlambda",0,(void*)lfunlambda0,20,"GGD0,L,b","lfunlambda(L,s,{D=0}): compute the completed L function Lambda(s), or if D is set, the derivative of order D at s. L is either an Lmath, an Ldata or an Linit."},
{"lfunmf",0,(void*)lfunmf,22,"GDGb","lfunmf(mf,{F}): If F is a modular form in mf, output the L-functions corresponding to its complex embeddings. If F is omitted, output the L-functions corresponding to all eigenforms in the new space."},
{"lfunmfspec",0,(void*)lfunmfspec,20,"Gb","lfunmfspec(L): L corresponding to a modular eigenform, returns [vo,ve,om,op] in even weight, where vo (resp., ve) is the vector of odd (resp., even) periods, and om and op the corresponding real numbers omega^- and omega^+. Returns [v,om] in odd weight."},
{"lfunmul",0,(void*)lfunmul,20,"GGb","lfunmul(L1,L2): creates the Ldata structure (without  initialization) corresponding to the product of the Dirichlet series  given by L1 and L2."},
{"lfunorderzero",0,(void*)lfunorderzero,20,"lGD-1,L,b","lfunorderzero(L,{m=-1}): computes the order of the possible zero of the L-function at the center k/2 of the critical strip. If m is given and has a nonnegative value, assumes the order is at most m."},
{"lfunparams",0,(void*)lfunparams,20,"Gp","lfunparams(ldata): returns the parameters [N, k, vga] of the L-function  defined by ldata (see lfuncreate).  The parameters Vga (gamma shifts) are returned to the current precision."},
{"lfunqf",0,(void*)lfunqf,20,"Gp","lfunqf(Q): returns the Ldata structure attached to the theta function of the lattice attached to the definite positive quadratic form Q."},
{"lfunrootres",0,(void*)lfunrootres,20,"Gb","lfunrootres(data): given the Ldata attached to an L-function (or the output of lfunthetainit), compute the root number and the residues. In the present implementation, if the polar part is not already known completely, at most a single pole is allowed. The output is a 3-component vector  [[[a_1, r_1],...,[a_n, r_n],[[b_1, R_1],...[b_m,R_m]]~, w], where r_i is the  polar part of L(s) at a_i, R_i is is the polar part of Lambda(s) at b_i,  or [0,0,r] if there is no pole, and r is the root number."},
{"lfunshift",0,(void*)lfunshift,20,"GGD0,L,b","lfunshift(L,d,{flag}): creates the Ldata structure (without initialization) corresponding to the function Ld such that Ld(s) = L(s-d). If fl=1, return the product L*Ld instead."},
{"lfunsympow",0,(void*)lfunsympow,20,"GU","lfunsympow(E,m): returns the Ldata structure attached to the L-function attached to m-th symmetric power of the elliptic curve E defined over the rationals."},
{"lfuntheta",0,(void*)lfuntheta,20,"GGD0,L,b","lfuntheta(data,t,{m=0}): compute the value of the m-th derivative at t of the theta function attached to the L-function given by data. data can be either the standard L-function data, or the output of lfunthetainit."},
{"lfunthetacost",0,(void*)lfunthetacost0,20,"lGDGD0,L,b","lfunthetacost(L,{tdom},{m=0}): estimates the cost of running lfunthetainit(L,tdom,m) at current bit precision. Returns the number of coefficients an that would be computed. Subsequent evaluation of lfuntheta computes that many values of gammamellininv. If L is already an Linit, then tdom and m are ignored."},
{"lfunthetainit",0,(void*)lfunthetainit,20,"GDGD0,L,b","lfunthetainit(L,{tdom},{m=0}): precompute data for evaluating  the m-th derivative of theta functions with argument in domain tdom  (by default t is real >= 1)."},
{"lfuntwist",0,(void*)lfuntwist,20,"GGb","lfuntwist(L,chi): creates the Ldata structure (without initialization) corresponding to the twist of L by the primitive character attached to the Dirichlet L-function chi. This requires that the conductor of the character is coprime to the conductor of the L-function L."},
{"lfunzeros",0,(void*)lfunzeros,20,"GGD8,L,b","lfunzeros(L,lim,{divz=8}): lim being either an upper limit or a real interval, computes an ordered list of zeros of L(s) on the critical line up to the given upper limit or in the given interval. Use a naive algorithm which may miss some zeros. To use a finer search mesh, set divz to some integral value larger than the default (= 8)."},
{"lift",0,(void*)lift0,6,"GDn","lift(x,{v}): if v is omitted, lifts elements of Z/nZ to Z, of Qp to Q, and of K[x]/(P) to K[x]. Otherwise lift only polmods with main variable v."},
{"liftall",0,(void*)liftall,6,"G","liftall(x): lifts every element of Z/nZ to Z, of Qp to Q, and of K[x]/(P) to K[x]."},
{"liftint",0,(void*)liftint,6,"G","liftint(x): lifts every element of Z/nZ to Z and of Qp to Q."},
{"liftpol",0,(void*)liftpol,6,"G","liftpol(x): lifts every polmod component of x to polynomials."},
{"limitnum",0,(void*)limitnum0,13,"GDGp","limitnum(expr,{alpha=1}): numerical limit of sequence expr using Lagrange-Zagier extrapolation; assume u(n) ~ sum a_i n^(-alpha*i)."},
{"lindep",0,(void*)lindep0,11,"GD0,L,","lindep(v,{flag=0}): integral linear dependencies between components of v. flag is optional, and can be 0: default, guess a suitable accuracy, or positive: accuracy to use for the computation, in decimal digits."},
{"listinsert",0,(void*)listinsert0,2,"mWGL","listinsert(~L,x,n): insert x at index n in list L, shifting the remaining elements to the right."},
{"listpop",0,(void*)listpop0,2,"vWD0,L,","listpop(~list,{n}): removes n-th element from list. If n is omitted or greater than the current list length, removes last element."},
{"listput",0,(void*)listput0,2,"mWGD0,L,","listput(~list,x,{n}): sets n-th element of list equal to x. If n is omitted or greater than the current list length, appends x."},
{"listsort",0,(void*)listsort,2,"vWD0,L,","listsort(~L,{flag=0}): sort the list L in place. If flag is nonzero, suppress all but one occurrence of each element in list."},
{"lngamma",0,(void*)glngamma,12,"Gp","lngamma(x): logarithm of the gamma function of x."},
{"local",0,NULL,2,NULL,"local(x,...,z): declare x,...,z as (dynamically scoped) local variables."},
{"localbitprec",0,(void*)localbitprec,2,"vG","localbitprec(p): set the real precision to p bits in the dynamic scope."},
{"localprec",0,(void*)localprec,2,"vG","localprec(p): set the real precision to p in the dynamic scope"},
{"log",0,(void*)glog,12,"Gp","log(x): natural logarithm of x."},
{"log1p",0,(void*)glog1p,12,"Gp","log1p(x): log(1+x)"},
{"logint",0,(void*)logint0,8,"lGGD&","logint(x,b,{&z}): return the largest non-negative integer e so that b^e <= x, where b > 1 is an integer and x >= 1 is a real number. If the parameter z is present, set it to b^e."},
{"mapapply",0,(void*)mapapply,2,"WGGDG","mapapply(~M,x,f,{u}): applies the closure f to the image of x by the map M and returns the evaluation of f."},
{"mapdelete",0,(void*)mapdelete,2,"vWG","mapdelete(~M,x): removes x from the domain of the map M."},
{"mapget",0,(void*)mapget,2,"GG","mapget(M,x): returns the image of x by the map M."},
{"mapisdefined",0,(void*)mapisdefined,2,"iGGD&","mapisdefined(M,x,{&z}): true (1) if x has an image by the map M, false (0) otherwise. If z is present, set it to the image of x, if it exists."},
{"mapput",0,(void*)mapput,2,"vWGG","mapput(~M,x,y): associates x to y in the map M."},
{"matadjoint",0,(void*)matadjoint0,11,"GD0,L,","matadjoint(M,{flag=0}): adjoint matrix of M using Leverrier-Faddeev's algorithm. If flag is 1, computes the characteristic polynomial independently first."},
{"matalgtobasis",0,(void*)matalgtobasis,14,"GG","matalgtobasis(nf,x): nfalgtobasis applied to every element of the vector or matrix x."},
{"matbasistoalg",0,(void*)matbasistoalg,14,"GG","matbasistoalg(nf,x): nfbasistoalg applied to every element of the matrix or vector x."},
{"matcompanion",0,(void*)matcompanion,11,"G","matcompanion(x): companion matrix to polynomial x."},
{"matconcat",0,(void*)matconcat,11,"G","matconcat(v): concatenate the entries of v and return the resulting matrix."},
{"matdet",0,(void*)det0,11,"GD0,L,","matdet(x,{flag=0}): determinant of the matrix x using an appropriate algorithm depending on the coefficients. If (optional) flag is set to 1, use classical Gaussian elimination (usually worse than the default)."},
{"matdetint",0,(void*)detint,11,"G","matdetint(B): some multiple of the determinant of the lattice generated by the columns of B (0 if not of maximal rank). Useful with mathnfmod."},
{"matdetmod",0,(void*)matdetmod,11,"GG","matdetmod(x,d): determinant of the matrix x modulo d."},
{"matdiagonal",0,(void*)diagonal,11,"G","matdiagonal(x): creates the diagonal matrix whose diagonal entries are the entries of the vector x."},
{"mateigen",0,(void*)mateigen,11,"GD0,L,p","mateigen(x,{flag=0}): complex eigenvectors of the matrix x given as columns of a matrix H. If flag=1, return [L,H], where L contains the eigenvalues and H the corresponding eigenvectors."},
{"matfrobenius",0,(void*)matfrobenius,11,"GD0,L,Dn","matfrobenius(M,{flag},{v='x}): return the Frobenius form of the square matrix M. If flag is 1, return only the elementary divisors as a vector of polynomials in the variable v. If flag is 2, return a two-components vector [F,B] where F is the Frobenius form and B is the basis change so that M=B^-1*F*B."},
{"mathess",0,(void*)hess,11,"G","mathess(x): Hessenberg form of x."},
{"mathilbert",0,(void*)mathilbert,11,"L","mathilbert(n): Hilbert matrix of order n."},
{"mathnf",0,(void*)mathnf0,11,"GD0,L,","mathnf(M,{flag=0}): (upper triangular) Hermite normal form of M, basis for the lattice formed by the columns of M. Basic values of flag are 0 (default): only return the Hermite normal form H, 1: return [H,U] such that H is the HNF of M, and U is an invertible matrix such that MU=H. These two use a naive algorithm; larger values of flag correspond to more involved algorithms and are restricted to integer matrices; flag = 4: returns [H,U] using LLL reduction along the way; flag = 5: return [H,U,P] where P is a permutation of row indices such that P applied to M U is H."},
{"mathnfmod",0,(void*)hnfmod,11,"GG","mathnfmod(x,d): (upper triangular) Hermite normal form of x, basis for the lattice formed by the columns of x, where d is a multiple of the nonzero determinant of this lattice."},
{"mathnfmodid",0,(void*)hnfmodid,11,"GG","mathnfmodid(x,d): (upper triangular) Hermite normal form of x concatenated with matdiagonal(d)."},
{"mathouseholder",0,(void*)mathouseholder,11,"GG","mathouseholder(Q,v): applies a sequence Q of Householder transforms to the vector or matrix v."},
{"matid",0,(void*)matid,11,"L","matid(n): identity matrix of order n."},
{"matimage",0,(void*)matimage0,11,"GD0,L,","matimage(x,{flag=0}): basis of the image of the matrix x. flag is optional and can be set to 0 or 1, corresponding to two different algorithms."},
{"matimagecompl",0,(void*)imagecompl,11,"G","matimagecompl(x): vector of column indices not corresponding to the indices given by the function matimage."},
{"matimagemod",0,(void*)matimagemod,11,"GGD&","matimagemod(x,d,&U): basis of the image of the matrix x modulo d."},
{"matindexrank",0,(void*)indexrank,11,"G","matindexrank(M): gives two extraction vectors (rows and columns) for the matrix M such that the extracted matrix is square of maximal rank."},
{"matintersect",0,(void*)intersect,11,"GG","matintersect(x,y): intersection of the vector spaces whose bases are the columns of x and y."},
{"matinverseimage",0,(void*)inverseimage,11,"GG","matinverseimage(x,y): an element of the inverse image of the vector y by the matrix x if one exists, the empty vector otherwise."},
{"matinvmod",0,(void*)matinvmod,11,"GG","matinvmod(x,d): left inverse of the matrix x modulo d."},
{"matisdiagonal",0,(void*)isdiagonal,11,"iG","matisdiagonal(x): true(1) if x is a diagonal matrix, false(0) otherwise."},
{"matker",0,(void*)matker0,11,"GD0,L,","matker(x,{flag}): basis of the kernel of the matrix x; flag is obsolete, ignore it."},
{"matkerint",0,(void*)matkerint0,11,"GD0,L,","matkerint(x,{flag=0}): LLL-reduced Z-basis of the kernel of the matrix x with integral entries; flag is deprecated, kept for backward compatibility."},
{"matkermod",0,(void*)matkermod,11,"GGD&","matkermod(x,d,&im): basis of the kernel of the matrix x modulo d."},
{"matmodhnf",0,(void*)matmodhnf,11,"GGD&","matmodhnf(A,H, {&Q}): reduce the column vector or matrix A modulo the HNF matrix H (integral, square, with positive diagonal elements). If Q is present, set it to the matrix such that A = H*Q + R, where R is the reduction."},
{"matmuldiagonal",0,(void*)matmuldiagonal,11,"GG","matmuldiagonal(x,d): product of matrix x by diagonal matrix whose diagonal coefficients are those of the vector d, equivalent but faster than x*matdiagonal(d)."},
{"matmultodiagonal",0,(void*)matmultodiagonal,11,"GG","matmultodiagonal(x,y): product of matrices x and y, knowing that the result will be a diagonal matrix. Much faster than general multiplication in that case."},
{"matpascal",0,(void*)matqpascal,11,"LDG","matpascal(n,{q}): Pascal triangle of order n if q is omitted. q-Pascal triangle otherwise."},
{"matpermanent",0,(void*)matpermanent,11,"G","matpermanent(x): permanent of the matrix x."},
{"matqr",0,(void*)matqr,11,"GD0,L,p","matqr(M,{flag=0}): returns [Q,R], the QR-decomposition of the square invertible matrix M. If flag=1, Q is given as a sequence of Householder transforms (faster and stabler)."},
{"matrank",0,(void*)rank,11,"lG","matrank(x): rank of the matrix x."},
{"matreduce",0,(void*)matreduce,11,"G","matreduce(m): reduce the factorization matrix m to canonical form (sorted first column with unique elements) matrix."},
{"matrix",0,(void*)matrice,11,"GDGDVDVDE","matrix(m,{n=m},{X},{Y},{expr=0}): m x n matrix of expression expr, where the row variable X goes from 1 to m and the column variable Y goes from 1 to n. By default, fill with 0s."},
{"matrixqz",0,(void*)matrixqz0,11,"GDG","matrixqz(A,{p=0}): if p>=0, transforms the rational or integral mxn (m>=n) matrix A into an integral matrix with gcd of maximal determinants coprime to p. If p=-1, finds a basis of the intersection with Z^n of the lattice spanned by the columns of A. If p=-2, finds a basis of the intersection with Z^n of the Q-vector space spanned by the columns of A."},
{"matsize",0,(void*)matsize,11,"G","matsize(x): number of rows and columns of the vector/matrix x as a 2-vector."},
{"matsnf",0,(void*)matsnf0,11,"GD0,L,","matsnf(X,{flag=0}): Smith normal form (i.e. elementary divisors) of the matrix X, expressed as a vector d; X must have integer or polynomial entries. Binary digits of flag mean 1: returns [u,v,d] where d=u*X*v, otherwise only the diagonal d is returned, 4: removes all information corresponding to entries equal to 1 in d."},
{"matsolve",0,(void*)gauss,11,"GG","matsolve(M,B): solution of MX=B (M matrix, B column vector or matrix)."},
{"matsolvemod",0,(void*)matsolvemod,11,"GGGD0,L,","matsolvemod(M,D,B,{flag=0}): one solution of system of congruences MX=B mod D (M matrix, B and D column vectors). If (optional) flag is nonzero return all solutions."},
{"matsupplement",0,(void*)suppl,11,"G","matsupplement(x): supplement the columns of the matrix x to an invertible matrix."},
{"mattranspose",0,(void*)gtrans,11,"G","mattranspose(x): x~ = transpose of x."},
{"max",0,(void*)gmax,5,"GG","max(x,y): maximum of x and y."},
{"mfDelta",0,(void*)mfDelta,22,"","mfDelta(): mf corresponding to the Ramanujan Delta function."},
{"mfEH",0,(void*)mfEH,22,"G","mfEH(k): k>0 being in 1/2+Z, mf corresponding to the Cohen-Eisenstein series H_k of weight k on G_0(4)."},
{"mfEk",0,(void*)mfEk,22,"L","mfEk(k): mf corresponding to the standard Eisenstein series E_k for nonnegative even integer k."},
{"mfTheta",0,(void*)mfTheta,22,"DG","mfTheta({Psi=1}): the unary theta function corresponding to the primitive Dirichlet character Psi, hence of weight 1/2 if Psi is even, of weight 3/2 if Psi is odd."},
{"mfatkin",0,(void*)mfatkin,22,"GG","mfatkin(mfatk,f): Given an mfatk output by mfatk = mfatkininit(mf,Q) and a modular form f belonging to the space mf, returns the modular form g = C*f|W_Q where C = mfatk[3] is a normalizing constant so that g has the same field of coefficients as f; mfatk[1] = mf2 (or 0 if mf2=mf) which is the space to which g belongs."},
{"mfatkineigenvalues",0,(void*)mfatkineigenvalues,22,"GLp","mfatkineigenvalues(mf,Q): given a modular form space mf and a primitive divisor Q of the level of mf, outputs the corresponding Atkin-Lehner eigenvalues on the new space, grouped by orbit."},
{"mfatkininit",0,(void*)mfatkininit,22,"GLp","mfatkininit(mf,Q): initializes data necessary for working with Atkin--Lehner operators W_Q, for now only the function mfatkin. The result is a 4-component vector [mfB, MC, C, mf] where mfB is either 0 or the possibly different modular form space to which F|W_Q will belong (this does not depend on F in mf); MC is the matrix of W_Q on the basis of mf multiplied by a normalizing constant C."},
{"mfbasis",0,(void*)mfbasis,22,"GD4,L,","mfbasis(NK,{space=4}): If NK=[N,k,CHI] as in mfinit, gives a basis of the corresponding subspace of M_k(G_0(N),CHI). NK can also be the output of mfinit, in which case space is ignored. To obtain the eigenforms use mfeigenbasis."},
{"mfbd",0,(void*)mfbd,22,"GL","mfbd(F,d): F being a generalized modular form, return B(d)(F), where B(d) is the expanding operator tau -> d tau."},
{"mfbracket",0,(void*)mfbracket,22,"GGD0,L,","mfbracket(F,G,{m=0}): compute the m-th Rankin-Cohen bracket of the generalized modular forms F and G."},
{"mfcoef",0,(void*)mfcoef,22,"GL","mfcoef(F,n): Compute the n-th Fourier coefficient a(n) of the generalized modular form F."},
{"mfcoefs",0,(void*)mfcoefs,22,"GLD1,L,","mfcoefs(F,n,{d=1}): Compute the vector of coefficients [a[0],a[d],...,a[nd]] of the modular form F."},
{"mfconductor",0,(void*)mfconductor,22,"lGG","mfconductor(mf,F): mf being output by mfinit and F a modular form, gives the smallest level at which F is defined."},
{"mfcosets",0,(void*)mfcosets,22,"G","mfcosets(N): list of right cosets of G_0(N)\\G, i.e., matrices g_j in G such that G = U G_0(N) g_j. The g_j are chosen in the form [a,b; c,d] with c | N."},
{"mfcuspisregular",0,(void*)mfcuspisregular,22,"lGG","mfcuspisregular(NK,cusp): In the space defined by NK = [N,k,CHI] or NK = mf, determine if cusp in canonical format (oo or denominator dividing N) is regular or not."},
{"mfcusps",0,(void*)mfcusps,22,"G","mfcusps(N): list of cusps of G_0(N) in the form a/b with b dividing N."},
{"mfcuspval",0,(void*)mfcuspval,22,"GGGb","mfcuspval(mf,F,cusp): valuation of modular form F in the space mf at cusp, which can be either oo or any rational number. The result is either a rational number or oo if F is zero. Let chi be the Nebentypus of the space mf; if Q(F) != Q(chi), return the vector of valuations attached to the [Q(F):Q(chi)] complex embeddings of F."},
{"mfcuspwidth",0,(void*)mfcuspwidth,22,"lGG","mfcuspwidth(N,cusp): width of cusp in Gamma_0(N)."},
{"mfderiv",0,(void*)mfderiv,22,"GD1,L,","mfderiv(F,{m=1}): m-th formal derivative of the power series corresponding to the generalized modular form F, with respect to the differential operator q.d/dq (default m=1)."},
{"mfderivE2",0,(void*)mfderivE2,22,"GD1,L,","mfderivE2(F,{m=1}): compute the Serre derivative (q.d/dq)F - kE_2F/12 of the generalized modular form F of weight k; and if m > 1, the m-th iterate."},
{"mfdescribe",0,(void*)mfdescribe,22,"GD&","mfdescribe(F,{&G}): gives a human-readable description of F, which is either a modular form space or a modular form. If the address of G is given, puts into G the vector of parameters of the outmost operator defining F."},
{"mfdim",0,(void*)mfdim,22,"GD4,L,","mfdim(NK,{space=4}): If NK=[N,k,CHI] as in mfinit, gives the dimension of the corresponding subspace of M_k(G_0(N),chi). The subspace is described by a small integer 'space': 0 for the newspace, 1 for the cuspidal space, 2 for the oldspace, 3 for the space of Eisenstein series and 4 (default) for the full space M_k. NK can also be the output of mfinit, in which case space must be omitted."},
{"mfdiv",0,(void*)mfdiv,22,"GG","mfdiv(F,G): compute F/G for two modular forms F and G assuming that the quotient will not have poles at infinity. If this is the case, use mfshift before doing the division."},
{"mfeigenbasis",0,(void*)mfeigenbasis,22,"G","mfeigenbasis(mf): vector of the eigenforms for the space mf."},
{"mfeigensearch",0,(void*)mfeigensearch,22,"GDG","mfeigensearch(NK,{AP}): search for normalized rational eigen cuspforms with quadratic characters given a few initial coefficients. The meaning of the parameters is as follows:  NK is of the form [N,k]: search given level N, weight k and quadratic character; note that the character is uniquely determined by (N,k). The level N can be replaced by a vector of allowed levels.  AP is the search criterion, which can be omitted: a list of pairs [...,[p,a_p],...], where a_p is either a t_INT (exact match) or a t_INTMOD (match modulo the given integer).  The result is a vector of newforms matching the search criteria, sorted by increasing level."},
{"mfeisenstein",0,(void*)mfeisenstein,22,"LDGDG","mfeisenstein(k,{CHI1},{CHI2}): create the Eisenstein E_k(CHI1,CHI2), where an omitted character is considered as trivial."},
{"mfembed",0,(void*)mfembed0,22,"GDGp","mfembed(f,{v}): if v is omitted, f must be a modular form or a modular form space with parameters [N,k,chi] and we return a vector of complex embeddings of Q(f) or Q(chi), respectively.  If v is given, it must be a scalar in Q(f), or a vector/matrix of such, we apply the embeddings coefficientwise and return a vector of results. Finally f can be replaced by a single embedding produced by mfembed(f) and we apply that particular embedding to v. Note that, in our context, Q(chi) has a single canonical embeding given by s: Mod(t, polcyclo(n,t)) -> exp(2*I*Pi/n) and Q(f) has [Q(f):Q(chi)] induced embeddings attached to the complex roots of s(P) where P = mfparams(f)[4], as ordered by polroots. In the latter case, we only support an f with Q(f) = Q(chi) or an eigenform produced by mfeigenbasis."},
{"mfeval",0,(void*)mfeval,22,"GGGb","mfeval(mf,F,vtau): computes the numerical value of the modular form F at the point vtau or the vector vtau of points in the completed upper-half plane."},
{"mffields",0,(void*)mffields,22,"G","mffields(mf): If mf is output by mfinit, gives the vector of polynomials defining each Galois orbit of the new space."},
{"mffromell",0,(void*)mffromell,22,"G","mffromell(E): E being an elliptic curve defined over Q given by an integral model in ellinit format, computes a 3-component vector [mf,F,v], where F is the newform corresponding to E by modularity, mf is the newspace to which F belongs, and v gives the coefficients of F on mfbasis(mf)."},
{"mffrometaquo",0,(void*)mffrometaquo,22,"GD0,L,","mffrometaquo(eta,{flag=0}): modular form corresponding to the eta quotient matrix eta. If the valuation v at infinity is fractional, returns 0. If the eta quotient is not holomorphic but simply meromorphic, returns 0 if flag=0; returns the eta quotient (divided by q to the power -v if v < 0, i.e., with valuation 0) if flag is set."},
{"mffromlfun",0,(void*)mffromlfun,22,"Gp","mffromlfun(L): L being an L-function representing a self-dual modular form, return [NK,space,v] where mf=mfinit(NK,space) contains the form and mftobasis(mf, v) containing it and v is mftobasis(mf,f)."},
{"mffromqf",0,(void*)mffromqf,22,"GDG","mffromqf(Q,{P = 1}): Q being an even positive definite quadratic form and P a homogeneous spherical polynomial for Q, computes a 3-component vector [mf,F,coeffs], where F is the theta function corresponding to (Q, P), mf is the corresponding space of modular forms from mfinit, and coeffs are the coefficients of F on mfbasis(mf)."},
{"mfgaloisprojrep",0,(void*)mfgaloisprojrep,22,"GGp","mfgaloisprojrep(mf,F): mf being an mf output by mfinit in weight 1, and F an eigenform, returns a polynomial defining the field fixed by the kernel of the projective representation associated to F."},
{"mfgaloistype",0,(void*)mfgaloistype,22,"GDG","mfgaloistype(NK,{F}): NK being either [N,1,CHI] or an mf output by mfinit in weight 1, gives the vector of types of Galois representations attached to each cuspidal eigenform, unless the eigenform F is specified, in which case only for F. Types A_4, S_4, A_5 are represented by minus their cardinality -12, -24, or -60, and type D_n is represented by its cardinality, the integer 2*n."},
{"mfhecke",0,(void*)mfhecke,22,"GGL","mfhecke(mf,F,n): F being a modular form in space mf, returns T(n)F, where T(n) is the n-th Hecke operator. Warning: if F is of level M<N, T(n)F is in general not the same in M_k(G_0(M),CHI) and in M_k(G_0(N),CHI). We take T(n) at the same level as the one used in mf."},
{"mfheckemat",0,(void*)mfheckemat,22,"GG","mfheckemat(mf,vecn): if vecn is an integer, matrix of the Hecke operator T(n) on the basis formed by mfbasis(mf), if it is a vector, vector of such matrices."},
{"mfinit",0,(void*)mfinit,22,"GD4,L,","mfinit(NK,{space=4}): Create the space of modular forms corresponding to the data contained in NK and space. NK is a vector which can be either [N,k] (N level, k weight) corresponding to a subspace of M_k(G_0(N)), or [N,k,CHI] (CHI a character) corresponding to a subspace of M_k(G_0(N),chi). The subspace is described by a small integer 'space': 0 for the newspace, 1 for the cuspidal space, 2 for the oldspace, 3 for the space of Eisenstein series and 4 (default) for the full space M_k"},
{"mfisCM",0,(void*)mfisCM,22,"G","mfisCM(F): Tests whether the eigenform F is a CM form. The answer is 0 if it is not, and if it is, either the unique negative discriminant of the CM field, or the pair of two negative discriminants of CM fields, this latter case occurring only in weight 1 when the projective image is D2=C2xC2, i.e., coded 4 by mfgaloistype."},
{"mfisequal",0,(void*)mfisequal,22,"lGGD0,L,","mfisequal(F,G,{lim=0}): Checks whether the modular forms F and G are equal. If lim is nonzero, only check equality of the first lim+1 Fourier coefficients."},
{"mfisetaquo",0,(void*)mfisetaquo,22,"GD0,L,","mfisetaquo(f,{flag=0}): if the generalized modular form f is a holomorphic eta quotient, return the eta quotient matrix, else return 0. If flag is set, also accept meromorphic eta quotients."},
{"mfkohnenbasis",0,(void*)mfkohnenbasis,22,"G","mfkohnenbasis(mf): mf being a cuspidal space of half-integral weight k >= 3/2, gives a basis B of the Kohnen + space of mf as a matrix whose columns are the coefficients of B on the basis of mf."},
{"mfkohnenbijection",0,(void*)mfkohnenbijection,22,"G","mfkohnenbijection(mf): mf being a cuspidal space of half-integral weight returns [mf2,M,K,shi], where M is a matrix giving a Hecke-module isomorphism from S_{2k-1}(N,CHI^2) given by mf2 to the Kohnen + space S_k+(4N,CHI), K is a basis of the Kohnen + space, and shi gives the linear combination of Shimura lifts giving M^(-1)."},
{"mfkohneneigenbasis",0,(void*)mfkohneneigenbasis,22,"GG","mfkohneneigenbasis(mf,bij): mf being a cuspidal space of half-integral weight k >= 3/2 and bij being the output of mfkohnenbijection(mf), outputs a 3-component vector [mf0,BNEW,BEIGEN], where BNEW and BEIGEN are two matrices whose columns are the coefficients of a basis of the Kohnen new space and of the eigenforms on the basis of mf respectively, and mf0 is the corresponding new space of integral weight 2k - 1."},
{"mflinear",0,(void*)mflinear,22,"GG","mflinear(vF,v): vF being a vector of modular forms and v a vector of coefficients of same length, compute the linear combination of the entries of vF with coefficients v."},
{"mfmanin",0,(void*)mfmanin,22,"Gb","mfmanin(FS): Given the modular symbol FS associated to an eigenform F by mfsymbol(mf,F), computes the odd and even special polynomials as well as the odd and even periods om- and om+ as a vector [[P-,P+],[om-,om+,r]], where r = imag(om+*conj(om-))/<F,F>. If F has several embeddings into C, give the vector of results corresponding to each embedding."},
{"mfmul",0,(void*)mfmul,22,"GG","mfmul(F,G): Multiply the two forms F and G."},
{"mfnumcusps",0,(void*)mfnumcusps,22,"G","mfnumcusps(N): number of cusps of Gamma_0(N)"},
{"mfparams",0,(void*)mfparams,22,"G","mfparams(F): If F is a modular form space, returns [N,k,CHI,space,Phi]: level, weight, character, and space code; where Phi is the cyclotomic polynomial defining the field of values of CHI. If F is a modular form, returns [N,k,CHI,P,Phi], where P is the (polynomial giving the) field of definition of F: in that case the level N may be a multiple of the level of F and the polynomial P may define a larger field than Q(F)."},
{"mfperiodpol",0,(void*)mfperiodpol,22,"GGD0,L,b","mfperiodpol(mf,f,{flag=0}): period polynomial of the cuspidal part of the form f, in other words integral from 0 to ioo of (X-tau)^(k-2)f(tau). If flag=0, ordinary period polynomial, if flag=1 or -1, even or odd part of that polynomial. f can also be the modular symbol output by mfsymbol(mf,f)."},
{"mfperiodpolbasis",0,(void*)mfperiodpolbasis,22,"LD0,L,","mfperiodpolbasis(k,{flag=0}): basis of period polynomials for weight k. If flag=1 or -1, basis of odd or even period polynomials."},
{"mfpetersson",0,(void*)mfpetersson,22,"GDG","mfpetersson(fs,{gs}): Petersson scalar product of the modular forms f and g belonging to the same modular form space mf, given by the corresponding \"modular symbols\" fs and gs output by mfsymbol (also in weight 1 and half-integral weight). If gs is omitted it is understood to be equal to fs. The scalar product is normalized by the factor 1/[G:G_0(N)]."},
{"mfpow",0,(void*)mfpow,22,"GL","mfpow(F,n): compute F^n"},
{"mfsearch",0,(void*)mfsearch,22,"GGD4,L,","mfsearch(NK,V,{space}): NK being of the form [N,k] with k possibly half-integral, search for a modular form with rational coefficients, of weight k and level N, whose initial coefficients a(0),... are equal to V; space specifies the modular form spaces in which to search. The output is a list of matching forms with that given level and weight. Note that the character is of the form (D/.), where D is a (positive or negative) fundamental discriminant dividing N.  N can be replaced by a vector of allowed levels, in which case the list of forms is sorted by increasing level, then increasing |D|. If a form is found at level N, any multiple of N with the same D is not considered  Note that this is very different from mfeigensearch, which only searches for rational eigenforms."},
{"mfshift",0,(void*)mfshift,22,"GL","mfshift(F,s): Divide the form F by q^s omitting the remainder if there is one; s can be negative."},
{"mfshimura",0,(void*)mfshimura,22,"GGD1,L,","mfshimura(mf,F,{D=1}): F being a modular form of half-integral weight k >= 3/2 and D either a positive squarefree integer or a fundamental discriminant of sign (-1)^{k-1/2}, computes the Shimura lift G of weight 2k-1 corresponding to D. This function returns [mf2,G,v], where mf2 is a modular form space containing G, and v the vector of coefficients of G on mf."},
{"mfslashexpansion",0,(void*)mfslashexpansion,22,"GGGLLD&p","mfslashexpansion(mf,f,g,n,flrat,{&params}): g being in M_2^+(Q), computes the Fourier expansion of f|_k g to n terms. f must belong to the space mf. If params is given, it is set to the parameters [alpha,w,A]. If flrat is 1, the program tries to rationalize the expression; if flag is 0, it does not."},
{"mfspace",0,(void*)mfspace,22,"lGDG","mfspace(mf,{f}): identify the modular space mf, resp. the modular form f in mf. Returns 0 (newspace), 1 (cuspidal space), 2 (old space), 3 (Eisenstein space) or 4 (full space). Return -1 when the form does not belong to the space."},
{"mfsplit",0,(void*)mfsplit,22,"GD0,L,D0,L,","mfsplit(mf,{dimlim=0},{flag=0}): mf containing the new space split the new space into Galois orbits of eigenforms of the newspace and return [vF,vK], where vF gives the (Galois orbit of) eigenforms in terms of mfbasis(mf) and vK is a list of polynomials defining each Galois orbit. If dimlim is set only the Galois orbits of dimension <= dimlim are computed (i.e. the rational eigenforms if dimlim = 1 and the character is real). Flag speeds up computations when the dimension is large: if flag = d > 0, when the dimension of the eigenspace is > d, only the Galois polynomial is computed."},
{"mfsturm",0,(void*)mfsturm,22,"lG","mfsturm(NK): Sturm bound for modular forms on G_0(N) and weight k, i.e., an upper bound for the order of the zero at infinity of a nonzero form. NK is either [N,k] or an mfinit (exact bound in the latter case)."},
{"mfsymbol",0,(void*)mfsymbol,22,"GDGb","mfsymbol(mf,f): Initialize data for working with all period polynomials of the modular form f: this is essential for efficiency for functions such as mfsymboleval, mfmanin, and mfpetersson. By abuse of language, initialize data for working with mfpetersson in weight 1 or half-integral weight (where no symbol exist)."},
{"mfsymboleval",0,(void*)mfsymboleval,22,"GGDGb","mfsymboleval(fs,path,{ga=id}): evaluation of the modular symbol fs output by mfsymbol on the given path, where path is either a vector [s1,s2] or an integral matrix [a,b;c,d] representing the path [a/c,b/d]. In both cases, s1 or s2 (or a/c or b/d) can also be elements of the upper half-plane. The result is the polynomial equal to the integral between s1 and s2 of (X-tau)^{k-2}F(tau). If ga in GL_2+(Q) is given, replace F by F|_k ga. If the integral diverges, the result will be a rational function."},
{"mftaylor",0,(void*)mftaylor,22,"GLD0,L,p","mftaylor(F,n,{flreal=0}): F being a modular form in M_k(SL_2(Z)), computes the first n+1 canonical Taylor expansion of F around tau=I. If flreal=0, computes only an algebraic equivalence class. If flreal is set, compute p_n such that for tau close enough to I we have f(tau)=(2I/(tau+I))^ksum_{n>=0}p_n((tau-I)/(tau+I))^n."},
{"mftobasis",0,(void*)mftobasis,22,"GGD0,L,","mftobasis(mf,F,{flag=0}): coefficients of the form F on the basis given by the mfbasis(mf). A q-expansion or vector of coefficients can also be given instead of F, but in this case an error message may occur if the expansion is too short. An error message is also given if F does not belong to the modular form space. If flag is set, instead of error messages return an output as an affine space of solutions if a q-expansion or vector of coefficients is given, or the empty column otherwise."},
{"mftocoset",0,(void*)mftocoset,22,"UGG","mftocoset(N,M,Lcosets): M being a matrix in SL_2(Z) and Lcosets being mfcosets(N), find the right coset of G_0(N) to which M belongs. The output is a pair [ga,i] such that M = ga * Lcosets[i], with ga in G_0(N)."},
{"mftonew",0,(void*)mftonew,22,"GG","mftonew(mf,F): mf being a full or cuspidal space with parameters [N,k,chi] and F a cusp form in that space, returns a vector of 3-component vectors [M,d,G], where f(chi) divides M divides N, d divides N/M, and G is a form in S_k^new(G_0(M),chi) such that F is equal to the sum of the B(d)(G) over all these 3-component vectors."},
{"mftraceform",0,(void*)mftraceform,22,"GD0,L,","mftraceform(NK,{space=0}): If NK=[N,k,CHI,.] as in mfinit with k integral, gives the trace form in the corresponding subspace of S_k(G_0(N),chi). The supported values for space are 0: the newspace (default), 1: the full cuspidal space."},
{"mftwist",0,(void*)mftwist,22,"GG","mftwist(F,D): returns the twist of the form F by the integer D, i.e., the form G such that mfcoef(G,n)=(D/n)mfcoef(F,n), where (D/n) is the Kronecker symbol."},
{"min",0,(void*)gmin,5,"GG","min(x,y): minimum of x and y."},
{"minpoly",0,(void*)minpoly,11,"GDn","minpoly(A,{v='x}): minimal polynomial of the matrix or polmod A."},
{"modreverse",0,(void*)modreverse,14,"G","modreverse(z): reverse polmod of the polmod z, if it exists."},
{"moebius",0,(void*)moebius,8,"lG","moebius(x): Moebius function of x."},
{"msatkinlehner",0,(void*)msatkinlehner,23,"GLDG","msatkinlehner(M,Q,{H}): M being a full modular symbol space of level N, as given by msinit, let Q | N, (Q,N/Q) = 1, and let H be a subspace stable under the Atkin-Lehner involution w_Q. Return the matrix of w_Q acting on H (M if omitted)."},
{"mscosets",0,(void*)mscosets0,23,"GG","mscosets(gen,inH): gen being a system of generators for a group G and H being a subgroup of finite index of G, return a list of right cosets of H \\ G and the right action of G on H \\ G. The subgroup H is given by a criterion inH (closure) deciding whether an element of G belongs to H."},
{"mscuspidal",0,(void*)mscuspidal,23,"GD0,L,","mscuspidal(M,{flag=0}): M being a full modular symbol space, as given by msinit, return its cuspidal part S. If flag = 1, return [S,E] its decomposition into Eisenstein and cuspidal parts."},
{"msdim",0,(void*)msdim,23,"lG","msdim(M): M being a modular symbol space or subspace, return its dimension as a Q-vector space."},
{"mseisenstein",0,(void*)mseisenstein,23,"G","mseisenstein(M): M being a full modular symbol space, as given by msinit, return its Eisenstein subspace."},
{"mseval",0,(void*)mseval,23,"GGDG","mseval(M,s,{p}): M being a full modular symbol space, as given by msinit, s being a modular symbol from M and p being a path between two elements in P^1(Q), return s(p)."},
{"msfarey",0,(void*)msfarey0,23,"GGD&","msfarey(F,inH,{&CM}): F being a Farey symbol attached to a group G contained in SL2(Z) and H a subgroup of G, return a Farey symbol attached to H; H is given by a criterion inH (closure) deciding whether an element of G belongs to H."},
{"msfromcusp",0,(void*)msfromcusp,23,"GG","msfromcusp(M,c): returns the modular symbol attached to the cusp c, where M is a modular symbol space of level N."},
{"msfromell",0,(void*)msfromell,23,"GD0,L,","msfromell(E,{sign=0}): return the [M, x], where M is msinit(N,2) and x is the modular symbol in M attached to the elliptic curve E/Q."},
{"msfromhecke",0,(void*)msfromhecke,23,"GGDG","msfromhecke(M,v,{H}): given a msinit M and a vector v of pairs [p, P] (where p is prime and P is a polynomial with integer coefficients), return a basis of all modular symbols such that P(Tp) * s = 0. If H is present, it must be a Hecke-stable subspace and we restrict to s in H."},
{"msgetlevel",0,(void*)msgetlevel,23,"lG","msgetlevel(M): M being a full modular symbol space, as given by msinit, return its level N."},
{"msgetsign",0,(void*)msgetsign,23,"lG","msgetsign(M): M being a full modular symbol space, as given by msinit, return its sign."},
{"msgetweight",0,(void*)msgetweight,23,"lG","msgetweight(M): M being a full modular symbol space, as given by msinit, return its weight k."},
{"mshecke",0,(void*)mshecke,23,"GLDG","mshecke(M,p,{H}): M being a full modular symbol space, as given by msinit, p being a prime number, and H being a Hecke-stable subspace (M if omitted), return the matrix of T_p acting on H (U_p if p divides the level)."},
{"msinit",0,(void*)msinit,23,"GGD0,L,","msinit(G,V,{sign=0}): given G a finite index subgroup of SL(2,Z) and a finite dimensional representation V of GL(2,Q), creates a space of modular symbols, the G-module Hom_G(Div^0(P^1 Q), V). This is canonically isomorphic to H^1_c(X(G), V), and allows to compute modular forms for G. If sign is present and nonzero, it must be +1 or -1 and we consider the subspace defined by Ker (Sigma - sign), where Sigma is induced by [-1,0;0,1]. Currently the only supported groups are the Gamma_0(N), coded by the integer N. The only supported representation is V_k = Q[X,Y]_{k-2}, coded by the integer k >= 2."},
{"msissymbol",0,(void*)msissymbol,23,"GG","msissymbol(M,s): M being a full modular symbol space, as given by msinit, check whether s is a modular symbol attached to M."},
{"mslattice",0,(void*)mslattice,23,"GDG","mslattice(M,{H}): M being a full modular symbol space, as given by msinit, H a Q-subspace or a matrix of modular symbols. Return the canonical integral structure of H."},
{"msnew",0,(void*)msnew,23,"G","msnew(M): M being a full modular symbol space, as given by msinit, return its new cuspidal subspace."},
{"msomseval",0,(void*)msomseval,23,"GGG","msomseval(Mp,PHI,path): return the vectors of moments of the p-adic distribution attached to the path 'path' via the overconvergent modular symbol 'PHI'."},
{"mspadicL",0,(void*)mspadicL,23,"GDGD0,L,","mspadicL(mu,{s=0},{r=0}): given mu from mspadicmoments (p-adic distributions attached to an overconvergent symbol PHI) returns the value on a character of Z_p^* represented by s of the derivative of order r of the p-adic L-function attached to PHI."},
{"mspadicinit",0,(void*)mspadicinit,23,"GLLD-1,L,","mspadicinit(M,p,n,{flag}): M being a full modular symbol space, as given by msinit and a prime p, initialize technical data needed to compute with overconvergent modular symbols (modulo p^n). If flag is unset, allow all symbols; if flag = 0, restrict to ordinary symbols; else initialize for symbols phi such that Tp(phi) = a_p * phi, with v_p(a_p) >= flag."},
{"mspadicmoments",0,(void*)mspadicmoments,23,"GGD1,L,","mspadicmoments(Mp,PHI,{D=1}): given Mp from mspadicinit, an overconvergent eigensymbol PHI, and optionally a fundamental discriminant D coprime to p, return the moments of the p-1 distributions PHI^D([0]-[oo]) | (a + pZp), 0 < a < p. To be used by mspadicL and mspadicseries."},
{"mspadicseries",0,(void*)mspadicseries,23,"GD0,L,","mspadicseries(mu,{i=0}): given mu from mspadicmoments, returns the attached p-adic series with maximal p-adic precision, depending on the precision of M (i-th Teichmueller component, if present)."},
{"mspathgens",0,(void*)mspathgens,23,"G","mspathgens(M): M being a full modular symbol space, as given by msinit, return a set of Z[G]-generators for Div^0(P^1 Q). The output is [g,R], where g is a minimal system of generators and R the vector of Z[G]-relations between the given generators."},
{"mspathlog",0,(void*)mspathlog,23,"GG","mspathlog(M,p): M being a full modular symbol space, as given by msinit and p being a path between two elements in P^1(Q), return (p_i) in Z[G] such that p = \\sum p_i g_i, and the g_i are fixed Z[G]-generators for Div^0(P^1 Q), see mspathgens."},
{"mspetersson",0,(void*)mspetersson,23,"GDGDG","mspetersson(M,{F},{G=F}): M being a full modular symbol space, as given by msinit, calculate the intersection product {F,G} of modular symbols F and G on M."},
{"mspolygon",0,(void*)mspolygon,23,"GD0,L,","mspolygon(M,{flag=0}): M describes a subgroup G of finite index in the modular group PSL2(Z), as given by msinit or a positive integer N (encoding the group G = Gamma0(N)), or by msfarey (arbitrary subgroups). Return an hyperbolic polygon (Farey symbol) attached to G. Binary digits of flag mean: 1=normalized polygon, 2=also add graphical representations."},
{"msqexpansion",0,(void*)msqexpansion,23,"GGDP","msqexpansion(M,projH,{B = seriesprecision}): M being a full modular symbol space, as given by msinit, and projH being a projector on a Hecke-simple subspace, return the Fourier coefficients [a_n, n <= B] of the corresponding normalized newform. If B omitted, use seriesprecision."},
{"mssplit",0,(void*)mssplit,23,"GDGD0,L,","mssplit(M,{H},{dimlim}): M being a full modular symbol space, as given by msinit, and H being a subspace (the new subspace if omitted), split H into Hecke-simple subspaces. If dimlim is present and positive, restrict to dim <= dimlim."},
{"msstar",0,(void*)msstar,23,"GDG","msstar(M,{H}): M being a full modular symbol space, as given by msinit, return the matrix of the * involution, induced by complex conjugation, acting on the (stable) subspace H (M if omitted)."},
{"mstooms",0,(void*)mstooms,23,"GG","mstooms(Mp,phi): given Mp from mspadicinit, lift the (classical) eigen symbol phi to a distribution-valued overconvergent symbol in the sense of Pollack and Stevens. The resulting overconvergent eigensymbol can then be used in mspadicmoments, then mspadicL or mspadicseries."},
{"my",0,NULL,2,NULL,"my(x,...,z): declare x,...,z as lexically-scoped local variables."},
{"newtonpoly",0,(void*)newtonpoly,14,"GG","newtonpoly(x,p): Newton polygon of polynomial x with respect to the prime p."},
{"next",0,(void*)next0,1,"D1,L,","next({n=1}): interrupt execution of current instruction sequence, and start another iteration from the n-th innermost enclosing loops."},
{"nextprime",0,(void*)nextprime0,8,"GDG","nextprime(x,{q}): smallest pseudoprime >= x. If q is an integer, return the smallest pseudoprime p >= x such that p = 1 mod q; if q is an intmod, return the smallest pseudoprime >= x in the given congruence class."},
{"nfalgtobasis",0,(void*)algtobasis,14,"GG","nfalgtobasis(nf,x): transforms the algebraic number x into a column vector on the integral basis nf.zk."},
{"nfbasis",0,(void*)nfbasis,14,"GD&","nfbasis(T,{&dK}): integral basis of the field Q[a], where a is a root of the polynomial T, using the round 4 algorithm. An argument [T,listP] is possible, where listP is a list of primes or a prime bound, to get an order which is maximal at certain primes only. If present, dK is set to the discriminant of the returned order."},
{"nfbasistoalg",0,(void*)basistoalg,14,"GG","nfbasistoalg(nf,x): transforms the column vector x on the integral basis into an algebraic number."},
{"nfcertify",0,(void*)nfcertify,14,"G","nfcertify(nf): returns a vector of composite integers used to certify nf.zk and nf.disc unconditionally (both are correct when the output is the empty vector)."},
{"nfcompositum",0,(void*)nfcompositum,14,"GGGD0,L,","nfcompositum(nf,P,Q,{flag=0}): vector of all possible compositums of the number fields defined by the polynomials P and Q; flag is optional, whose binary digits mean 1: output for each compositum, not only the compositum polynomial pol, but a vector [R,a,b,k] where a (resp. b) is a root of P (resp. Q) expressed as a polynomial modulo R, and a small integer k such that al2+k*al1 is the chosen root of R; 2: assume that the number fields defined by P and Q are linearly disjoint."},
{"nfdetint",0,(void*)nfdetint,16,"GG","nfdetint(nf,x): multiple of the ideal determinant of the pseudo generating set x."},
{"nfdisc",0,(void*)nfdisc,14,"G","nfdisc(T): discriminant of the number field defined by the polynomial T. An argument [T,listP] is possible, where listP is a list of primes or a prime bound."},
{"nfdiscfactors",0,(void*)nfdiscfactors,14,"G","nfdiscfactors(T): [D, faD], where D = nfdisc(T), and faD is the factorization of |D|."},
{"nfeltadd",0,(void*)nfadd,14,"GGG","nfeltadd(nf,x,y): element x+y in nf."},
{"nfeltdiv",0,(void*)nfdiv,14,"GGG","nfeltdiv(nf,x,y): element x/y in nf."},
{"nfeltdiveuc",0,(void*)nfdiveuc,14,"GGG","nfeltdiveuc(nf,x,y): gives algebraic integer q such that x-qy is small."},
{"nfeltdivmodpr",0,(void*)nfdivmodpr,14,"GGGG","nfeltdivmodpr(nf,x,y,pr): this function is obsolete, use nfmodpr."},
{"nfeltdivrem",0,(void*)nfdivrem,14,"GGG","nfeltdivrem(nf,x,y): gives [q,r] such that r=x-qy is small."},
{"nfeltembed",0,(void*)nfeltembed,14,"GGDGp","nfeltembed(nf,x,{pl}): complex embeddings of x at places given by vector pl."},
{"nfeltispower",0,(void*)nfispower,14,"lGGLD&","nfeltispower(nf,x,n,{&y}): returns 1 if x is an n-th power in nf (and set y to an n-th root if present), else returns 0."},
{"nfeltissquare",0,(void*)nfissquare,14,"lGGD&","nfeltissquare(nf,x,{&y}): returns 1 if x is a square in nf (and sets y to a square root if present), else returns 0."},
{"nfeltmod",0,(void*)nfmod,14,"GGG","nfeltmod(nf,x,y): gives r such that r=x-qy is small with q algebraic integer."},
{"nfeltmul",0,(void*)nfmul,14,"GGG","nfeltmul(nf,x,y): element x.y in nf."},
{"nfeltmulmodpr",0,(void*)nfmulmodpr,14,"GGGG","nfeltmulmodpr(nf,x,y,pr): this function is obsolete, use nfmodpr."},
{"nfeltnorm",0,(void*)nfnorm,14,"GG","nfeltnorm(nf,x): norm of x."},
{"nfeltpow",0,(void*)nfpow,14,"GGG","nfeltpow(nf,x,k): element x^k in nf."},
{"nfeltpowmodpr",0,(void*)nfpowmodpr,14,"GGGG","nfeltpowmodpr(nf,x,k,pr): this function is obsolete, use nfmodpr."},
{"nfeltreduce",0,(void*)nfreduce,14,"GGG","nfeltreduce(nf,a,id): gives r such that a-r is in the ideal id and r is small."},
{"nfeltreducemodpr",0,(void*)nfreducemodpr,14,"GGG","nfeltreducemodpr(nf,x,pr): this function is obsolete, use nfmodpr."},
{"nfeltsign",0,(void*)nfeltsign,14,"GGDG","nfeltsign(nf,x,{pl}): signs of real embeddings of x at places given by vector pl."},
{"nfelttrace",0,(void*)nftrace,14,"GG","nfelttrace(nf,x): trace of x."},
{"nfeltval",0,(void*)gpnfvalrem,14,"GGGD&","nfeltval(nf,x,pr,{&y}): valuation of element x at the prime pr as output by idealprimedec."},
{"nffactor",0,(void*)nffactor,14,"GG","nffactor(nf,T): factor polynomial T in number field nf."},
{"nffactorback",0,(void*)nffactorback,14,"GGDG","nffactorback(nf,f,{e}): given a factorization f, returns the factored object back as an nf element."},
{"nffactormod",0,(void*)nffactormod,14,"GGG","nffactormod(nf,Q,pr): this routine is obsolete, use nfmodpr and factormod. Factor polynomial Q modulo prime ideal pr in number field nf."},
{"nfgaloisapply",0,(void*)galoisapply,14,"GGG","nfgaloisapply(nf,aut,x): apply the Galois automorphism aut to the object x (element or ideal) in the number field nf."},
{"nfgaloisconj",0,(void*)galoisconj0,14,"GD0,L,DGp","nfgaloisconj(nf,{flag=0},{d}): list of conjugates of a root of the polynomial x=nf.pol in the same number field. flag is optional (set to 0 by default), meaning 0: use combination of flag 4 and 1, always complete; 1: use nfroots; 4: use Allombert's algorithm, complete if the field is Galois of degree <= 35 (see manual for details). nf can be simply a polynomial."},
{"nfgrunwaldwang",0,(void*)nfgrunwaldwang,15,"GGGGDn","nfgrunwaldwang(nf,Lpr,Ld,pl,{v='x}): a polynomial in the variable v defining a cyclic extension of nf (given in nf or bnf form) with local behavior prescribed by Lpr, Ld and pl: the extension has local degree a multiple of Ld[i] at the prime Lpr[i], and the extension is complex at the i-th real place of nf if pl[i]=-1 (no condition if pl[i]=0). The extension has degree the LCM of the local degrees."},
{"nfhilbert",0,(void*)nfhilbert0,14,"lGGGDG","nfhilbert(nf,a,b,{pr}): if pr is omitted, global Hilbert symbol (a,b) in nf, that is 1 if X^2-aY^2-bZ^2 has a nontrivial solution (X,Y,Z) in nf, -1 otherwise. Otherwise compute the local symbol modulo the prime ideal pr."},
{"nfhnf",0,(void*)nfhnf0,16,"GGD0,L,","nfhnf(nf,x,{flag=0}): if x=[A,I], gives a pseudo-basis [B,J] of the module sum A_jI_j. If flag is nonzero, return [[B,J], U], where U is the transformation matrix such that AU = [0|B]."},
{"nfhnfmod",0,(void*)nfhnfmod,16,"GGG","nfhnfmod(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."},
{"nfinit",0,(void*)nfinit0,14,"GD0,L,p","nfinit(pol,{flag=0}): pol being a nonconstant irreducible polynomial in Q[X], returns an nf structure attached to the number field Q[X] / (pol). Binary digits of flag mean 1: two-element vector [nf,Mod(a,P)], where Mod(a,P) is a polmod equal to Mod(x,pol) and P=nf.pol; 2: first use polredbest to find a simpler polynomial P; 4: do not LLL-reduce the maximal order basis nf.zk."},
{"nfisideal",0,(void*)isideal,14,"lGG","nfisideal(nf,x): true(1) if x is an ideal in the number field nf, false(0) if not."},
{"nfisincl",0,(void*)nfisincl0,14,"GGD0,L,","nfisincl(f,g,{flag=0}): let f and g define number fields, either irreducible rational polynomials or number fields as output by nfinit; tests whether the number field f is isomorphic to a subfield of g. Return 0 if not, and otherwise all the embeddings (flag=0, default), only one (flag=1), or all embeddings as rational functions (flag=2)."},
{"nfisisom",0,(void*)nfisisom,14,"GG","nfisisom(f,g): as nfisincl but tests whether f is isomorphic to g."},
{"nfislocalpower",0,(void*)nfislocalpower,14,"lGGGG","nfislocalpower(nf,pr,a,n): true(1) if a is an n-th power in the local field K_v, false(0) if not."},
{"nfkermodpr",0,(void*)nfkermodpr,14,"GGG","nfkermodpr(nf,x,pr): this function is obsolete, use nfmodpr."},
{"nflist",0,(void*)nflist,15,"GDGD-1,L,DG","nflist(G,{N},{s=-1},{F}): finds number fields (up to isomorphism) with Galois group of Galois closure isomorphic to G, and s complex places.  If s = -1 (default) all signatures, s = -2 is identical to s = -1 except fields are separated by increasing number of complex places. If field F is specified (by a polynomial), gives only number fields having F as a subfield (or a resolvent field in the case of S3, Dl, A4, S4, F5, M21 and M42).  The parameter N can be the following: a positive integer (absolute value of discriminant is N); a vector [a,b] (finds fields with absolute discriminant between a and b); a polynomial, in variable t say (regular extension of Q(t) with specified Galois group). If omitted (default), returns a few fields and F is ignored."},
{"nfmodpr",0,(void*)nfmodpr,14,"GGG","nfmodpr(nf,x,pr): maps x to the residue field mod pr."},
{"nfmodprinit",0,(void*)nfmodprinit0,14,"GGDn","nfmodprinit(nf,pr,{v=variable(nf.pol)}): transforms the prime ideal pr into modpr format necessary for all operations mod pr in the number field nf. Variable v is used to display finite field elements (see ffgen)."},
{"nfmodprlift",0,(void*)nfmodprlift,14,"GGG","nfmodprlift(nf,x,pr): lift x from residue field mod pr to nf."},
{"nfnewprec",0,(void*)nfnewprec,14,"Gp","nfnewprec(nf): transform the number field data nf into new data using the current (usually larger) precision."},
{"nfpolsturm",0,(void*)nfpolsturm,14,"GGDG","nfpolsturm(nf,T,{pl}): number of distinct real roots of the polynomial s(T) where s runs through the real embeddings given by vector pl."},
{"nfresolvent",0,(void*)nfresolvent,15,"GD0,L,","nfresolvent(pol,{flag=0}): In the case where the Galois closure of the number field defined by pol is S3, Dl, A4, S4, F5, A5, M21, or M42, gives the corresponding resolvent field. Otherwise, give a \"canonical\" subfield, or if flag >= 2 all \"canonical\" subfields. If flag is odd, give also the \"conductor\" f, whose definition is specific to each group."},
{"nfroots",0,(void*)nfroots,14,"DGG","nfroots({nf},x): roots of polynomial x belonging to nf (Q if omitted) without multiplicity."},
{"nfrootsof1",0,(void*)nfrootsof1,14,"G","nfrootsof1(nf): number of roots of unity and primitive root of unity in the number field nf."},
{"nfsnf",0,(void*)nfsnf0,16,"GGD0,L,","nfsnf(nf,x,{flag=0}): if x=[A,I,J], outputs D=[d_1,...d_n] Smith normal form of x. If flag is nonzero return [D,U,V], where UAV = Id."},
{"nfsolvemodpr",0,(void*)nfsolvemodpr,14,"GGGG","nfsolvemodpr(nf,a,b,P): this function is obsolete, use nfmodpr."},
{"nfsplitting",0,(void*)nfsplitting0,14,"GDGD0,L,","nfsplitting(P,{d},{fl}): defining polynomial S over Q for the splitting field of P, that is the smallest field over which P is totally split. P can also be given by a nf structure. If d is given, it must be a multiple of the splitting field degree. If fl=1, return [S,C] where C is an embedding of Q[x]/(P) in its splitting field."},
{"nfsubfields",0,(void*)nfsubfields0,14,"GD0,L,D0,L,","nfsubfields(pol,{d=0},{flag=0}): finds all subfields of degree d of number field defined by pol (all subfields if d is null or omitted). The result is a vector of subfields, each being given by [g,h] (default) or simply g (flag=1), where g is an absolute equation and h expresses one of the roots of g in terms of the root x of the polynomial defining nf."},
{"nfsubfieldscm",0,(void*)nfsubfieldscm,14,"GD0,L,","nfsubfieldscm(nf,{flag=0}): computes the maximal CM subfield of nf. Returns 0 if nf does not have a CM subfield, otherwise returns [g,h] (default) or g (flag=1) where g is an absolute equation and h expresses a root of g in terms of the generator of nf."},
{"nfsubfieldsmax",0,(void*)nfsubfieldsmax,14,"GD0,L,","nfsubfieldsmax(nf,{flag=0}): computes the list of maximal subfields of nf. The result is as in nfsubfields."},
{"nfweilheight",0,(void*)nfweilheight,14,"GGp","nfweilheight(nf, v): returns the absolute Weil height of the vector v seen as an element of the projective space over the number field nf given by nfinit."},
{"norm",0,(void*)gnorm,6,"G","norm(x): norm of x."},
{"norml2",0,(void*)gnorml2,11,"G","norml2(x): square of the L2-norm of x."},
{"normlp",0,(void*)gnormlp,11,"GDGp","normlp(x,{p=oo}): Lp-norm of x; sup norm if p is omitted."},
{"numbpart",0,(void*)numbpart,7,"G","numbpart(n): number of partitions of n."},
{"numdiv",0,(void*)numdiv,8,"G","numdiv(x): number of divisors of x."},
{"numerator",0,(void*)numerator,6,"GDG","numerator(f,{D}): numerator of f."},
{"numtoperm",0,(void*)numtoperm,7,"LG","numtoperm(n,k): permutation number k (mod n!) of n letters (n C-integer)."},
{"omega",0,(void*)omega,8,"lG","omega(x): number of distinct prime divisors of x."},
{"oo",0,(void*)mkoo,6,"","oo=oo(): infinity."},
{"padicappr",0,(void*)padicappr,10,"GG","padicappr(pol,a): p-adic roots of the polynomial pol congruent to a mod p."},
{"padicfields",0,(void*)padicfields0,10,"GGD0,L,","padicfields(p,N,{flag=0}): returns polynomials generating all the extensions of degree N of the field of p-adic rational numbers; N is allowed to be a 2-component vector [n,d], in which case, returns the extensions of degree n and discriminant p^d. flag is optional, and can be 0: default, 1: return also the ramification index, the residual degree, the valuation of the discriminant and the number of conjugate fields, or 2: return only the number of extensions in a fixed algebraic closure."},
{"padicprec",0,(void*)gppadicprec,6,"GG","padicprec(x,p): return the absolute p-adic precision of object x."},
{"parapply",0,(void*)parapply,3,"GG","parapply(f,x): parallel evaluation of f on the elements of x."},
{"pareval",0,(void*)pareval,3,"G","pareval(x): parallel evaluation of the elements of the vector of closures x."},
{"parfor",0,(void*)parfor0,3,"vV=GDGJDVDI","parfor(i=a,{b},expr1,{r},{expr2}): evaluates the expression expr1 in parallel for all i between a and b (if b is set to +oo, the loop will not stop), resulting in as many values; if r and expr2 are present, the expression expr2 in the formal variables r and i is evaluated with r running through all the different results obtained for expr1 and i takes the corresponding argument."},
{"parforeach",0,(void*)parforeach0,3,"vGVJDVDI","parforeach(V,x,expr1,{r},{expr2}): evaluates in parallel the expression expr1 for all components x of V. If the formal variables r and expr2 are present, evaluate sequentially expr2, in which x and r are replaced by the successive arguments and corresponding values."},
{"parforprime",0,(void*)parforprime0,3,"vV=GDGJDVDI","parforprime(p=a,{b},expr1,{r},{expr2}): evaluates the expression expr1 in parallel for all primes p between a and b (if b is set to +oo, the loop will not stop), resulting in as many values; if the formal variables r and expr2 are present, evaluate sequentially expr2, in which r has been replaced by the different results obtained for expr1 and p with the corresponding arguments."},
{"parforprimestep",0,(void*)parforprimestep0,3,"vV=GDGGJDVDI","parforprimestep(p=a,{b},q,expr1,{r},{expr2}): evaluates the expression expr1 in parallel for all primes p between a and b in an arithmetic progression of the form a + k*q, resulting in as many values; if the formal variables r and expr2 are present, evaluate sequentially expr2, in which r has been replaced by the different results obtained for expr1 and p with the corresponding arguments."},
{"parforstep",0,(void*)parforstep0,3,"vV=GDGGJDVDI","parforstep(i=a,{b},s,expr1,{r},{expr2}): evaluates the expression expr1 in parallel for i going from a to b in steps of s (can be a positive real number, an intmod for an arithmetic progression, or finally a vector of steps). If the formal variables r and expr2 are present, evaluates sequentially expr2, in which r has been replaced by the different results obtained for expr1 and i with the corresponding arguments."},
{"parforvec",0,(void*)parforvec0,3,"vV=GJDVDID0,L,","parforvec(X=v,expr1,{j},{expr2},{flag}): evaluates the sequence expr2 (dependent on X and j) for X as generated by forvec, in random order, computed in parallel. Substitute for j the value of expr1 (dependent on X)."},
{"parmatrix",0,(void*)parmatrix,3,"LLVVJ","parmatrix(m,n,i,j,expr): as matrix(m,n,i,j,expr) but the evaluations of expr are done in parallel."},
{"parploth",0,(void*)parploth,4,"V=GGJD0,M,D0,L,p\nParametric|1; Recursive|2; no_Rescale|4; no_X_axis|8; no_Y_axis|16; no_Frame|32; no_Lines|64; Points_too|128; Splines|256; no_X_ticks|512; no_Y_ticks|1024; Same_ticks|2048; Complex|4096","parploth(X=a,b,expr,{flags=0},{n=0}): parallel version of ploth. Plot of expression expr, X goes from a to b in high resolution. Both flags and n are optional. Binary digits of flags mean: 1=Parametric, 2=Recursive, 4=no_Rescale, 8=no_X_axis, 16=no_Y_axis, 32=no_Frame, 64=no_Lines (do not join points), 128=Points_too (plot both lines and points), 256=Splines (use cubic splines), 512=no_X_ticks, 1024= no_Y_ticks, 2048=Same_ticks (plot all ticks with the same length), 4096=Complex (the two coordinates of each point are encoded as a complex number). n specifies number of reference points on the graph (0=use default value). Returns a vector for the bounding box."},
{"parplothexport",0,(void*)parplothexport,4,"GV=GGJD0,M,D0,L,p\nParametric|1; Recursive|2; no_Rescale|4; no_X_axis|8; no_Y_axis|16; no_Frame|32; no_Lines|64; Points_too|128; Splines|256; no_X_ticks|512; no_Y_ticks|1024; Same_ticks|2048; Complex|4096","parplothexport(fmt,X=a,b,expr,{flags=0},{n=0}): parallel version of plothexport. Plot of expression expr, X goes from a to b in high resolution, returning the resulting picture as a character string which can then be written to a file."},
{"parselect",0,(void*)parselect,3,"GGD0,L,","parselect(f,A,{flag=0}): (parallel select) selects elements of A according to the selection function f which is tested in parallel. If flag is 1, return the indices of those elements (indirect selection)."},
{"parsum",0,(void*)parsum,3,"V=GGJ","parsum(i=a,b,expr): the sum (i goes from a to b) of expression expr, evaluated in parallel (in random order)."},
{"partitions",0,(void*)partitions,7,"LDGDG","partitions(k,{a=k},{n=k}): vector of partitions of the integer k. You can restrict the length of the partitions with parameter n (n=nmax or n=[nmin,nmax]), or the range of the parts with parameter a (a=amax or a=[amin,amax]). By default remove zeros, but one can set amin=0 to get X of fixed length nmax (=k by default)."},
{"parvector",0,(void*)parvector,3,"LVJ","parvector(N,i,expr): as vector(N,i,expr) but the evaluations of expr are done in parallel."},
{"permcycles",0,(void*)permcycles,7,"G","permcycles(x): cycles of the permutation x."},
{"permorder",0,(void*)permorder,7,"G","permorder(x): order of the permutation x."},
{"permsign",0,(void*)permsign,7,"lG","permsign(x): signature of the permutation x."},
{"permtonum",0,(void*)permtonum,7,"G","permtonum(x): ordinal (between 0 and n!-1) of permutation x."},
{"plot",0,(void*)pariplot0,4,"vV=GGEDGDGp","plot(X=a,b,expr,{Ymin},{Ymax}): crude plot of expression expr, X goes from a to b, with Y ranging from Ymin to Ymax. If Ymin (resp. Ymax) is not given, the minimum (resp. the maximum) of the expression is used instead."},
{"plotarc",0,(void*)plotarc,4,"vLGGD0,L,","plotarc(w,x2,y2,{filled=0}): if the cursor is at position (x1,y1), draws the ellipse that fits inside the box with diagonal (x1,y1) and (x2,y2) in rectwindow w (cursor does not move). If filled=1, fill the ellipse"},
{"plotbox",0,(void*)plotbox,4,"vLGGD0,L,","plotbox(w,x2,y2,{filled=0}): if the cursor is at position (x1,y1), draw a box with diagonal (x1,y1) and (x2,y2) in rectwindow w (cursor does not move). If filled=1, fill the box."},
{"plotclip",0,(void*)plotclip,4,"vL","plotclip(w): clip the contents of the rectwindow to the bounding box (except strings)."},
{"plotcolor",0,(void*)plotcolor,4,"LG","plotcolor(w,c): in rectwindow w, set default color to c. Possible values for c are [R,G,B] values, a color name or an index in the graphcolormap default: factory settings are 0=white, 1=black, 2=blue, 3=sienna, 4=red, 5=green, 6=grey, 7=gainsborough. Return [R,G,B] value attached to color."},
{"plotcopy",0,(void*)plotcopy,4,"vLLGGD0,L,","plotcopy(sourcew,destw,dx,dy,{flag=0}): copy the contents of rectwindow sourcew to rectwindow destw with offset (dx,dy). If flag's bit 1 is set, dx and dy express fractions of the size of the current output device, otherwise dx and dy are in pixels. dx and dy are relative positions of northwest corners if other bits of flag vanish, otherwise of: 2: southwest, 4: southeast, 6: northeast corners."},
{"plotcursor",0,(void*)plotcursor,4,"L","plotcursor(w): current position of cursor in rectwindow w."},
{"plotdraw",0,(void*)plotdraw,4,"vGD0,L,","plotdraw(w,{flag=0}): draw rectwindow w. More generally, w can be of the form [w1,x1,y1, w2,x2,y2,etc.]: draw rectwindows wi at given xi,yi positions. If flag!=0, the xi,yi express fractions of the size of the current output device."},
{"plotexport",0,(void*)plotexport,4,"GGD0,L,","plotexport(fmt,list,{flag=0}): draw vector of rectwindows list as in plotdraw, returning the resulting picture as a character string; fmt is either \"ps\" or \"svg\"."},
{"ploth",0,(void*)ploth0,4,"V=GGED0,M,D0,L,p\nParametric|1; Recursive|2; no_Rescale|4; no_X_axis|8; no_Y_axis|16; no_Frame|32; no_Lines|64; Points_too|128; Splines|256; no_X_ticks|512; no_Y_ticks|1024; Same_ticks|2048; Complex|4096; No_MinMax|8192;","ploth(X=a,b,expr,{flag=0},{n=0}): plot of expression expr, X goes from a to b in high resolution. Both flag and n are optional. Binary digits of flag mean: 1=Parametric, 2=Recursive, 4=no_Rescale, 8=no_X_axis, 16=no_Y_axis, 32=no_Frame, 64=no_Lines (do not join points), 128=Points_too (plot both lines and points), 256=Splines (use cubic splines), 512=no_X_ticks, 1024= no_Y_ticks, 2048=Same_ticks (plot all ticks with the same length), 4096=Complex (the two coordinates of each point are encoded as a complex number). n specifies number of reference points on the graph (0=use default value). Returns a vector for the bounding box."},
{"plothexport",0,(void*)plothexport0,4,"GV=GGED0,M,D0,L,p\nParametric|1; Recursive|2; no_Rescale|4; no_X_axis|8; no_Y_axis|16; no_Frame|32; no_Lines|64; Points_too|128; Splines|256; no_X_ticks|512; no_Y_ticks|1024; Same_ticks|2048; Complex|4096","plothexport(fmt,X=a,b,expr,{flags=0},{n=0}): plot of expression expr, X goes from a to b in high resolution, returning the resulting picture as a character string which can then be written to a file."},
{"plothraw",0,(void*)plothraw,4,"GGD0,L,","plothraw(X,Y,{flag=0}): plot in high resolution points whose x (resp. y) coordinates are in X (resp. Y). If flag is 1, join points, other nonzero flags should be combinations of bits 8,16,32,64,128,256 meaning the same as for ploth()."},
{"plothrawexport",0,(void*)plothrawexport,4,"GGGD0,L,","plothrawexport(fmt,X,Y,{flag=0}): plot in high resolution points whose x (resp. y) coordinates are in X (resp. Y), returning the resulting picture as a character string. If flag is 1, join points, other nonzero flags should be combinations of bits 8,16,32,64,128,256 meaning the same as for ploth()."},
{"plothsizes",0,(void*)plothsizes,4,"D0,L,","plothsizes({flag=0}): returns array of 8 elements: terminal width and height, sizes for ticks in horizontal and vertical directions, width and height of characters, width and height of display (if applicable). If flag=0, sizes of ticks and characters are in pixels, otherwise are fractions of the terminal size."},
{"plotinit",0,(void*)plotinit,4,"vLDGDGD0,L,","plotinit(w,{x},{y},{flag=0}): initialize rectwindow w to size x,y. If flag!=0, x and y express fractions of the size of the current output device. Omitting x or y means use the full size of the device."},
{"plotkill",0,(void*)plotkill,4,"vL","plotkill(w): erase the rectwindow w."},
{"plotlines",0,(void*)plotlines,4,"vLGGD0,L,","plotlines(w,X,Y,{flag=0}): draws an open polygon in rectwindow w where X and Y contain the x (resp. y) coordinates of the vertices. If X and Y are both single values (i.e not vectors), draw the corresponding line (and move cursor). If (optional) flag is nonzero, close the polygon."},
{"plotlinetype",0,(void*)plotlinetype,4,"vLL","plotlinetype(w,type): this function is obsolete; no graphing engine implement this functionality."},
{"plotmove",0,(void*)plotmove,4,"vLGG","plotmove(w,x,y): move cursor to position x,y in rectwindow w."},
{"plotpoints",0,(void*)plotpoints,4,"vLGG","plotpoints(w,X,Y): draws in rectwindow w the points whose x (resp y) coordinates are in X (resp Y). If X and Y are both single values (i.e not vectors), draw the corresponding point (and move cursor)."},
{"plotpointsize",0,(void*)plotpointsize,4,"vLG","plotpointsize(w,size): change the \"size\" of following points in rectwindow w. w=-1 changes global value."},
{"plotpointtype",0,(void*)plotpointtype,4,"vLL","plotpointtype(w,type): this function is obsolete; no graphing engine implement this functionality."},
{"plotrbox",0,(void*)plotrbox,4,"vLGGD0,L,","plotrbox(w,dx,dy,{filled}): if the cursor is at (x1,y1), draw a box with diagonal (x1,y1)-(x1+dx,y1+dy) in rectwindow w (cursor does not move). If filled=1, fill the box."},
{"plotrecth",0,(void*)plotrecth0,4,"LV=GGED0,M,D0,L,p\nParametric|1; Recursive|2; no_Rescale|4; no_X_axis|8; no_Y_axis|16; no_Frame|32; no_Lines|64; Points_too|128; Splines|256; no_X_ticks|512; no_Y_ticks|1024; Same_ticks|2048; Complex|4096","plotrecth(w,X=a,b,expr,{flag=0},{n=0}): writes to rectwindow w the curve output of ploth(w,X=a,b,expr,flag,n). Returns a vector for the bounding box."},
{"plotrecthraw",0,(void*)plotrecthraw,4,"LGD0,L,","plotrecthraw(w,data,{flags=0}): plot graph(s) for data in rectwindow w, where data is a vector of vectors. If plot is parametric, length of data should be even, and pairs of entries give curves to plot. If not, first entry gives x-coordinate, and the other ones y-coordinates. Admits the same optional flags as plotrecth, save that recursive plot is meaningless."},
{"plotrline",0,(void*)plotrline,4,"vLGG","plotrline(w,dx,dy): if the cursor is at (x1,y1), draw a line from (x1,y1) to (x1+dx,y1+dy) (and move the cursor) in the rectwindow w."},
{"plotrmove",0,(void*)plotrmove,4,"vLGG","plotrmove(w,dx,dy): move cursor to position (dx,dy) relative to the present position in the rectwindow w."},
{"plotrpoint",0,(void*)plotrpoint,4,"vLGG","plotrpoint(w,dx,dy): draw a point (and move cursor) at position dx,dy relative to present position of the cursor in rectwindow w."},
{"plotscale",0,(void*)plotscale,4,"vLGGGG","plotscale(w,x1,x2,y1,y2): scale the coordinates in rectwindow w so that x goes from x1 to x2 and y from y1 to y2 (y2<y1 is allowed)."},
{"plotstring",0,(void*)plotstring,4,"vLsD0,L,","plotstring(w,x,{flags=0}): draw in rectwindow w the string corresponding to x. Bits 1 and 2 of flag regulate horizontal alignment: left if 0, right if 2, center if 1. Bits 4 and 8 regulate vertical alignment: bottom if 0, top if 8, v-center if 4. Can insert additional gap between point and string: horizontal if bit 16 is set, vertical if bit 32 is set."},
{"polchebyshev",0,(void*)polchebyshev_eval,10,"LD1,L,DG","polchebyshev(n,{flag=1},{a='x}): Chebyshev polynomial of the first (flag = 1) or second (flag = 2) kind, of degree n, evaluated at a."},
{"polclass",0,(void*)polclass,10,"GD0,L,Dn","polclass(D,{inv=0},{x='x}): return a polynomial generating the Hilbert class field of Q(sqrt(D)) for the discriminant D<0."},
{"polcoef",0,(void*)polcoef,10,"GLDn","polcoef(x,n,{v}): coefficient of degree n of x. With respect to the main variable if v is omitted, with respect to the variable v otherwise."},
{"polcoeff",0,(void*)polcoef,10,"GLDn","polcoeff(x,n,{v}): deprecated alias for polcoef."},
{"polcompositum",0,(void*)polcompositum0,14,"GGD0,L,","polcompositum(P,Q,{flag=0}): vector of all possible compositums of the number fields defined by the polynomials P and Q; flag is optional, whose binary digits mean 1: output for each compositum, not only the compositum polynomial pol, but a vector [R,a,b,k] where a (resp. b) is a root of P (resp. Q) expressed as a polynomial modulo R, and a small integer k such that al2+k*al1 is the chosen root of R; 2: assume that the number fields defined by P and Q are linearly disjoint."},
{"polcyclo",0,(void*)polcyclo_eval,10,"LDG","polcyclo(n,{a = 'x}): n-th cyclotomic polynomial evaluated at a."},
{"polcyclofactors",0,(void*)polcyclofactors,10,"G","polcyclofactors(f): returns a vector of polynomials, whose product is the product of distinct cyclotomic polynomials dividing f."},
{"poldegree",0,(void*)gppoldegree,10,"GDn","poldegree(x,{v}): degree of the polynomial or rational function x with respect to main variable if v is omitted, with respect to v otherwise. For scalar x, return 0 if x is nonzero and -oo otherwise."},
{"poldisc",0,(void*)poldisc0,10,"GDn","poldisc(pol,{v}): discriminant of the polynomial pol, with respect to main variable if v is omitted, with respect to v otherwise."},
{"poldiscfactors",0,(void*)poldiscfactors,10,"GD0,L,","poldiscfactors(T,{flag=0}): [D, faD], where D = discriminant of the polynomial T, and faD is a cheap partial factorization of D (entries are coprime but need not be primes); if flag is 1, finish the factorization via factorint."},
{"poldiscreduced",0,(void*)reduceddiscsmith,10,"G","poldiscreduced(f): vector of elementary divisors of Z[a]/f'(a)Z[a], where a is a root of the polynomial f."},
{"polfromroots",0,(void*)polfromroots,10,"GDn","polfromroots(a,{v=x}): returns the monic polynomial in variable v whose roots are the components of the vector a with multiplicities."},
{"polgalois",0,(void*)polgalois,14,"Gp","polgalois(T): Galois group of the polynomial T (see manual for group coding). Return [n, s, k, name] where n is the group order, s the signature, k the index and name is the GAP4 name of the transitive group."},
{"polgraeffe",0,(void*)polgraeffe0,10,"GD2,L,","polgraeffe(f,{d=2}): returns the Graeffe transform g of f, such that g(x^2) = f(x)f(-x). If d > 0 is given, return g such that g(x^d) = prod(i=0, d-1, f(x*y^i)) mod y^d-1"},
{"polhensellift",0,(void*)polhensellift,10,"GGGL","polhensellift(A,B,p,e): lift the factorization B of A modulo p to a factorization modulo p^e using Hensel lift. The factors in B must be pairwise relatively prime modulo p."},
{"polhermite",0,(void*)polhermite_eval0,10,"LDGD0,L,","polhermite(n,{a='x},{flag=0}): Hermite polynomial H(n,v) of degree n, evaluated at a. If flag is nonzero, return [H_{n-1}(a), H_n(a)]."},
{"polinterpolate",0,(void*)polint,10,"GDGDGD&","polinterpolate(X,{Y},{t = 'x},{&e}): polynomial interpolation at t according to data vectors X, Y, i.e., given P of minimal degree such that P(X[i]) = Y[i] for all i, return P(t). If Y is omitted, take P such that P(i) = X[i]. If present and t is numeric, e will contain an error estimate on the returned value (Neville's algorithm)."},
{"polisclass",0,(void*)polisclass,10,"lG","polisclass(P): P being a monic irreducible polynomial with integer coefficients, return 0 if P is not a class polynomial for the j-invariant, otherwise return the discriminant D<0 such that P=polclass(D)."},
{"poliscyclo",0,(void*)poliscyclo,10,"lG","poliscyclo(f): returns 0 if f is not a cyclotomic polynomial, and n > 0 if f = Phi_n, the n-th cyclotomic polynomial."},
{"poliscycloprod",0,(void*)poliscycloprod,10,"lG","poliscycloprod(f): returns 1 if f is a product of cyclotomic polynonials, and 0 otherwise."},
{"polisirreducible",0,(void*)polisirreducible,10,"lG","polisirreducible(pol): true(1) if pol is an irreducible nonconstant polynomial, false(0) if pol is reducible or constant."},
{"pollaguerre",0,(void*)pollaguerre_eval0,10,"LDGDGD0,L,","pollaguerre(n,{a=0},{b='x},{flag=0}): Laguerre polynomial of degree n and parameter a evaluated at b. If flag is 1, return [L^{(a)_{n-1}(b), L^{(a)}_n(b)]."},
{"pollead",0,(void*)pollead,10,"GDn","pollead(x,{v}): leading coefficient of polynomial or series x, or x itself if x is a scalar. Error otherwise. With respect to the main variable of x if v is omitted, with respect to the variable v otherwise."},
{"pollegendre",0,(void*)pollegendre_eval0,10,"LDGD0,L,","pollegendre(n,{a='x},{flag=0}): legendre polynomial of degree n evaluated at a. If flag is 1, return [P_{n-1}(a), P_n(a)]."},
{"polmodular",0,(void*)polmodular,10,"LD0,L,DGDnD0,L,","polmodular(L,{inv=0},{x='x},{y='y},{derivs=0}): return the modular polynomial of level L and invariant inv."},
{"polrecip",0,(void*)polrecip,10,"G","polrecip(pol): reciprocal polynomial of pol."},
{"polred",0,(void*)polred0,14,"GD0,L,","polred(T,{flag=0}): deprecated, use polredbest. Reduction of the polynomial T (gives minimal polynomials only). The following binary digits of (optional) flag are significant 1: partial reduction, 2: gives also elements."},
{"polredabs",0,(void*)polredabs0,14,"GD0,L,","polredabs(T,{flag=0}): a smallest generating polynomial of the number field for the T2 norm on the roots, with smallest index for the minimal T2 norm. flag is optional, whose binary digit mean 1: give the element whose characteristic polynomial is the given polynomial. 4: give all polynomials of minimal T2 norm (give only one of P(x) and P(-x))."},
{"polredbest",0,(void*)polredbest,14,"GD0,L,","polredbest(T,{flag=0}): reduction of the polynomial T (gives minimal polynomials only). If flag=1, gives also elements."},
{"polredord",0,(void*)polredord,14,"G","polredord(x): this function is obsolete, use polredbest."},
{"polresultant",0,(void*)polresultant0,10,"GGDnD0,L,","polresultant(x,y,{v},{flag=0}): resultant of the polynomials x and y, with respect to the main variables of x and y if v is omitted, with respect to the variable v otherwise. flag is optional, and can be 0: default, uses either the subresultant algorithm, a modular algorithm or Sylvester's matrix, depending on the inputs; 1 uses Sylvester's matrix (should always be slower than the default); 2 uses subresultant algorithm."},
{"polresultantext",0,(void*)polresultantext0,10,"GGDn","polresultantext(A,B,{v}): return [U,V,R] such that R=polresultant(A,B,v) and U*A+V*B = R, where A and B are polynomials."},
{"polroots",0,(void*)roots,10,"Gp","polroots(T): complex roots of the polynomial T using Schonhage's method, as modified by Gourdon."},
{"polrootsbound",0,(void*)polrootsbound,10,"GDG","polrootsbound(T,{tau=0.01}): return a sharp upper bound for the modulus of the largest complex root of the polynomial T with relative error tau."},
{"polrootsff",0,(void*)polrootsff,10,"GDGDG","polrootsff(x,{p},{a}): obsolete, use polrootsmod."},
{"polrootsmod",0,(void*)polrootsmod,10,"GDG","polrootsmod(f,{D}): roots of the polynomial f over the finite field defined by the domain D."},
{"polrootspadic",0,(void*)polrootspadic,10,"GGL","polrootspadic(f,p,r): p-adic roots of the polynomial f to precision r."},
{"polrootsreal",0,(void*)realroots,10,"GDGp","polrootsreal(T,{ab}): real roots of the polynomial T with real coefficients, using Uspensky's method. In interval ab = [a,b] if present."},
{"polsturm",0,(void*)RgX_sturmpart,10,"lGDG","polsturm(T,{ab}): number of distinct real roots of the polynomial T (in the interval ab = [a,b] if present)."},
{"polsubcyclo",0,(void*)polsubcyclo,10,"LLDn","polsubcyclo(n,d,{v='x}): finds an equation (in variable v) for the d-th degree subfields of Q(zeta_n). Output is a polynomial, or a vector of polynomials if there are several such fields or none."},
{"polsubcyclofast",0,(void*)polsubcyclofast,10,"GLD0,L,D0,L,","polsubcyclofast(n,d,{s=0},{exact=0}): If 1 <= d <= 6 or a prime, finds an equation for the subfields of Q(zeta_n) with galois group C_d. Contrary to polsubcyclo, the output is always a (possibly empty) vector of polynomials. If s = 0 (default) all signatures, otherwise s = 1 (resp., -1) for totally real (resp., totally complex). Set exact = 1 for subfields of exact conductor n."},
{"polsylvestermatrix",0,(void*)sylvestermatrix,10,"GG","polsylvestermatrix(x,y): forms the sylvester matrix attached to the two polynomials x and y. Warning: the polynomial coefficients are in columns, not in rows."},
{"polsym",0,(void*)polsym,10,"GL","polsym(x,n): column vector of symmetric powers of the roots of x up to n."},
{"poltchebi",0,(void*)polchebyshev1,10,"LDn","poltchebi(n,{v='x}): deprecated alias for polchebyshev."},
{"polteichmuller",0,(void*)polteichmuller,10,"GUL","polteichmuller(T,p,r): return the polynomial whose roots (resp. leading coef) are the Teichmuller lift of the roots (resp. leading coef) of the irreducible polynomial T in Fp[X], to p-adic precision r."},
{"poltomonic",0,(void*)poltomonic,10,"GD&","poltomonic(T,{&L}): T in Q[x]; returns U monic in Z[x] such that U(x) = C T(x/L) for some rational C and L. If &L is given, set it to L."},
{"poltschirnhaus",0,(void*)tschirnhaus,14,"G","poltschirnhaus(x): random Tschirnhausen transformation of the polynomial x."},
{"polylog",0,(void*)polylog0,12,"LGD0,L,p","polylog(m,x,{flag=0}): m-th polylogarithm of x. flag is optional, and can be 0: default, 1: D_m~-modified m-th polylog of x, 2: D_m-modified m-th polylog of x, 3: P_m-modified m-th polylog of x."},
{"polylogmult",0,(void*)polylogmult_interpolate,12,"GDGDGp","polylogmult(s,{z},{t=0}): multiple polylogarithm value at integral s = [s1,...,sr] with argument z = [z1,...,zr]. If z is omitted, assume z = [1,...,1], i.e., multiple zeta value. More generally, return Yamamoto's interpolation at t (ordinary multiple polylog at t = 0 and star value at t = 1)."},
{"polzagier",0,(void*)polzag,10,"LL","polzagier(n,m): Zagier's polynomials of index n,m."},
{"powers",0,(void*)gpowers0,11,"GLDG","powers(x,n,{x0}): return the vector [1,x,...,x^n] if x0 is omitted, and [x0, x0*x, ..., x0*x^n] otherwise."},
{"precision",0,(void*)precision00,6,"GDG","precision(x,{n}): if n is present, return x at precision n. If n is omitted, return real precision of object x."},
{"precprime",0,(void*)precprime,8,"G","precprime(x): largest pseudoprime <= x, 0 if x<=1."},
{"prime",0,(void*)prime,8,"L","prime(n): returns the n-th prime (n C-integer)."},
{"primecert",0,(void*)primecert0,8,"GD0,L,D0,L,","primecert(N,{flag=0},{partial=0}): If N is a prime, return a Primality Certificate.  Return 0 otherwise. If flag = 0 return an ECPP certificate (Atkin-Morain); if flag = 1 return an N-1 certificate (Pocklington-Lehmer)"},
{"primecertexport",0,(void*)primecertexport,8,"GD0,L,","primecertexport(cert,{format=0}): Returns a string suitable for print/write to display a primality certificate."},
{"primecertisvalid",0,(void*)primecertisvalid,8,"lG","primecertisvalid(cert): Verifies if cert is a valid PARI ECPP Primality certificate."},
{"primeisregular",0,(void*)primeisregular,8,"lU","primeisregular(p): true(1) if p is regular, false(0) otherwise. p must be prime."},
{"primepi",0,(void*)primepi,8,"G","primepi(x): the prime counting function pi(x) = #{p <= x, p prime}."},
{"primes",0,(void*)primes0,8,"G","primes(n): returns the vector of the first n primes (integer), or the primes in interval n = [a,b]."},
{"print",0,(void*)print,2,"vs*","print({str}*): outputs its string arguments (in raw format) ending with a newline."},
{"print1",0,(void*)print1,2,"vs*","print1({str}*): outputs its string arguments (in raw format) without ending with newline."},
{"printf",0,(void*)printf0,2,"vss*","printf(fmt,{x}*): prints its arguments according to the format fmt."},
{"printp",0,(void*)printp,2,"vs*","printp({str}*): outputs its string arguments (in prettymatrix format) ending with a newline."},
{"printsep",0,(void*)printsep,2,"vss*","printsep(sep,{str}*): outputs its string arguments (in raw format), separated by 'sep', ending with a newline."},
{"printsep1",0,(void*)printsep1,2,"vss*","printsep1(sep,{str}*): outputs its string arguments (in raw format), separated by 'sep', without ending with a newline."},
{"printtex",0,(void*)printtex,2,"vs*","printtex({str}*): outputs its string arguments in TeX format."},
{"prod",0,(void*)produit,13,"V=GGEDG","prod(X=a,b,expr,{x=1}): x times the product (X runs from a to b) of expression."},
{"prodeuler",0,(void*)prodeuler0,13,"V=GGEp","prodeuler(p=a,b,expr): Euler product (p runs over the primes between a and b) of real or complex expression, as a floating point approximation."},
{"prodeulerrat",0,(void*)prodeulerrat,13,"GDGD2,L,p","prodeulerrat(F,{s=1},{a=2}): product from primes p = a to infinity of F(p^s), where F is a rational function."},
{"prodinf",0,(void*)prodinf0,13,"V=GED0,L,p","prodinf(X=a,expr,{flag=0}): infinite product (X goes from a to infinity) of real or complex expression. flag can be 0 (default) or 1, in which case compute the product of the 1+expr instead."},
{"prodnumrat",0,(void*)prodnumrat,13,"GLp","prodnumrat(F,a): product from n = a to infinity of F(n), where F-1 is a rational function of degree less than or equal to -2."},
{"psdraw",0,(void*)psdraw,4,"vGD0,L,","psdraw(list,{flag=0}): obsolete function."},
{"psi",0,(void*)gpsi_der,12,"GD0,L,p","psi(x,{der}): psi-function at x (der-th derivative of psi if der is set)"},
{"psploth",0,(void*)psploth0,4,"V=GGED0,M,D0,L,p\nParametric|1; Recursive|2; no_Rescale|4; no_X_axis|8; no_Y_axis|16; no_Frame|32; no_Lines|64; Points_too|128; Splines|256; no_X_ticks|512; no_Y_ticks|1024; Same_ticks|2048; Complex|4096","psploth(X=a,b,expr,{flags=0},{n=0}): obsolete function."},
{"psplothraw",0,(void*)psplothraw,4,"GGD0,L,","psplothraw(listx,listy,{flag=0}): obsolete function."},
{"qfauto",0,(void*)qfauto0,11,"GDG","qfauto(G,{fl}): automorphism group of the positive definite quadratic form G."},
{"qfautoexport",0,(void*)qfautoexport,11,"GD0,L,","qfautoexport(qfa,{flag}): qfa being an automorphism group as output by qfauto, output a string representing the underlying matrix group in GAP notation (default) or Magma notation (flag = 1)."},
{"qfbclassno",0,(void*)qfbclassno0,8,"GD0,L,","qfbclassno(D,{flag=0}): class number of discriminant D using Shanks's method by default. If (optional) flag is set to 1, use Euler products."},
{"qfbcomp",0,(void*)qfbcomp,8,"GG","qfbcomp(x,y): Gaussian composition with reduction of the binary quadratic forms x and y."},
{"qfbcompraw",0,(void*)qfbcompraw,8,"GG","qfbcompraw(x,y): Gaussian composition without reduction of the binary quadratic forms x and y."},
{"qfbcornacchia",0,(void*)qfbcornacchia,8,"GG","qfbcornacchia(d,n): Solves the equation x^2+dy^2 = n in integers x and y where d > 0 and n is prime or 4 times a prime."},
{"qfbhclassno",0,(void*)hclassno,8,"G","qfbhclassno(x): Hurwitz-Kronecker class number of x>0."},
{"qfbil",0,(void*)qfbil,11,"GGDG","qfbil(x,y,{q}): this function is obsolete, use qfeval."},
{"qfbnucomp",0,(void*)nucomp,8,"GGG","qfbnucomp(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."},
{"qfbnupow",0,(void*)nupow,8,"GGDG","qfbnupow(x,n,{L}): n-th power of primitive positive definite quadratic form x using nucomp and nudupl."},
{"qfbpow",0,(void*)qfbpow,8,"GG","qfbpow(x,n): n-th power with reduction of the binary quadratic form x."},
{"qfbpowraw",0,(void*)qfbpowraw,8,"GL","qfbpowraw(x,n): n-th power without reduction of the binary quadratic form x."},
{"qfbprimeform",0,(void*)primeform,8,"GG","qfbprimeform(x,p): returns the prime form of discriminant x, whose first coefficient is p."},
{"qfbred",0,(void*)qfbred0,8,"GD0,L,DGDG","qfbred(x,{flag=0},{isd},{sd}): reduction of the binary quadratic form x. All other args. are optional. The argument isd and sd, if present, supply the values of floor(sqrt(d)) and sqrt(d) respectively, where d is the discriminant. If d<0, its value is not used. flag can be any of 0: default; 1: do a single reduction step;"},
{"qfbredsl2",0,(void*)qfbredsl2,8,"GDG","qfbredsl2(x,{isD}): reduction of the binary quadratic form x, returns [y,g] where y is reduced and g in Sl(2,Z) is such that g.x = y; isD, if present, must be equal to sqrtint(D), where D > 0 is the discriminant of x."},
{"qfbsolve",0,(void*)qfbsolve,8,"GGD0,L,","qfbsolve(Q,n,{flag=0}): Solve the equation Q(x,y)=n in coprime integers x and y where Q is a binary quadratic form, up to the action of the special orthogonal group of Q over the integers. Binary digits of flag mean 1: return all solutions, 2: also include imprimitive solutions."},
{"qfcholesky",0,(void*)qfcholesky,11,"Gp","qfcholesky(M): given a square symmetric matrix M, returns R the upper triangular matrix such that R~*R = M, or [] if there is no solution (eventually due to insufficient precision)."},
{"qfcvp",0,(void*)qfcvp0,11,"GGDGDGD0,L,","qfcvp(x,t,{B},{m},{flag=0}): Let x be a square and symmetric matrix representing a positive definite quadratic form and t be a vector of the same dimension. This function deals with the vectors of whose squared distance to t is less than B, enumerated using the Fincke-Pohst algorithm, storing at most m vectors (no limit if m is omitted). The function searches for the closest vectors to t if B is omitted or <= 0. The precise behavior depends on flag. 0: returns at most m vectors (unless m omitted), returns [N,M,V] where N is the number of vectors enumerated, M the maximum squared distance among these, and V lists the vectors. 1: ignores m and returns the first vector whose squared distance to t is less than B."},
{"qfeval",0,(void*)qfeval0,11,"DGGDG","qfeval({q},x,{y}): evaluate the quadratic form q (symmetric matrix) at x; if y is present, evaluate the polar form at (x,y); if q omitted, use the standard Euclidean form."},
{"qfgaussred",0,(void*)qfgaussred0,11,"GD0,L,","qfgaussred(q,{flag=0}): square reduction of the symmetric matrix q. flag=0: returns a square matrix A such that q(x) = sum_i A[i,i] (x[i] + sum_{j != i} A[i,j] x[j])^2; flag=1 return [U,V] where U is a square matrix and V a vector such that q = U~ * matdiagonal(V) * U"},
{"qfisom",0,(void*)qfisom0,11,"GGDGDG","qfisom(G,H,{fl},{grp}): find an isomorphism between the integral positive definite quadratic forms G and H if it exists. G can also be given by a qfisominit structure which is preferable if several forms need to be compared to G."},
{"qfisominit",0,(void*)qfisominit0,11,"GDGDG","qfisominit(G,{fl},{m}): G being a square and symmetric matrix representing an integral positive definite quadratic form, this function returns a structure allowing to compute isomorphisms between G and other quadratic form faster."},
{"qfjacobi",0,(void*)jacobi,11,"Gp","qfjacobi(A): eigenvalues and orthogonal matrix of eigenvectors of the real symmetric matrix A."},
{"qflll",0,(void*)qflll0,11,"GD0,L,","qflll(x,{flag=0}): LLL reduction of the vectors forming the matrix x (gives the unimodular transformation matrix T such that x*T is LLL-reduced). flag is optional, and can be 0: default, 1: disable FLATTER, 2: assumes x is integral, returns a partially reduced basis, 3: assumes x is integral, in place (return x*T), 4: assumes x is integral, returns [K,T] where K is the integer kernel of x and T the LLL reduced image, 5: same as 4 but x may have polynomial coefficients, 8: same as 0 but x may have polynomial coefficients."},
{"qflllgram",0,(void*)qflllgram0,11,"GD0,L,","qflllgram(G,{flag=0}): LLL reduction of the lattice whose gram matrix is G (gives the unimodular transformation matrix). flag is optional and can be 0: default,1: disable FLATTER, 4: assumes x is integral, returns [K,T],  where K is the integer kernel of x and T the LLL reduced image, 5: same as 4 but x may have polynomial coefficients, 8: same as 0 but x may have polynomial coefficients."},
{"qfminim",0,(void*)qfminim0,11,"GDGDGD0,L,p","qfminim(x,{B},{m},{flag=0}): x being a square and symmetric matrix representing a positive definite quadratic form, this function deals with the vectors of x whose norm is less than or equal to B, enumerated using the Fincke-Pohst algorithm, storing at most m vectors (no limit if m is omitted). The function searches for the minimal nonzero vectors if B is omitted. The precise behavior depends on flag. 0: returns at most 2m vectors (unless m omitted), returns [N,M,V] where N is the number of vectors enumerated, M the maximum norm among these, and V lists half the vectors (the other half is given by -V). 1: ignores m and returns the first vector whose norm is less than B. 2: as 0 but uses a more robust, slower implementation"},
{"qfminimize",0,(void*)qfminimize,11,"G","qfminimize(G): given a square symmetric matrix G with rational  coefficients and non-zero determinant, of dimension n >= 1, return [H,U,c] such that H = c * U~*G*U for some rational c, and H integral with minimal determinant."},
{"qfnorm",0,(void*)qfnorm,11,"GDG","qfnorm(x,{q}): this function is obsolete, use qfeval."},
{"qforbits",0,(void*)qforbits,11,"GG","qforbits(G,V): return the orbits of V under the action of the group of linear transformation generated by the set G, which must stabilize V."},
{"qfparam",0,(void*)qfparam,11,"GGD0,L,","qfparam(G,sol,{flag=0}): coefficients of binary quadratic forms that parametrize the solutions of the ternary quadratic form G, using the particular solution sol."},
{"qfperfection",0,(void*)qfperfection,11,"G","qfperfection(G): rank of matrix of xx~ for x minimal vectors of a Gram matrix G."},
{"qfrep",0,(void*)qfrep0,11,"GGD0,L,","qfrep(q,B,{flag=0}): vector of (half) the number of vectors of norms from 1 to B for the integral and definite quadratic form q. If flag is 1, count vectors of even norm from 1 to 2B."},
{"qfsign",0,(void*)qfsign,11,"G","qfsign(x): signature of the symmetric matrix x."},
{"qfsolve",0,(void*)qfsolve,11,"G","qfsolve(G): solve over Q the quadratic equation X~ G X = 0, where G is a symmetric matrix."},
{"quadclassunit",0,(void*)quadclassunit0,8,"GD0,L,DGp","quadclassunit(D,{flag=0},{tech=[]}): compute the structure of the class group and the regulator of the quadratic field of discriminant D. See manual for the optional technical parameters."},
{"quaddisc",0,(void*)quaddisc,8,"G","quaddisc(x): discriminant of the quadratic field Q(sqrt(x))."},
{"quadgen",0,(void*)quadgen0,8,"GDn","quadgen(D,{v = 'w}): standard generator g of quadratic order of discriminant D. If v is given, the variable name is used to display g, else 'w' is used."},
{"quadhilbert",0,(void*)quadhilbert,8,"Gp","quadhilbert(D): relative equation for the Hilbert class field of the quadratic field of discriminant D (which can also be a bnf)."},
{"quadpoly",0,(void*)quadpoly0,8,"GDn","quadpoly(D,{v='x}): quadratic polynomial corresponding to the discriminant D, in variable v."},
{"quadray",0,(void*)quadray,8,"GGp","quadray(D,f): relative equation for the ray class field of conductor f for the quadratic field of discriminant D (which can also be a bnf)."},
{"quadregulator",0,(void*)quadregulator,8,"Gp","quadregulator(D): regulator of the real quadratic field of discriminant D."},
{"quadunit",0,(void*)quadunit0,8,"GDn","quadunit(D,{v = 'w}): fundamental unit u of the quadratic order of discriminant D where D must be positive. If v is given, the variable name is used to display u, else 'w' is used."},
{"quadunitindex",0,(void*)quadunitindex,8,"GG","quadunitindex(D,f): given a fundamental discriminant D, returns the index of the unit group of the order of conductor f."},
{"quadunitnorm",0,(void*)quadunitnorm,8,"lG","quadunitnorm(D): returns the norm of the fundamental unit of the quadratic order of discriminant D."},
{"ramanujantau",0,(void*)ramanujantau,8,"GD12,L,","ramanujantau(n,{ell=12}): compute the value of Ramanujan's tau function at n, assuming the GRH. If ell is 16, 18, 20, 22, or 26, same for the newform of level 1 and corresponding weight. Otherwise, compute the coefficient of the trace form at n. Algorithm in O(n^{1/2+eps})."},
{"random",0,(void*)genrand,6,"DG","random({N=2^31}): random object, depending on the type of N. Integer between 0 and N-1 (t_INT), int mod N (t_INTMOD), element in a finite field (t_FFELT), point on an elliptic curve (ellinit mod p or over a finite field)."},
{"randomprime",0,(void*)randomprime0,8,"DGDG","randomprime({N=2^31},{q}): returns a strong pseudo prime in [2, N-1]. If q is an integer, return a prime = 1 mod q; if q is an intmod, return a prime in the given congruence class."},
{"read",0,(void*)gp_read_file,2,"D\"\",s,","read({filename}): read from the input file filename. If filename is omitted, reread last input file, be it from read() or \\r."},
{"readstr",0,(void*)readstr,2,"D\"\",s,","readstr({filename}): returns the vector of GP strings containing the lines in filename."},
{"readvec",0,(void*)gp_readvec_file,2,"D\"\",s,","readvec({filename}): create a vector whose components are the evaluation of all the expressions found in the input file filename."},
{"real",0,(void*)greal,6,"G","real(x): real part of x."},
{"removeprimes",0,(void*)removeprimes,8,"DG","removeprimes({x=[]}): remove primes in the vector x from the prime table. x can also be a single integer. List the current extra primes if x is omitted."},
{"return",0,(void*)return0,1,"DG","return({x=0}): return from current subroutine with result x."},
{"rnfalgtobasis",0,(void*)rnfalgtobasis,16,"GG","rnfalgtobasis(rnf,x): relative version of nfalgtobasis, where rnf is a relative numberfield."},
{"rnfbasis",0,(void*)rnfbasis,16,"GG","rnfbasis(bnf,M): given a projective Z_K-module M as output by rnfpseudobasis or rnfsteinitz, gives either a basis of M if it is free, or an n+1-element generating set."},
{"rnfbasistoalg",0,(void*)rnfbasistoalg,16,"GG","rnfbasistoalg(rnf,x): relative version of nfbasistoalg, where rnf is a relative numberfield."},
{"rnfcharpoly",0,(void*)rnfcharpoly,16,"GGGDn","rnfcharpoly(nf,T,a,{var='x}): characteristic polynomial of a over nf, where a belongs to the algebra defined by T over nf. Returns a polynomial in variable var (x by default)."},
{"rnfconductor",0,(void*)rnfconductor0,16,"GGD0,L,","rnfconductor(bnf,T,{flag=0}): conductor of the Abelian extension of bnf defined by T. The result is [conductor,bnr,subgroup], where conductor is the conductor itself, bnr the attached bnr structure, and subgroup the HNF defining the norm group (Artin or Takagi group) on the given generators bnr.gen. If flag is 1, return a bnr modulo deg(T), attached to Cl_f / (deg(T)); if flag is 2 only return [f, idealfactor(f[1])]."},
{"rnfdedekind",0,(void*)rnfdedekind,16,"GGDGD0,L,","rnfdedekind(nf,pol,{pr},{flag=0}): relative Dedekind criterion over the number field K, represented by nf, applied to the order Z_K[X]/(P), modulo the prime ideal pr (at all primes if pr omitted, in which case flag is automatically set to 1). P is assumed to be monic, irreducible, in Z_K[X]. Returns [max,basis,v], where basis is a pseudo-basis of the enlarged order, max is 1 iff this order is pr-maximal, and v is the valuation at pr of the order discriminant. If flag is set, just return 1 if the order is maximal, and 0 if not."},
{"rnfdet",0,(void*)rnfdet,16,"GG","rnfdet(nf,M): given a pseudo-matrix M, compute its determinant."},
{"rnfdisc",0,(void*)rnfdiscf,16,"GG","rnfdisc(nf,T): given a polynomial T 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."},
{"rnfeltabstorel",0,(void*)rnfeltabstorel,16,"GG","rnfeltabstorel(rnf,x): transforms the element x from absolute to relative representation."},
{"rnfeltdown",0,(void*)rnfeltdown0,16,"GGD0,L,","rnfeltdown(rnf,x,{flag=0}): expresses x on the base field if possible; returns an error otherwise."},
{"rnfeltnorm",0,(void*)rnfeltnorm,16,"GG","rnfeltnorm(rnf,x): returns the relative norm N_{L/K}(x), as an element of K."},
{"rnfeltreltoabs",0,(void*)rnfeltreltoabs,16,"GG","rnfeltreltoabs(rnf,x): transforms the element x from relative to absolute representation."},
{"rnfelttrace",0,(void*)rnfelttrace,16,"GG","rnfelttrace(rnf,x): returns the relative trace Tr_{L/K}(x), as an element of K."},
{"rnfeltup",0,(void*)rnfeltup0,16,"GGD0,L,","rnfeltup(rnf,x,{flag=0}): expresses x (belonging to the base field) on the relative field. As a t_POLMOD if flag = 0 and as a t_COL on the absolute field integer basis if flag = 1."},
{"rnfequation",0,(void*)rnfequation0,16,"GGD0,L,","rnfequation(nf,pol,{flag=0}): given a pol with coefficients in nf, gives an absolute equation z of the number field defined by pol. flag is optional, and can be 0: default, or nonzero, gives [z,al,k], where z defines the absolute equation L/Q as in the default behavior, al expresses as an element of L a root of the polynomial defining the base field nf, and k is a small integer such that t = b + k al is a root of z, for b a root of pol."},
{"rnfhnfbasis",0,(void*)rnfhnfbasis,16,"GG","rnfhnfbasis(bnf,M): given a bnf attached to a number field K and a projective Z_K module M given by a pseudo-matrix, returns either a true HNF basis of M if one exists, or zero otherwise. If M is a polynomial with coefficients in K, replace it by the pseudo-matrix returned by rnfpseudobasis."},
{"rnfidealabstorel",0,(void*)rnfidealabstorel,16,"GG","rnfidealabstorel(rnf,x): transforms the ideal x from absolute to relative representation."},
{"rnfidealdown",0,(void*)rnfidealdown,16,"GG","rnfidealdown(rnf,x): finds the intersection of the ideal x with the base field."},
{"rnfidealfactor",0,(void*)rnfidealfactor,16,"GG","rnfidealfactor(rnf,x): factor the ideal x into prime ideals in the number field nfinit(rnf)."},
{"rnfidealhnf",0,(void*)rnfidealhnf,16,"GG","rnfidealhnf(rnf,x): relative version of idealhnf, where rnf is a relative numberfield."},
{"rnfidealmul",0,(void*)rnfidealmul,16,"GGG","rnfidealmul(rnf,x,y): relative version of idealmul, where rnf is a relative numberfield."},
{"rnfidealnormabs",0,(void*)rnfidealnormabs,16,"GG","rnfidealnormabs(rnf,x): absolute norm of the ideal x."},
{"rnfidealnormrel",0,(void*)rnfidealnormrel,16,"GG","rnfidealnormrel(rnf,x): relative norm of the ideal x."},
{"rnfidealprimedec",0,(void*)rnfidealprimedec,16,"GG","rnfidealprimedec(rnf,pr): return prime ideal decomposition of the maximal ideal pr of K in L/K; pr is also allowed to be a prime number p, in which case return a pair of vectors [SK,SL], where SK contains the primes of K above p and SL[i] is the vector of primes of L above SK[i]."},
{"rnfidealreltoabs",0,(void*)rnfidealreltoabs0,16,"GGD0,L,","rnfidealreltoabs(rnf,x,{flag=0}): transforms the ideal x from relative to absolute representation. As a vector of t_POLMODs if flag = 0 and as an ideal in HNF in the absolute field if flag = 1."},
{"rnfidealtwoelt",0,(void*)rnfidealtwoelement,16,"GG","rnfidealtwoelt(rnf,x): relative version of idealtwoelt, where rnf is a relative numberfield."},
{"rnfidealup",0,(void*)rnfidealup0,16,"GGD0,L,","rnfidealup(rnf,x,{flag=0}): lifts the ideal x (of the base field) to the relative field. As a vector of t_POLMODs if flag = 0 and as an ideal in HNF in the absolute field if flag = 1."},
{"rnfinit",0,(void*)rnfinit0,16,"GGD0,L,","rnfinit(nf,T,{flag=0}): T being an irreducible polynomial defined over the number field nf, initializes a vector of data necessary for working in relative number fields (rnf functions). See manual for technical details."},
{"rnfisabelian",0,(void*)rnfisabelian,16,"lGG","rnfisabelian(nf,T): T being a relative polynomial with coefficients in nf, return 1 if it defines an abelian extension, and 0 otherwise."},
{"rnfisfree",0,(void*)rnfisfree,16,"lGG","rnfisfree(bnf,M): given a bnf attached to a number field K and a projective Z_K module M given by a pseudo-matrix, return true (1) if M is free else return false (0)."},
{"rnfislocalcyclo",0,(void*)rnfislocalcyclo,16,"lG","rnfislocalcyclo(rnf): true(1) if the l-extension attached to rnf is locally cyclotomic (locally contained in the Z_l extension of K_v at all places v | l), false(0) if not."},
{"rnfisnorm",0,(void*)rnfisnorm,16,"GGD0,L,","rnfisnorm(T,a,{flag=0}): T is as output by rnfisnorminit applied to L/K. Tries to tell whether a is a norm from L/K. Returns a vector [x,q] where a=Norm(x)*q. Looks for a solution which is a S-integer, with S a list of places in K containing the ramified primes, generators of the class group of ext, as well as those primes dividing a. If L/K is Galois, you may omit flag, otherwise it is used to add more places to S: all the places above the primes p <= flag (resp. p | flag) if flag > 0 (resp. flag < 0). The answer is guaranteed (i.e a is a norm iff q=1) if L/K is Galois or, under GRH, if S contains all primes less than 4log(disc(M))^2, where M is the normal closure of L/K."},
{"rnfisnorminit",0,(void*)rnfisnorminit,16,"GGD2,L,","rnfisnorminit(pol,polrel,{flag=2}): let K be defined by a root of pol, L/K the extension defined by polrel. Computes technical data needed by rnfisnorm to solve norm equations Nx = a, for x in L, and a in K. If flag=0, does not care whether L/K is Galois or not; if flag = 1, assumes L/K is Galois; if flag = 2, determines whether L/K is Galois."},
{"rnfkummer",0,(void*)rnfkummer,16,"GDGp","rnfkummer(bnr,{subgp}): this function is deprecated. Use bnrclassfield."},
{"rnflllgram",0,(void*)rnflllgram,16,"GGGp","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."},
{"rnfnormgroup",0,(void*)rnfnormgroup,16,"GG","rnfnormgroup(bnr,pol): norm group (or Artin or Takagi group) corresponding to the Abelian extension of bnr.bnf defined by pol, where the module corresponding to bnr is assumed to be a multiple of the conductor. The result is the HNF defining the norm group on the generators in bnr.gen."},
{"rnfpolred",0,(void*)rnfpolred,16,"GGp","rnfpolred(nf,pol): given a pol with coefficients in nf, finds a list of relative polynomials defining some subfields, hopefully simpler."},
{"rnfpolredabs",0,(void*)rnfpolredabs,14,"GGD0,L,","rnfpolredabs(nf,pol,{flag=0}): given an irreducible pol with coefficients in nf, finds a canonical relative polynomial defining the same field. Binary digits of flag mean: 1: return also the element whose characteristic polynomial is the given polynomial, 2: return an absolute polynomial, 16: partial reduction."},
{"rnfpolredbest",0,(void*)rnfpolredbest,14,"GGD0,L,","rnfpolredbest(nf,pol,{flag=0}): given a pol with coefficients in nf, finds a relative polynomial P defining the same field, hopefully simpler than pol; flag can be 0: default, 1: return [P,a], where a is a root of pol 2: return an absolute polynomial Pabs, 3: return [Pabs, a,b], where a is a root of nf.pol and b is a root of pol."},
{"rnfpseudobasis",0,(void*)rnfpseudobasis,14,"GG","rnfpseudobasis(nf,T): given an irreducible polynomial T with coefficients in nf, returns [A,J,D,d] where [A,J] is a pseudo basis of the maximal order of the extension, D is the relative ideal discriminant, and d is the relative discriminant in nf^*/nf*^2."},
{"rnfsteinitz",0,(void*)rnfsteinitz,14,"GG","rnfsteinitz(nf,M): given a nf attached to a number field K and a projective module M given by a pseudo-matrix, returns [A,I,D,d] where (A,I) is a pseudo basis for M where all the ideals except perhaps the last are trivial. If M is a polynomial with coefficients in K, replace it by the pseudo-matrix returned by rnfpseudobasis."},
{"rootsof1",0,(void*)grootsof1,12,"Lp","rootsof1(N): column vector of complex N-th roots of 1."},
{"round",0,(void*)round0,6,"GD&","round(x,{&e}): take the nearest integer to all the coefficients of x. If e is present, do not take into account loss of integer part precision, and set e = error estimate in bits."},
{"select",0,(void*)select0,2,"GGD0,L,","select(f,A,{flag=0}): selects elements of A according to the selection function f. If flag is 1, return the indices of those elements (indirect selection)."},
{"self",0,(void*)pari_self,2,"m","self(): return the calling function or closure. Useful for defining anonymous recursive functions."},
{"seralgdep",0,(void*)seralgdep,10,"GLL","seralgdep(s,p,r): find a linear relation between powers (1,s, ..., s^p) of the series s, with polynomial coefficients of degree <= r."},
{"serchop",0,(void*)serchop,6,"GD0,L,","serchop(s,{n=0}): remove all terms of degree strictly less than n in series s."},
{"serconvol",0,(void*)convol,10,"GG","serconvol(x,y): convolution (or Hadamard product) of two power series."},
{"serdiffdep",0,(void*)serdiffdep,10,"GLL","serdiffdep(s,p,r): find an inhomogenous linear differential equation satisfied by the series s, with polynomial coefficients of degree <= r. The result is a pair [E,P] such that E(d)(S)=P where E(d) is interpreted as a differential polynomial, or 0 in case no relation is found."},
{"serlaplace",0,(void*)laplace,10,"G","serlaplace(x): replaces the power series sum of a_n*x^n/n! by sum of a_n*x^n. For the reverse operation, use serconvol(x,exp(X))."},
{"serprec",0,(void*)gpserprec,6,"Gn","serprec(x,v): return the absolute precision x with respect to power series in the variable v."},
{"serreverse",0,(void*)serreverse,10,"G","serreverse(s): reversion of the power series s."},
{"setbinop",0,(void*)setbinop,11,"GGDG","setbinop(f,X,{Y}): the set {f(x,y), x in X, y in Y}. If Y is omitted, assume that X = Y and that f is symmetric."},
{"setdebug",0,(void*)setdebug,1,"DsD-1,L,","setdebug({D},{n}): sets debug level for domain D to n (n must be between 0 and 20). If n is omitted, returns the current level for domain D. if D is omitted, returns a two-column matrix which lists the available domains with their levels."},
{"setdelta",0,(void*)setdelta,11,"GG","setdelta(x,y): symmetric difference of the sets x and y."},
{"setintersect",0,(void*)setintersect,11,"GG","setintersect(x,y): intersection of the sets x and y."},
{"setisset",0,(void*)setisset,11,"lG","setisset(x): true(1) if x is a set (row vector with strictly increasing entries), false(0) if not."},
{"setminus",0,(void*)setminus,11,"GG","setminus(x,y): set of elements of x not belonging to y."},
{"setrand",0,(void*)setrand,2,"vG","setrand(n): reset the seed of the random number generator to n."},
{"setsearch",0,(void*)setsearch,11,"lGGD0,L,","setsearch(S,x,{flag=0}): determines whether x belongs to the set (or sorted list) S. If flag is 0 or omitted, returns 0 if it does not, otherwise returns the index j such that x==S[j]. If flag is nonzero, return 0 if x belongs to S, otherwise the index j where it should be inserted."},
{"setunion",0,(void*)setunion,11,"GG","setunion(x,y): union of the sets x and y."},
{"shift",0,(void*)gshift,5,"GL","shift(x,n): shift x left n bits if n>=0, right -n bits if n<0."},
{"shiftmul",0,(void*)gmul2n,5,"GL","shiftmul(x,n): multiply x by 2^n (n>=0 or n<0)."},
{"sigma",0,(void*)sumdivk,8,"GD1,L,","sigma(x,{k=1}): sum of the k-th powers of the divisors of x. k is optional and if omitted is assumed to be equal to 1."},
{"sign",0,(void*)gsigne,5,"iG","sign(x): sign of x, of type integer, real or fraction."},
{"simplify",0,(void*)simplify,6,"G","simplify(x): simplify the object x as much as possible."},
{"sin",0,(void*)gsin,12,"Gp","sin(x): sine of x."},
{"sinc",0,(void*)gsinc,12,"Gp","sinc(x): sinc function of x."},
{"sinh",0,(void*)gsinh,12,"Gp","sinh(x): hyperbolic sine of x."},
{"sizebyte",0,(void*)gsizebyte,6,"lG","sizebyte(x): number of bytes occupied by the complete tree of the object x."},
{"sizedigit",0,(void*)sizedigit,6,"lG","sizedigit(x): rough upper bound for the number of decimal digits of (the components of) x. DEPRECATED."},
{"snfrank",0,(void*)snfrank,11,"lGDG","snfrank(D,{q=0}): assuming that D is a Smith normal form (i.e. vector of elementary divisors) for some module and q a power of an irreducible element or 0 (default if omitted), returns the rank of D/qD."},
{"solve",0,(void*)zbrent0,13,"V=GGEp","solve(X=a,b,expr): real root of expression expr (X between a and b), where either a or b is infinite or expr(a)*expr(b)<=0."},
{"solvestep",0,(void*)solvestep0,13,"V=GGGED0,L,p","solvestep(X=a,b,step,expr,{flag=0}): find zeros of a function in the real interval [a,b] by naive interval splitting."},
{"sqr",0,(void*)gsqr,12,"G","sqr(x): square of x. NOT identical to x*x."},
{"sqrt",0,(void*)gsqrt,12,"Gp","sqrt(x): square root of x."},
{"sqrtint",0,(void*)sqrtint0,8,"GD&","sqrtint(x,{&r}): integer square root y of x, where x is a nonnegative real number. If r is present, set it to the remainder x - y^2."},
{"sqrtn",0,(void*)gsqrtn,12,"GGD&p","sqrtn(x,n,{&z}): nth-root of x, n must be integer. If present, z is set to a suitable root of unity to recover all solutions. If it was not possible, z is set to zero."},
{"sqrtnint",0,(void*)sqrtnint,8,"GL","sqrtnint(x,n): integer n-th root of x, where x is nonnegative real number."},
{"stirling",0,(void*)stirling,7,"LLD1,L,","stirling(n,k,{flag=1}): if flag=1 (default) return the Stirling number of the first kind s(n,k), if flag=2, return the Stirling number of the second kind S(n,k)."},
{"strchr",0,(void*)pari_strchr,2,"G","strchr(x): converts integer or vector of integers x to a string, translating each integer into a character using ASCII encoding."},
{"strexpand",0,(void*)strexpand,2,"s*","strexpand({x}*): concatenates its (string) arguments into a single string, performing tilde expansion."},
{"strjoin",0,(void*)strjoin,2,"GDG","strjoin(v,{p = \"\"}): joins the strings in vector v, separating them with delimiter p."},
{"strprintf",0,(void*)strprintf,2,"ss*","strprintf(fmt,{x}*): returns a string built from the remaining arguments according to the format fmt."},
{"strsplit",0,(void*)strsplit,2,"GDG","strsplit(s,{p = \"\"}): splits the string s into a vector of strings, with p acting as a delimiter between successive fields; if p is empty or omitted, split into characters."},
{"strtex",0,(void*)strtex,2,"s*","strtex({x}*): translates its (string) arguments to TeX format and returns the resulting string."},
{"strtime",0,(void*)strtime,2,"L","strtime(t): return a string describing the time t in milliseconds, in the format used by the GP timer."},
{"subcyclohminus",0,(void*)subcyclohminus,15,"GDG","subcyclohminus(fH,{p=0}): Let F be the abelian number field contained in Q(zeta_f) corresponding to the subgroup H of (Z/fZ)^*. Let h be the relative class number h^-(F) and Q the Hasse unit index in {1,2}. If Q could be computed, returns [h, Q]; else returns [2h/Q, 0]."},
{"subcycloiwasawa",0,(void*)subcycloiwasawa,15,"GGD0,L,","subcycloiwasawa(fH,p,{n=0}): Let F be the abelian number field contained in Q(zeta_f) corresponding to the subgroup H of (Z/fZ)^*. Returns the minus part of Iwasawa polynomials attached to the cyclotomic Z_p extension of F."},
{"subcyclopclgp",0,(void*)subcyclopclgp,15,"GGD0,L,","subcyclopclgp(fH,p,{flag=0}): Let F be the abelian number field contained in Q(zeta_f) corresponding to the subgroup H of (Z/fZ)^* and let p be a prime not dividing 2[F:Q]. Computes the p-Sylow subgroup of the ideal class group of F."},
{"subgrouplist",0,(void*)subgrouplist0,14,"GDGD0,L,","subgrouplist(cyc,{bound},{flag=0}): cyc being any object which has a '.cyc' method giving the cyclic components for a finite Abelian group G, outputs the list of subgroups of G (of index bounded by bound, if not omitted), given as HNF left divisors of the SNF matrix corresponding to G. If flag=0 (default) and 'cyc' is a bnr struture output by bnrinit, gives only the subgroups whose conductor is the modulus bnr.mod"},
{"subst",0,(void*)gsubst,10,"GnG","subst(x,y,z): in expression x, replace the variable y by the expression z."},
{"substpol",0,(void*)gsubstpol,10,"GGG","substpol(x,y,z): in expression x, replace the polynomial y by the expression z, using remainder decomposition of x."},
{"substvec",0,(void*)gsubstvec,10,"GGG","substvec(x,v,w): in expression x, make a best effort to replace the variables v1,...,vn by the expression w1,...,wn."},
{"sum",0,(void*)somme,13,"V=GGEDG","sum(X=a,b,expr,{x=0}): x plus the sum (X goes from a to b) of expression expr."},
{"sumalt",0,(void*)sumalt0,13,"V=GED0,L,p","sumalt(X=a,expr,{flag=0}): Cohen-Villegas-Zagier's acceleration of alternating series expr, X starting at a. flag is optional, and can be 0: default, or 1: uses a slightly different method using Zagier's polynomials."},
{"sumdedekind",0,(void*)sumdedekind,8,"GG","sumdedekind(h,k): Dedekind sum attached to h,k."},
{"sumdigits",0,(void*)sumdigits0,8,"GDG","sumdigits(n,{B=10}): sum of digits in the integer n, when written in base B."},
{"sumdiv",0,(void*)sumdivexpr,13,"GVE","sumdiv(n,X,expr): sum of expression expr, X running over the divisors of n."},
{"sumdivmult",0,(void*)sumdivmultexpr0,13,"GVE","sumdivmult(n,d,expr): sum of multiplicative function expr, d running over the divisors of n."},
{"sumeulerrat",0,(void*)sumeulerrat,13,"GDGD2,L,p","sumeulerrat(F,{s=1},{a=2}): sum from primes p = a to infinity of F(p^s), where F is a rational function."},
{"sumformal",0,(void*)sumformal,10,"GDn","sumformal(f,{v}): formal sum of f with respect to v, or to the main variable of f if v is omitted."},
{"suminf",0,(void*)suminf0,13,"V=GEb","suminf(X=a,expr): naive summation (X goes from a to infinity) of real or complex expression expr."},
{"sumnum",0,(void*)sumnum0,13,"V=GEDGp","sumnum(n=a,f,{tab}): numerical summation of f(n) from n = a to +infinity using Euler-MacLaurin summation. Assume that f corresponds to a series with positive terms and is a C^oo function; a must be an integer, and tab, if given, is the output of sumnuminit."},
{"sumnumap",0,(void*)sumnumap0,13,"V=GEDGp","sumnumap(n=a,f,{tab}): numerical summation of f(n) from n = a to +infinity using Abel-Plana formula. Assume that f is holomorphic in the right half-plane Re(z) > a; a must be an integer, and tab, if given, is the output of sumnumapinit."},
{"sumnumapinit",0,(void*)sumnumapinit,13,"DGp","sumnumapinit({asymp}): initialize tables for Abel-Plana summation of a series."},
{"sumnuminit",0,(void*)sumnuminit,13,"DGp","sumnuminit({asymp}): initialize tables for Euler-MacLaurin delta summation of a series with positive terms."},
{"sumnumlagrange",0,(void*)sumnumlagrange0,13,"V=GEDGp","sumnumlagrange(n=a,f,{tab}): numerical summation of f(n) from n = a to +infinity using Lagrange summation. a must be an integer, and tab, if given, is the output of sumnumlagrangeinit."},
{"sumnumlagrangeinit",0,(void*)sumnumlagrangeinit,13,"DGDGp","sumnumlagrangeinit({asymp},{c1}): initialize tables for Lagrange summation of a series."},
{"sumnummonien",0,(void*)sumnummonien0,13,"V=GEDGp","sumnummonien(n=a,f,{tab}): numerical summation from n = a to +infinity using Monien summation."},
{"sumnummonieninit",0,(void*)sumnummonieninit,13,"DGDGDGp","sumnummonieninit({asymp},{w},{n0 = 1}): initialize tables for Monien summation of a series with positive terms."},
{"sumnumrat",0,(void*)sumnumrat,13,"GGp","sumnumrat(F,a): sum from n = a to infinity of F(n), where F is a rational function of degree less than or equal to -2."},
{"sumnumsidi",0,(void*)sumnumsidi0,13,"V=GED1,L,p","sumnumsidi(n=a,f,{safe=1}): numerical summation of f(n) from n = a to +infinity using Sidi summation; a must be an integer. If safe is set to 0, the function is faster but much less robust."},
{"sumpos",0,(void*)sumpos0,13,"V=GED0,L,p","sumpos(X=a,expr,{flag=0}): sum of positive (or negative) series expr, the formal variable X starting at a. flag is optional, and can be 0: default, or 1: uses a slightly different method using Zagier's polynomials."},
{"system",0,(void*)gpsystem,2,"ls","system(str): str being a string, execute the system command str."},
{"tan",0,(void*)gtan,12,"Gp","tan(x): tangent of x."},
{"tanh",0,(void*)gtanh,12,"Gp","tanh(x): hyperbolic tangent of x."},
{"taylor",0,(void*)tayl,10,"GnDP","taylor(x,t,{d=seriesprecision}): taylor expansion of x with respect to t, adding O(t^d) to all components of x."},
{"teichmuller",0,(void*)teichmuller,12,"GDG","teichmuller(x,{tab}): Teichmuller character of p-adic number x. If x = [p,n], return the lifts of all teichmuller(i + O(p^n)) for i = 1, ..., p-1. Such a vector can be fed back to teichmuller, as the optional argument tab, to speed up later computations."},
{"theta",0,(void*)theta,12,"GGDGp","theta(a,b,{flag}): Jacobi theta-functions. If flag is omitted, let (q,z) = (a,b) and return theta(q,z), the Jacobi sine theta function. Otherwise, let (z, tau) = (a,b) and return one variable Riemann-Jacobi theta functions depending on flag: theta_{0,0} = theta_3, theta_{0,1} = theta_4, theta_{1,0} = theta_2, or theta_{1,1} = -theta_1. If flag=0, return all four theta_{i,j} for 0<=i,j<=1."},
{"thetanull",0,(void*)thetanull,12,"GDGp","thetanull(tau,{flag=0}): Jacobi Thetanullwerte: if flag is not 1 or [1,1], same as theta(0, tau, flag). Otherwise, (d/dz)theta(z,tau,flag) at z=0. If flag = 0 or omitted, vector of all four."},
{"thetanullk",0,(void*)thetanullk,12,"GLp","thetanullk(q,k): k-th derivative at z=0 of theta(q,z)."},
{"thue",0,(void*)thue,10,"GGDG","thue(tnf,a,{sol}): solve the equation P(x,y)=a, where tnf was created with thueinit(P), and sol, if present, contains the solutions of Norm(x)=a modulo units in the number field defined by P. If tnf was computed without assuming GRH (flag 1 in thueinit), the result is unconditional. If tnf is a polynomial, compute thue(thueinit(P,0), a)."},
{"thueinit",0,(void*)thueinit,10,"GD0,L,p","thueinit(P,{flag=0}): initialize the tnf corresponding to P, that will be used to solve Thue equations P(x,y) = some-integer. If flag is nonzero, certify the result unconditionally. Otherwise, assume GRH (much faster of course)."},
{"trace",0,(void*)gtrace,11,"G","trace(x): trace of x."},
{"truncate",0,(void*)trunc0,6,"GD&","truncate(x,{&e}): truncation of x; when x is a power series,take away the O(X^). If e is present, do not take into account loss of integer part precision, and set e = error estimate in bits."},
{"type",0,(void*)type0,2,"G","type(x): return the type of the GEN x."},
{"unexport",0,NULL,2,NULL,"unexport(x,...,z): remove x,...,z from the list of variables exported to the parallel world."},
{"unexportall",0,(void*)unexportall,2,"v","unexportall(): empty the list of variables exported to the parallel world."},
{"uninline",0,NULL,2,NULL,"uninline(): forget all inline variables. DEPRECATED, use export."},
{"until",0,(void*)untilpari,1,"vEI","until(a,seq): evaluate the expression sequence seq until a is nonzero."},
{"valuation",0,(void*)gpvaluation,6,"GDG","valuation(x,{p}): valuation of x with respect to p."},
{"varhigher",0,(void*)varhigher,6,"sDn","varhigher(name,{v}): return a variable 'name' whose priority is higher than the priority of v (of all existing variables if v is omitted)."},
{"variable",0,(void*)gpolvar,6,"DG","variable({x}): main variable of object x. Gives p for p-adic x, 0 if no variable can be attached to x. Returns the list of user variables if x is omitted."},
{"variables",0,(void*)variables_vec,6,"DG","variables({x}): all variables occurring in object x, sorted by decreasing priority. Returns the list of user variables if x is omitted."},
{"varlower",0,(void*)varlower,6,"sDn","varlower(name,{v}): return a variable 'name' whose priority is lower than the priority of v (of all existing variables if v is omitted."},
{"vecextract",0,(void*)extract0,11,"GGDG","vecextract(x,y,{z}): extraction of the components of the matrix or vector x according to y and z. If z is omitted, y represents columns, otherwise y corresponds to rows and z to columns. y and z can be vectors (of indices), strings (indicating ranges as in \"1..10\") or masks (integers whose binary representation indicates the indices to extract, from left to right 1, 2, 4, 8, etc.)."},
{"vecmax",0,(void*)vecmax0,5,"GD&","vecmax(x,{&v}): largest entry in the vector/matrix x. If v is present, set it to the index of a largest entry (indirect max)."},
{"vecmin",0,(void*)vecmin0,5,"GD&","vecmin(x,{&v}): smallest entry in the vector/matrix x. If v is present, set it to the index of a smallest entry (indirect min)."},
{"vecprod",0,(void*)vecprod,11,"G","vecprod(v): return the product of the components of the vector v."},
{"vecsearch",0,(void*)vecsearch,11,"lGGDG","vecsearch(v,x,{cmpf}): determines whether x belongs to the sorted vector v. If the comparison function cmpf is explicitly given, assume that v was sorted according to vecsort(, cmpf)."},
{"vecsort",0,(void*)vecsort0,11,"GDGD0,L,","vecsort(x,{cmpf},{flag=0}): sorts the vector x in ascending order, according to the comparison function cmpf, if not omitted. Binary digits of flag (if present) mean: 1: indirect sorting, return the permutation instead of the permuted vector, 4: use descending instead of ascending order, 8: remove duplicate entries."},
{"vecsum",0,(void*)vecsum,11,"G","vecsum(v): return the sum of the components of the vector v."},
{"vector",0,(void*)vecteur,11,"GDVDE","vector(n,{X},{expr=0}): row vector with n components of expression expr (X ranges from 1 to n). By default, fills with 0s."},
{"vectorsmall",0,(void*)vecteursmall,11,"GDVDE","vectorsmall(n,{X},{expr=0}): VECSMALL with n components of expression expr (X ranges from 1 to n) which must be small integers. By default, fills with 0s."},
{"vectorv",0,(void*)vvecteur,11,"GDVDE","vectorv(n,{X},{expr=0}): column vector with n components of expression expr (X ranges from 1 to n). By default, fill with 0s."},
{"version",0,(void*)pari_version,2,"","version(): returns the PARI version as [major,minor,patch] or [major,minor,patch,GITversion]."},
{"warning",0,(void*)warning0,2,"vs*","warning({str}*): display warning message str."},
{"weber",0,(void*)weber0,12,"GD0,L,p","weber(x,{flag=0}): one of Weber's f function of x. flag is optional, and can be 0: default, function f(x)=exp(-i*Pi/24)*eta((x+1)/2)/eta(x), 1: function f1(x)=eta(x/2)/eta(x) 2: function f2(x)=sqrt(2)*eta(2*x)/eta(x)."},
{"while",0,(void*)whilepari,1,"vEI","while(a,seq): while a is nonzero evaluate the expression sequence seq. Otherwise 0."},
{"write",0,(void*)write0,2,"vss*","write(filename,{str}*): appends the remaining arguments (same output as print) to filename."},
{"write1",0,(void*)write1,2,"vss*","write1(filename,{str}*): appends the remaining arguments (same output as print1) to filename."},
{"writebin",0,(void*)gpwritebin,2,"vsDG","writebin(filename,{x}): write x as a binary object to file filename. If x is omitted, write all session variables."},
{"writetex",0,(void*)writetex,2,"vss*","writetex(filename,{str}*): appends the remaining arguments (same format as print) to filename, in TeX format."},
{"zeta",0,(void*)gzeta,12,"Gp","zeta(s): Riemann zeta function at s with s a complex or a p-adic number."},
{"zetahurwitz",0,(void*)zetahurwitz,12,"GGD0,L,b","zetahurwitz(s,x,{der=0}): Hurwitz zeta function at s, x, with s not 1 and x not a negative or zero integer. s can be a scalar, polynomial, rational function, or power series. If s is not p-adic, compute the der'th derivative with respect to s, otherwise compute Hurwitz zeta for the der'th power of the Teichmuller character."},
{"zetamult",0,(void*)zetamult_interpolate,12,"GDGp","zetamult(s,{t=0}): multiple zeta value at integral s = [s1,...,sk]; more generally, return Yamamoto's t-MZV interpolation (star value for t = 1)."},
{"zetamultall",0,(void*)zetamultall,12,"LD0,L,p","zetamultall(k,{flag=0}): list of all multiple zeta values for weight up to k. Binary digits of flag mean: 0 = zetastar values if set, 1 = values up to duality if set, 2 = values of weight k if set (else all values up to weight k), 3 = return the 2-component vector [Z, M], where M is the vector of the corresponding indices m, i.e., such that zetamult(M[i]) = Z[i]."},
{"zetamultconvert",0,(void*)zetamultconvert,12,"GD1,L,","zetamultconvert(a,{flag=1}): a being either an evec, avec, or index m, converts into evec (flag=0), avec (flag=1), or index m (flag=2)."},
{"zetamultdual",0,(void*)zetamultdual,12,"G","zetamultdual(s): s being either an evec, avec, or index m, return the dual sequence in avec format."},
{"znchar",0,(void*)znchar,9,"G","znchar(D): given a datum D describing a group G = (Z/NZ)^* and a Dirichlet character chi, return the pair [G,chi]."},
{"zncharconductor",0,(void*)zncharconductor,9,"GG","zncharconductor(G,chi): let G be znstar(q,1) and chi be a Dirichlet character on (Z/qZ)*. Return the conductor of chi."},
{"znchardecompose",0,(void*)znchardecompose,9,"GGG","znchardecompose(G,chi,Q): given a znstar G = (Z/NZ)^* and a Dirichlet character chi, return the product of local characters chi_p for p | (N,Q)."},
{"znchargauss",0,(void*)znchargauss,9,"GGDGb","znchargauss(G,chi,{a=1}): given a Dirichlet character chi on G = (Z/NZ)^*, return the complex Gauss sum g(chi,a)."},
{"zncharinduce",0,(void*)zncharinduce,9,"GGG","zncharinduce(G,chi,N): let G be znstar(q,1), let chi be a Dirichlet character mod q and let N be a multiple of q. Return the character modulo N extending chi."},
{"zncharisodd",0,(void*)zncharisodd,9,"lGG","zncharisodd(G,chi): let G be znstar(N,1), let chi be a Dirichlet character mod N, return 1 if and only if chi(-1) = -1 and 0 otherwise."},
{"znchartokronecker",0,(void*)znchartokronecker,9,"GGD0,L,","znchartokronecker(G,chi,{flag=0}): let G be znstar(N,1), let chi be a Dirichlet character mod N, return the discriminant D if chi is real equal to the Kronecker symbol (D/.) and 0 otherwise. If flag is set, return the fundamental discriminant attached to the corresponding primitive character."},
{"znchartoprimitive",0,(void*)znchartoprimitive,9,"GG","znchartoprimitive(G,chi): let G be znstar(q,1) and chi be a Dirichlet character on (Z/qZ)* of conductor q0. Return [G0,chi0], where chi0 is the primitive character attached to chi and G0 is znstar(q0,1)."},
{"znconreychar",0,(void*)znconreychar,9,"GG","znconreychar(G,m): Dirichlet character attached to m in (Z/qZ)* in Conrey's notation, where G is znstar(q,1)."},
{"znconreyconductor",0,(void*)znconreyconductor,9,"GGD&","znconreyconductor(G,chi,{&chi0}): let G be znstar(q,1) and chi be a Dirichlet character on (Z/qZ)* given by its Conrey logarithm. Return the conductor of chi, and set chi0 to (the Conrey logarithm of) the attached primitive character. If chi0 != chi, return the conductor and its factorization."},
{"znconreyexp",0,(void*)znconreyexp,9,"GG","znconreyexp(G,chi): Conrey exponential attached to G = znstar(q, 1). Returns the element m in (Z/qZ)^* attached to the character chi on G: znconreylog(G, m) = chi."},
{"znconreylog",0,(void*)znconreylog,9,"GG","znconreylog(G,m): Conrey logarithm attached to m in (Z/qZ)*, where G is znstar(q,1)."},
{"zncoppersmith",0,(void*)zncoppersmith,9,"GGGDG","zncoppersmith(P,N,X,{B=N}): finds all integers x with |x| <= X such that  gcd(N, P(x)) >= B. The parameter X should be smaller than exp((log B)^2 / (deg(P) log N)) and the leading coefficient of P should be coprime to N."},
{"znlog",0,(void*)znlog0,9,"GGDG","znlog(x,g,{o}): return the discrete logarithm of x in (Z/nZ)* in base g. If present, o represents the multiplicative order of g. Return [] if no solution exist."},
{"znorder",0,(void*)znorder,9,"GDG","znorder(x,{o}): order of the integermod x in (Z/nZ)*. Optional o represents a multiple of the order of the element."},
{"znprimroot",0,(void*)znprimroot,9,"G","znprimroot(n): returns a primitive root of n when it exists."},
{"znstar",0,(void*)znstar0,9,"GD0,L,","znstar(n,{flag=0}): 3-component vector v = [no,cyc,gen], giving the structure of the abelian group (Z/nZ)^*; no is the order (i.e. eulerphi(n)), cyc is a vector of cyclic components, and gen is a vector giving the corresponding generators."},
{"znsubgroupgenerators",0,(void*)znsubgroupgenerators,9,"GD0,L,","znsubgroupgenerators(H,{flag=0}): finds generators of the subgroup H of (Z/fZ)^*; H is given by a vector of length f of 1/0 values: the a-th component is 1 if and only if a belongs to H."},
{NULL,0,NULL,0,NULL,NULL} /* sentinel */
};
