| version 1.1, 2001/10/02 11:17:10 |
version 1.2, 2002/09/11 07:27:04 |
| Line 44 char *helpmessages_basic[]={ |
|
| Line 44 char *helpmessages_basic[]={ |
|
| "bernfrac(x): Bernoulli number B_x, as a rational number", |
"bernfrac(x): Bernoulli number B_x, as a rational number", |
| "bernreal(x): Bernoulli number B_x, as a real number with the current precision", |
"bernreal(x): Bernoulli number B_x, as a real number with the current precision", |
| "bernvec(x): Vector of rational Bernoulli numbers B_0, B_2,...up to B_(2x)", |
"bernvec(x): Vector of rational Bernoulli numbers B_0, B_2,...up to B_(2x)", |
| |
"besselh1(nu,x): H^1-bessel function of index nu and argument x", |
| |
"besselh2(nu,x): H^2-bessel function of index nu and argument x", |
| |
"besseli(nu,x): I-bessel function of index nu and argument x", |
| |
"besselj(nu,x): J-bessel function of index nu and argument x", |
| "besseljh(n,x): J-bessel function of index n+1/2 and argument x, where n is a non-negative integer", |
"besseljh(n,x): J-bessel function of index n+1/2 and argument x, where n is a non-negative integer", |
| "besselk(nu,x,{flag=0}): K-bessel function of index nu and argument x (x positive real of type real, nu of any scalar type). flag is optional, and may be set to 0: default; 1: use hyperu", |
"besselk(nu,x,{flag=0}): K-bessel function of index nu and argument x (x positive real of type real, nu of any scalar type). flag is optional, and may be set to 0: default; 1: use hyperu", |
| |
"besseln(nu,x): N-bessel function of index nu and argument x", |
| "bestappr(x,k): gives the best approximation to the real x with denominator less or equal to k", |
"bestappr(x,k): gives the best approximation to the real x with denominator less or equal to k", |
| "bezout(x,y): gives a 3-dimensional row vector [u,v,d] such that d=gcd(x,y) and u*x+v*y=d", |
"bezout(x,y): gives a 3-dimensional row vector [u,v,d] such that d=gcd(x,y) and u*x+v*y=d", |
| "bezoutres(x,y): gives a 3-dimensional row vector [u,v,d] such that d=resultant(x,y) and u*x+v*y=d, where x and y are polynomials", |
"bezoutres(x,y): gives a 3-dimensional row vector [u,v,d] such that d=resultant(x,y) and u*x+v*y=d, where x and y are polynomials", |
| Line 54 char *helpmessages_basic[]={ |
|
| Line 59 char *helpmessages_basic[]={ |
|
| "binomial(x,y): binomial coefficient x*(x-1)...*(x-y+1)/y! defined for y in Z and any x", |
"binomial(x,y): binomial coefficient x*(x-1)...*(x-y+1)/y! defined for y in Z and any x", |
| "bitand(x,y): bitwise \"and\" of two integers x and y. Negative numbers behave as if modulo big power of 2", |
"bitand(x,y): bitwise \"and\" of two integers x and y. Negative numbers behave as if modulo big power of 2", |
| "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", |
"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", |
| "bitnegimpy(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", |
"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(x,y): bitwise \"or\" of two integers x and y. Negative numbers behave as if modulo big power of 2", |
"bitor(x,y): bitwise \"or\" of two integers x and y. Negative numbers behave as if modulo big power of 2", |
| "bittest(x,n): gives bit number n (coefficient of 2^n) of the integer x", |
"bittest(x,n,{c=1}): extracts |c| bits starting from number n (coefficient of 2^n) of the integer x, returning the bits as an integer bitmap; negative c means: treat negative values of x as if modulo big power of 2; bits at negative offsets are zeros", |
| "bitxor(x,y): bitwise \"exclusive or\" of two integers x and y. Negative numbers behave as if modulo big power of 2", |
"bitxor(x,y): bitwise \"exclusive or\" of two integers x and y. Negative numbers behave as if modulo big power of 2", |
| "bnfcertify(bnf): certify the correctness (i.e. remove the GRH) of the bnf data output by bnfclassunit or bnfinit", |
"bnfcertify(bnf): certify the correctness (i.e. remove the GRH) of the bnf data output by bnfclassunit or bnfinit", |
| "bnfclassunit(P,{flag=0},{tech=[]}): compute the class group, regulator of the number field defined by the polynomial P, and also the fundamental units if they are not too large. flag and tech are both optional. flag can be any of 0: default, 1: insist on having fundamental units, 2: do not compute units. See manual for details about tech. P may also be a non-zero integer, and is then considered as the discriminant of a quadratic order", |
"bnfclassunit(P,{flag=0},{tech=[]}): compute the class group, regulator of the number field defined by the polynomial P, and also the fundamental units if they are not too large. flag and tech are both optional. flag can be any of 0: default, 1: insist on having fundamental units, 2: do not compute units. See manual for details about tech. P may also be a non-zero integer, and is then considered as the discriminant of a quadratic order", |
| Line 74 char *helpmessages_basic[]={ |
|
| Line 79 char *helpmessages_basic[]={ |
|
| "bnfsignunit(bnf): matrix of signs of the real embeddings of the system of fundamental units found by bnfinit", |
"bnfsignunit(bnf): matrix of signs of the real embeddings of the system of fundamental units found by bnfinit", |
| "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. See manual for details", |
"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. See manual for details", |
| "bnfunit(bnf): compute the fundamental units of the number field bnf output by bnfinit when they have not yet been computed (i.e. with flag=2)", |
"bnfunit(bnf): compute the fundamental units of the number field bnf output by bnfinit when they have not yet been computed (i.e. with flag=2)", |
| "bnrL1(bnr, subgroup, {flag=0}): bnr being output by bnrinit(,,1) and subgroup being a square matrix defining a congruence subgroup of bnr (or 0 for the trivial subgroup), for each character of bnr trivial on this subgroup, compute L(1, chi) (or equivalently the first non-zero 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 non-trivial characters), 2: if 0 then compute the value of the primitive L-function associated 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", |
"bnrL1(bnr, {subgroup}, {flag=0}): bnr being output by bnrinit(,,1) and subgroup 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 non-zero 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 non-trivial characters), 2: if 0 then compute the value of the primitive L-function associated 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", |
| "bnrclass(bnf,ideal,{flag=0}): given a big number field as output by bnfinit (only) and an ideal or a 2-component row vector formed by an ideal and a list of R1 zeros or ones representing a module, finds the ray class group structure corresponding to this module. flag is optional, and can be 0: default, 1: compute data necessary for working in the ray class group, for example with functions such as bnrisprincipal or bnrdisc, without computing the generators of the ray class group, or 2: with the generators. When flag=1 or 2, the fifth component is the ray class group structure obtained when flag=0", |
"bnrclass(bnf,ideal,{flag=0}): given a big number field as output by bnfinit (only) and an ideal or a 2-component row vector formed by an ideal and a list of R1 zeros or ones representing a module, finds the ray class group structure corresponding to this module. flag is optional, and can be 0: default, 1: compute data necessary for working in the ray class group, for example with functions such as bnrisprincipal or bnrdisc, without computing the generators of the ray class group, or 2: with the generators. When flag=1 or 2, the fifth component is the ray class group structure obtained when flag=0", |
| "bnrclassno(bnf,x): ray class number of the module x for the big number field bnf. Faster than bnrclass if only the ray class number is wanted", |
"bnrclassno(bnf,x): ray class number of the module x for the big number field bnf. Faster than bnrclass if only the ray class number is wanted", |
| "bnrclassnolist(bnf,list): if list is as output by ideallist or similar, gives list of corresponding ray class numbers", |
"bnrclassnolist(bnf,list): if list is as output by ideallist or similar, gives list of corresponding ray class numbers", |
| Line 86 char *helpmessages_basic[]={ |
|
| Line 91 char *helpmessages_basic[]={ |
|
| "bnrisconductor(a1,{a2},{a3}): returns 1 if the modulus is the conductor of the subfield of the ray class field given by a1,a2,a3 (see bnrdisc), and 0 otherwise. Slightly faster than bnrconductor if this is the only desired result", |
"bnrisconductor(a1,{a2},{a3}): returns 1 if the modulus is the conductor of the subfield of the ray class field given by a1,a2,a3 (see bnrdisc), and 0 otherwise. Slightly faster than bnrconductor if this is the only desired result", |
| "bnrisprincipal(bnr,x,{flag=1}): bnr being output by bnrinit, gives [v,alpha,bitaccuracy], where v is the vector of exponents on the class group generators and alpha is the generator of the resulting principal ideal. In particular x is principal if and only if v is the zero vector. If (optional) flag is set to 0, output only v", |
"bnrisprincipal(bnr,x,{flag=1}): bnr being output by bnrinit, gives [v,alpha,bitaccuracy], where v is the vector of exponents on the class group generators and alpha is the generator of the resulting principal ideal. In particular x is principal if and only if v is the zero vector. If (optional) flag is set to 0, output only v", |
| "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 associated to chi. Set flag = 1 if the character is known to be primitive", |
"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 associated to chi. Set flag = 1 if the character is known to be primitive", |
| "bnrstark(bnr,subgroup,{flag=0}): bnr being as output by bnrinit(,,1), finds a relative equation for the class field corresponding to the module in bnr and the given congruence subgroup using Stark's units. The ground field and the class field must be totally real. flag is optional and may be set to 0 to obtain a reduced polynomial, 1 to obtain a non reduced polynomial, 2 to obtain an absolute polynomial and 3 to obtain the irreducible polynomial of the Stark unit, 0 being default. If 4 is added to the value of flag, try hard to find the best modulus", |
"bnrstark(bnr,{subgroup},{flag=0}): bnr being as output by bnrinit(,,1), 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. flag is optional and may be set to 0 to obtain a reduced polynomial, 1 to obtain a non reduced polynomial, 2 to obtain an absolute polynomial and 3 to obtain the irreducible polynomial of the Stark unit, 0 being default. If 4 is added to the value of flag, try hard to find the best modulus", |
| "break({n=1}): interrupt execution of current instruction sequence, and exit from the n innermost enclosing loops", |
"break({n=1}): interrupt execution of current instruction sequence, and exit from the n innermost enclosing loops", |
| "ceil(x): ceiling of x=smallest integer>=x", |
"ceil(x): ceiling of x=smallest integer>=x", |
| "centerlift(x,{v}): centered lift of x. Same as lift except for integermods", |
"centerlift(x,{v}): centered lift of x. Same as lift except for integermods", |
| "changevar(x,y): change variables of x according to the vector y", |
"changevar(x,y): change variables of x according to the vector y", |
| "charpoly(A,{v=x},{flag=0}): det(v*Id-A)=characteristic polynomial of the matrix A using the comatrix. flag is optional and may be set to 1 (use Lagrange interpolation) or 2 (use Hessenberg form), 0 being the default", |
"charpoly(A,{v=x},{flag=0}): det(v*Id-A)=characteristic polynomial of the matrix A using the comatrix. flag is optional and may be set to 1 (use Lagrange interpolation) or 2 (use Hessenberg form), 0 being the default", |
| "chinese(x,y): x,y being integers modulo mx and my, finds z such that z is congruent to x mod mx and y mod my", |
"chinese(x,{y}): x,y being integers modulo mx and my, finds z such that z is congruent to x mod mx and y mod my", |
| "component(x,s): the s'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 \".\" ", |
"component(x,s): the s'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(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", |
"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(x): the algebraic conjugate of x", |
"conj(x): the algebraic conjugate of x", |
| Line 113 char *helpmessages_basic[]={ |
|
| Line 118 char *helpmessages_basic[]={ |
|
| "dirmul(x,y): multiplication of the Dirichlet series x by the Dirichlet series y", |
"dirmul(x,y): multiplication of the Dirichlet series x by the Dirichlet series y", |
| "dirzetak(nf,b): Dirichlet series of the Dedekind zeta function of the number field nf up to the bound b-1", |
"dirzetak(nf,b): Dirichlet series of the Dedekind zeta function of the number field nf up to the bound b-1", |
| "divisors(x): gives a vector formed by the divisors of x in increasing order", |
"divisors(x): gives a vector formed by the divisors of x in increasing order", |
| "divrem(x,y): euclidean division of x by y giving as a 2-dimensional column vector the quotient and the remainder", |
"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(x,{n}): exponential integral E1(x). If n is present, computes the vector of the first n values of the exponential integral E1(n.x) (x > 0)", |
"eint1(x,{n}): exponential integral E1(x). If n is present, computes the vector of the first n values of the exponential integral E1(n.x) (x > 0)", |
| "elladd(e,z1,z2): sum of the points z1 and z2 on elliptic curve e", |
"elladd(e,z1,z2): sum of the points z1 and z2 on elliptic curve e", |
| "ellak(e,n): computes the n-th Fourier coefficient of the L-function of the elliptic curve e", |
"ellak(e,n): computes the n-th Fourier coefficient of the L-function of the elliptic curve e", |
| Line 132 char *helpmessages_basic[]={ |
|
| Line 137 char *helpmessages_basic[]={ |
|
| "ellj(x): elliptic j invariant of x", |
"ellj(x): elliptic j invariant of x", |
| "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 variable needed to make e minimal at p, and c is the local Tamagawa number c_p", |
"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 variable needed to make e minimal at p, and c is the local Tamagawa number c_p", |
| "elllseries(e,s,{A=1}): L-series at s of the elliptic curve e, where A a cut-off point close to 1", |
"elllseries(e,s,{A=1}): L-series at s of the elliptic curve e, where A a cut-off point close to 1", |
| |
"ellminimalmodel(e,{&v}): return the standard minimal integral model of the rational elliptic curve e. Sets v to the corresponding change of variables", |
| "ellorder(e,p): order of the point p on the elliptic curve e over Q, 0 if non-torsion", |
"ellorder(e,p): order of the point p on the elliptic curve e over Q, 0 if non-torsion", |
| "ellordinate(e,x): y-coordinates corresponding to x-ordinate x on elliptic curve e", |
"ellordinate(e,x): y-coordinates corresponding to x-ordinate x on elliptic curve e", |
| "ellpointtoz(e,P): lattice point z corresponding to the point P on the elliptic curve e", |
"ellpointtoz(e,P): lattice point z corresponding to the point P on the elliptic curve e", |
| Line 150 char *helpmessages_basic[]={ |
|
| Line 156 char *helpmessages_basic[]={ |
|
| "eval(x): evaluation of x, replacing variables by their value", |
"eval(x): evaluation of x, replacing variables by their value", |
| "exp(x): exponential of x", |
"exp(x): exponential of x", |
| "factor(x,{lim}): factorization of x. lim is optional and can be set whenever x is of (possibly recursive) rational type. If lim is set return partial factorization, using primes up to lim (up to primelimit if lim=0)", |
"factor(x,{lim}): factorization of x. lim is optional and can be set whenever x is of (possibly recursive) rational type. If lim is set return partial factorization, using primes up to lim (up to primelimit if lim=0)", |
| "factorback(fa,{nf}): given a factorisation fa, gives the factored object back. If this is a prime ideal factorisation you must supply the corresponding number field as second argument", |
"factorback(f,{e},{nf}): given a factorisation f, gives the factored object back. If this is a prime ideal factorisation you must supply the corresponding number field as last argument. 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(x,p): factorization mod p of the polynomial x using Cantor-Zassenhaus", |
"factorcantor(x,p): factorization mod p of the polynomial x using Cantor-Zassenhaus", |
| "factorff(x,p,a): factorization of the polynomial x in the finite field F_p[X]/a(X)F_p[X]", |
"factorff(x,p,a): factorization of the polynomial x in the finite field F_p[X]/a(X)F_p[X]", |
| "factorial(x): factorial of x (x C-integer), the result being given as a real number", |
"factorial(x): factorial of x (x C-integer), the result being given as a real number", |
| Line 170 char *helpmessages_basic[]={ |
|
| Line 176 char *helpmessages_basic[]={ |
|
| "frac(x): fractional part of x = x-floor(x)", |
"frac(x): fractional part of x = x-floor(x)", |
| "galoisfixedfield(gal,perm,{flag},{v=y}): gal being a galois field as output by galoisinit and perm 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", |
"galoisfixedfield(gal,perm,{flag},{v=y}): gal being a galois field as output by galoisinit and perm 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", |
| "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 neccessary informations for computing fixed fields. den is optional and has the same meaning as in nfgaloisconj(,4)(see manual)", |
"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 neccessary informations for computing fixed fields. den is optional and has the same meaning as in nfgaloisconj(,4)(see manual)", |
| |
"galoisisabelian(gal,{flag=0}): gal being as output by galoisinit, return 0 if gal is not abelian, and the HNF matrix of gal over gal.gen if flag=0, 1 if flag is 1", |
| "galoispermtopol(gal,perm): gal being a galois field as output by galoisinit and perm a element of gal.group, return the polynomial defining the corresponding Galois automorphism", |
"galoispermtopol(gal,perm): gal being a galois field as output by galoisinit and perm a element of gal.group, return the polynomial defining the corresponding Galois automorphism", |
| "galoissubcyclo(n,H,{Z},{v},{fl=0}):Compute a polynomial defining the subfield of Q(zeta_n) fixed by the subgroup H of Z/nZ. H can be given by a generator, a set of generator given by a vector or a SNF matrix. If present Z must be znstar(n), currently it is used only when H is a SNF matrix. If v is given, the polynomial is given in the variable v. If flag is 1, output only the conductor of the abelian extension. If flag is 2 output [pol,f] where pol is the polynomial and f the conductor.", |
"galoissubcyclo(N,H,{fl=0},{v}):Compute 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]],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, output only the conductor of the abelian extension. If flag is 2 output [pol,f] where pol is the polynomial and f the conductor.", |
| |
"galoissubfields(G,{flags=0},{v}):Output all the subfields of G. flags have the same meaning as for galoisfixedfield", |
| |
"galoissubgroups(G):Output all the subgroups of G", |
| "gamma(x): gamma function at x", |
"gamma(x): gamma function at x", |
| "gammah(x): gamma of x+1/2 (x integer)", |
"gammah(x): gamma of x+1/2 (x integer)", |
| "gcd(x,y,{flag=0}): greatest common divisor of x and y. flag is optional, and can be 0: default, 1: use the modular gcd algorithm (x and y must be polynomials), 2 use the subresultant algorithm (x and y must be polynomials)", |
"gcd(x,{y},{flag=0}): greatest common divisor of x and y. flag is optional, and can be 0: default, 1: use the modular gcd algorithm (x and y must be polynomials), 2 use the subresultant algorithm (x and y must be polynomials)", |
| "getheap(): 2-component vector giving the current number of objects in the heap and the space they occupy", |
"getheap(): 2-component vector giving the current number of objects in the heap and the space they occupy", |
| "getrand(): current value of random number seed", |
"getrand(): current value of random number seed", |
| "getstack(): current value of stack pointer avma", |
"getstack(): current value of stack pointer avma", |
| Line 212 char *helpmessages_basic[]={ |
|
| Line 221 char *helpmessages_basic[]={ |
|
| "intformal(x,{y}): formal integration of x with respect to the main variable of y, or to the main variable of x if y is omitted", |
"intformal(x,{y}): formal integration of x with respect to the main variable of y, or to the main variable of x if y is omitted", |
| "intnum(X=a,b,s,{flag=0}): numerical integration of s (smooth in ]a,b[) from a to b with respect to X. flag is optional and mean 0: default. s 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: s has only limits at a or b", |
"intnum(X=a,b,s,{flag=0}): numerical integration of s (smooth in ]a,b[) from a to b with respect to X. flag is optional and mean 0: default. s 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: s has only limits at a or b", |
| "isfundamental(x): true(1) if x is a fundamental discriminant (including 1), false(0) if not", |
"isfundamental(x): true(1) if x is a fundamental discriminant (including 1), false(0) if not", |
| "isprime(x,{flag=0}): if flag is omitted or 0 true(1) if x is a strong pseudoprime for 10 random bases, false(0) if not. If flag is 1 the primality is certified by Pocklington-Lehmer Test. If flag is 2 a primality certificate is output(see manual)", |
"isprime(x,{flag=0}): if flag is omitted or 0, true(1) if x is a strong pseudoprime for 10 random bases, false(0) if not. 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.", |
| "ispseudoprime(x): true(1) if x is a strong pseudoprime, false(0) if not", |
"ispseudoprime(x): true(1) if x is a strong pseudoprime, false(0) if not", |
| "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", |
"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(x): true(1) if x is squarefree, false(0) if not", |
"issquarefree(x): true(1) if x is squarefree, false(0) if not", |
| "kronecker(x,y): kronecker symbol (x/y)", |
"kronecker(x,y): kronecker symbol (x/y)", |
| "lcm(x,y): least common multiple of x and y=x*y/gcd(x,y)", |
"lcm(x,{y}): least common multiple of x and y=x*y/gcd(x,y)", |
| "length(x): number of non code words in x, number of characters for a string", |
"length(x): number of non code words in x, number of characters for a string", |
| "lex(x,y): compare x and y lexicographically (1 if x>y, 0 if x=y, -1 if x<y)", |
"lex(x,y): compare x and y lexicographically (1 if x>y, 0 if x=y, -1 if x<y)", |
| "lift(x,{v}): lifts every element of Z/nZ to Z or T[x]/PT[x] to T[x] for a type T if v is omitted, otherwise lift only polymods with main variable v. If v does not occur in x, lift only intmods", |
"lift(x,{v}): lifts every element of Z/nZ to Z or T[x]/PT[x] to T[x] for a type T if v is omitted, otherwise lift only polymods with main variable v. If v does not occur in x, lift only intmods", |
| Line 277 char *helpmessages_basic[]={ |
|
| Line 286 char *helpmessages_basic[]={ |
|
| "nfdisc(x,{flag=0},{p}): discriminant of the number field defined by the polynomial x using round 4. Optional args flag and p are as in nfbasis", |
"nfdisc(x,{flag=0},{p}): discriminant of the number field defined by the polynomial x using round 4. Optional args flag and p are as in nfbasis", |
| "nfeltdiv(nf,a,b): element a/b in nf", |
"nfeltdiv(nf,a,b): element a/b in nf", |
| "nfeltdiveuc(nf,a,b): gives algebraic integer q such that a-bq is small", |
"nfeltdiveuc(nf,a,b): gives algebraic integer q such that a-bq is small", |
| "nfeltdivmodpr(nf,a,b,pr): element a/b modulo pr in nf, where pr is in prhall format (see nfmodprinit)", |
"nfeltdivmodpr(nf,a,b,pr): element a/b modulo pr in nf, where pr is in modpr format (see nfmodprinit)", |
| "nfeltdivrem(nf,a,b): gives [q,r] such that r=a-bq is small", |
"nfeltdivrem(nf,a,b): gives [q,r] such that r=a-bq is small", |
| "nfeltmod(nf,a,b): gives r such that r=a-bq is small with q algebraic integer", |
"nfeltmod(nf,a,b): gives r such that r=a-bq is small with q algebraic integer", |
| "nfeltmul(nf,a,b): element a. b in nf", |
"nfeltmul(nf,a,b): element a. b in nf", |
| "nfeltmulmodpr(nf,a,b,pr): element a. b modulo pr in nf, where pr is in prhall format (see nfmodprinit)", |
"nfeltmulmodpr(nf,a,b,pr): element a. b modulo pr in nf, where pr is in modpr format (see nfmodprinit)", |
| "nfeltpow(nf,a,k): element a^k in nf", |
"nfeltpow(nf,a,k): element a^k in nf", |
| "nfeltpowmodpr(nf,a,k,pr): element a^k modulo pr in nf, where pr is in prhall format (see nfmodprinit)", |
"nfeltpowmodpr(nf,a,k,pr): element a^k modulo pr in nf, where pr is in modpr format (see nfmodprinit)", |
| "nfeltreduce(nf,a,id): gives r such that a-r is in the ideal id and r is small", |
"nfeltreduce(nf,a,id): gives r such that a-r is in the ideal id and r is small", |
| "nfeltreducemodpr(nf,a,pr): element a modulo pr in nf, where pr is in prhall format (see nfmodprinit)", |
"nfeltreducemodpr(nf,a,pr): element a modulo pr in nf, where pr is in modpr format (see nfmodprinit)", |
| "nfeltval(nf,a,pr): valuation of element a at the prime pr as output by idealprimedec", |
"nfeltval(nf,a,pr): valuation of element a at the prime pr as output by idealprimedec", |
| "nffactor(nf,x): factor polynomial x in number field nf", |
"nffactor(nf,x): factor polynomial x in number field nf", |
| "nffactormod(nf,pol,pr): factorize polynomial pol modulo prime ideal pr in number field nf", |
"nffactormod(nf,pol,pr): factorize polynomial pol modulo prime ideal pr in number field nf", |
| Line 298 char *helpmessages_basic[]={ |
|
| Line 307 char *helpmessages_basic[]={ |
|
| "nfisideal(nf,x): true(1) if x is an ideal in the number field nf, false(0) if not", |
"nfisideal(nf,x): true(1) if x is an ideal in the number field nf, false(0) if not", |
| "nfisincl(x,y): tests whether the number field x is isomorphic to a subfield of y (where x and y are either polynomials or number fields as output by nfinit). Return 0 if not, and otherwise all the isomorphisms. If y is a number field, a faster algorithm is used", |
"nfisincl(x,y): tests whether the number field x is isomorphic to a subfield of y (where x and y are either polynomials or number fields as output by nfinit). Return 0 if not, and otherwise all the isomorphisms. If y is a number field, a faster algorithm is used", |
| "nfisisom(x,y): as nfisincl but tests whether x is isomorphic to y", |
"nfisisom(x,y): as nfisincl but tests whether x is isomorphic to y", |
| "nfkermodpr(nf,x,pr): kernel of the matrix x in Z_K/pr, where pr is in prhall format (see nfmodprinit)", |
"nfkermodpr(nf,x,pr): kernel of the matrix x in Z_K/pr, where pr is in modpr format (see nfmodprinit)", |
| "nfmodprinit(nf,pr): transform the 5 element row vector pr representing a prime ideal into prhall format necessary for all operations mod pr in the number field nf (see manual for details about the format)", |
"nfmodprinit(nf,pr): transform the 5 element row vector pr representing a prime ideal into modpr format necessary for all operations mod pr in the number field nf (see manual for details about the format)", |
| "nfnewprec(nf): transform the number field data nf into new data using the current (usually larger) precision", |
"nfnewprec(nf): transform the number field data nf into new data using the current (usually larger) precision", |
| "nfroots(nf,pol): roots of polynomial pol belonging to nf without multiplicity", |
"nfroots(nf,pol): roots of polynomial pol belonging to nf without multiplicity", |
| "nfrootsof1(nf): number of roots of unity and primitive root of unity in the number field nf", |
"nfrootsof1(nf): number of roots of unity and primitive root of unity in the number field nf", |
| "nfsnf(nf,x): if x=[A,I,J], outputs [c_1,...c_n] Smith normal form of x", |
"nfsnf(nf,x): if x=[A,I,J], outputs [c_1,...c_n] Smith normal form of x", |
| "nfsolvemodpr(nf,a,b,pr): solution of a*x=b in Z_K/pr, where a is a matrix and b a column vector, and where pr is in prhall format (see nfmodprinit)", |
"nfsolvemodpr(nf,a,b,pr): solution of a*x=b in Z_K/pr, where a is a matrix and b a column vector, and where pr is in modpr format (see nfmodprinit)", |
| "nfsubfields(nf,{d=0}): find all subfields of degree d of number field nf (all subfields if d is null or omitted). Result is a vector of subfields, each being given by [g,h], 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", |
"nfsubfields(nf,{d=0}): find all subfields of degree d of number field nf (all subfields if d is null or omitted). Result is a vector of subfields, each being given by [g,h], 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", |
| "norm(x): norm of x", |
"norm(x): norm of x", |
| "norml2(x): square of the L2-norm of the vector x", |
"norml2(x): square of the L2-norm of the vector x", |
| Line 329 char *helpmessages_basic[]={ |
|
| Line 338 char *helpmessages_basic[]={ |
|
| "pollegendre(n,{v=x}): legendre polynomial of degree n (n C-integer), in variable v", |
"pollegendre(n,{v=x}): legendre polynomial of degree n (n C-integer), in variable v", |
| "polrecip(x): reciprocal polynomial of x", |
"polrecip(x): reciprocal polynomial of x", |
| "polred(x,{flag=0},{p}): reduction of the polynomial x (gives minimal polynomials only). Second and third args are optional. The following binary digits of flag are significant 1: partial reduction, 2: gives also elements. p, if present, contains the complete factorization matrix of the discriminant", |
"polred(x,{flag=0},{p}): reduction of the polynomial x (gives minimal polynomials only). Second and third args are optional. The following binary digits of flag are significant 1: partial reduction, 2: gives also elements. p, if present, contains the complete factorization matrix of the discriminant", |
| "polredabs(x,{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))", |
"polredabs(x,{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)). 16: partial reduction", |
| "polredord(x): reduction of the polynomial x, staying in the same order", |
"polredord(x): reduction of the polynomial x, staying in the same order", |
| "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, assumes that the polynomials have exact entries (uses the subresultant algorithm), 1 for arbitrary polynomials, using Sylvester's matrix, or 2: using a Ducos's modified subresultant algorithm", |
"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, assumes that the polynomials have exact entries (uses the subresultant algorithm), 1 for arbitrary polynomials, using Sylvester's matrix, or 2: using a Ducos's modified subresultant algorithm", |
| "polroots(x,{flag=0}): complex roots of the polynomial x. flag is optional, and can be 0: default, uses Schonhage's method modified by Gourdon, or 1: uses a modified Newton method", |
"polroots(x,{flag=0}): complex roots of the polynomial x. flag is optional, and can be 0: default, uses Schonhage's method modified by Gourdon, or 1: uses a modified Newton method", |
| "polrootsmod(x,p,{flag=0}): roots mod p of the polynomial x. flag is optional, and can be 0: default, or 1: use a naive search, useful for small p", |
"polrootsmod(x,p,{flag=0}): roots mod p of the polynomial x. flag is optional, and can be 0: default, or 1: use a naive search, useful for small p", |
| "polrootspadic(x,p,r): p-adic roots of the polynomial x to precision r", |
"polrootspadic(x,p,r): p-adic roots of the polynomial x to precision r", |
| "polsturm(x,{a},{b}): number of real roots of the polynomial x in the interval]a,b] (which are respectively taken to be -oo or +oo when omitted)", |
"polsturm(x,{a},{b}): number of real roots of the polynomial x in the interval]a,b] (which are respectively taken to be -oo or +oo when omitted)", |
| "polsubcyclo(n,d,{v=x}): finds an equation (in variable v) for the d-th degree subfield of Q(zeta_n), where (Z/nZ)^* must be cyclic", |
"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 is there are several such fields, or none.", |
| "polsylvestermatrix(x,y): forms the sylvester matrix associated to the two polynomials x and y. Warning: the polynomial coefficients are in columns, not in rows", |
"polsylvestermatrix(x,y): forms the sylvester matrix associated to the two polynomials x and y. Warning: the polynomial coefficients are in columns, not in rows", |
| "polsym(x,n): vector of symmetric powers of the roots of x up to n", |
"polsym(x,n): vector of symmetric powers of the roots of x up to n", |
| "poltchebi(n,{v=x}): Tchebitcheff polynomial of degree n (n C-integer), in variable v", |
"poltchebi(n,{v=x}): Tchebitcheff polynomial of degree n (n C-integer), in variable v", |
| Line 361 char *helpmessages_basic[]={ |
|
| Line 370 char *helpmessages_basic[]={ |
|
| "qfbred(x,{flag=0},{D},{isqrtD},{sqrtD}): reduction of the binary quadratic form x. All other args. are optional. D, isqrtD and sqrtD, if present, supply the values of the discriminant, floor(sqrt(D)) and sqrt(D) respectively. If D<0, its value is not used and all references to Shanks's distance hereafter are meaningless. flag can be any of 0: default, uses Shanks's distance function d; 1: use d, do a single reduction step; 2: do not use d; 3: do not use d, single reduction step. ", |
"qfbred(x,{flag=0},{D},{isqrtD},{sqrtD}): reduction of the binary quadratic form x. All other args. are optional. D, isqrtD and sqrtD, if present, supply the values of the discriminant, floor(sqrt(D)) and sqrt(D) respectively. If D<0, its value is not used and all references to Shanks's distance hereafter are meaningless. flag can be any of 0: default, uses Shanks's distance function d; 1: use d, do a single reduction step; 2: do not use d; 3: do not use d, single reduction step. ", |
| "qfgaussred(x): square reduction of the (symmetric) matrix x (returns a square matrix whose i-th diagonal term is the coefficient of the i-th square in which the coefficient of the i-th variable is 1)", |
"qfgaussred(x): square reduction of the (symmetric) matrix x (returns a square matrix whose i-th diagonal term is the coefficient of the i-th square in which the coefficient of the i-th variable is 1)", |
| "qfjacobi(x): eigenvalues and orthogonal matrix of eigenvectors of the real symmetric matrix x", |
"qfjacobi(x): eigenvalues and orthogonal matrix of eigenvectors of the real symmetric matrix x", |
| "qflll(x,{flag=0}): LLL reduction of the vectors forming the matrix x (gives the unimodular transformation matrix). flag is optional, and can be 0: default, 1: lllint algorithm for integer matrices, 2: lllintpartial algorithm for integer matrices, 3: lllrat for rational matrices, 4: lllkerim giving the kernel and the LLL reduced image, 5: lllkerimgen same but if the matrix has polynomial coefficients, 7: lll1, old version of qflll, 8: lllgen, same as qflll when the coefficients are polynomials, 9: lllint algorithm for integer matrices using content", |
"qflll(x,{flag=0}): LLL reduction of the vectors forming the matrix x (gives the unimodular transformation matrix). flag is optional, and can be 0: default, 1: lllint algorithm for integer matrices, 2: lllintpartial algorithm for integer matrices, 4: lllkerim giving the kernel and the LLL reduced image, 5: lllkerimgen same but if the matrix has polynomial coefficients, 8: lllgen, same as qflll when the coefficients are polynomials", |
| "qflllgram(x,{flag=0}): LLL reduction of the lattice whose gram matrix is x (gives the unimodular transformation matrix). flag is optional and can be 0: default,1: lllgramint algorithm for integer matrices, 4: lllgramkerim giving the kernel and the LLL reduced image, 5: lllgramkerimgen same when the matrix has polynomial coefficients, 7: lllgram1, old version of qflllgram, 8: lllgramgen, same as qflllgram when the coefficients are polynomials", |
"qflllgram(x,{flag=0}): LLL reduction of the lattice whose gram matrix is x (gives the unimodular transformation matrix). flag is optional and can be 0: default,1: lllgramint algorithm for integer matrices, 4: lllgramkerim giving the kernel and the LLL reduced image, 5: lllgramkerimgen same when the matrix has polynomial coefficients, 8: lllgramgen, same as qflllgram when the coefficients are polynomials", |
| "qfminim(x,bound,maxnum,{flag=0}): number of vectors of square norm <= bound, maximum norm and list of vectors for the integral and definite quadratic form x; minimal non-zero vectors if bound=0. flag is optional, and can be 0: default; 1: returns the first minimal vector found (ignore maxnum); 2: as 0 but use Fincke-Pohst (valid for non integral quadratic forms)", |
"qfminim(x,bound,maxnum,{flag=0}): number of vectors of square norm <= bound, maximum norm and list of vectors for the integral and definite quadratic form x; minimal non-zero vectors if bound=0. flag is optional, and can be 0: default; 1: returns the first minimal vector found (ignore maxnum); 2: as 0 but use Fincke-Pohst (valid for non integral quadratic forms)", |
| "qfperfection(a): rank of matrix of xx~ for x minimal vectors of a gram matrix a", |
"qfperfection(a): rank of matrix of xx~ for x minimal vectors of a gram matrix a", |
| "qfsign(x): signature of the symmetric matrix x", |
"qfsign(x): signature of the symmetric matrix x", |
| Line 404 char *helpmessages_basic[]={ |
|
| Line 413 char *helpmessages_basic[]={ |
|
| "rnfidealup(rnf,x): lifts the ideal x (of the base field) to the relative field", |
"rnfidealup(rnf,x): lifts the ideal x (of the base field) to the relative field", |
| "rnfinit(nf,pol): pol being a non constant 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", |
"rnfinit(nf,pol): pol being a non constant 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", |
| "rnfisfree(bnf,order): given an order as output by rnfpseudobasis or rnfsteinitz, outputs true (1) or false (0) according to whether the order is free or not", |
"rnfisfree(bnf,order): given an order as output by rnfpseudobasis or rnfsteinitz, outputs true (1) or false (0) according to whether the order is free or not", |
| "rnfisnorm(bnf,ext,x,{flag=1}): Tries to tell whether x (in bnf) is the norm of some y (in ext). Returns a vector [a,b] where x=Norm(a)*b. Looks for a solution which is a S-integer, with S a list of places (in bnf) containing the ramified primes, generators of the class group of ext, as well as those primes dividing x. If ext/bnf is known to be Galois, set flag=0 (here x is a norm iff b=1). If flag is non zero add to S all the places above the primes: dividing flag if flag<0, 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 12.log(Ext)^2, where Ext is the normal closure of ext/bnf", |
"rnfisnorm(T,x,{flag=0}): T is as output by rnfisnorminit applied to L/K. Tries to tell whether x is a norm from L/K. Returns a vector [a,b] where x=Norm(a)*b. 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 x. If L/K is Galois, 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 x norm iff b=1) if L/K is Galois or, under GRH, if S contains all primes less than 12.log(disc(M))^2, where M is the normal closure of L/K", |
| "rnfkummer(bnr,subgroup,{deg=0}): 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. deg can be zero (default), or positive, and in this case the output is the list of all relative equations of degree deg for the given bnr", |
"rnfisnorminit(pol,polrel,{flag=2}): let K be defined by a root of pol, L/K the extension defined by polrel. Compute technical data needed by rnfisnorm to solve norm equations Nx = a, for x in L, and a in K. If flag=0, do not care whether L/K is Galois or not; if flag = 1, assume L/K is Galois; if flag = 2, determine whether L/K is Galois", |
| |
"rnfkummer(bnr,{subgroup},{deg=0}): 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 ray class field if subgroup is omitted). deg can be zero (default), or positive, and in this case the output is the list of all relative equations of degree deg for the given bnr", |
| "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", |
"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(bnr,polrel): norm group (or Artin or Takagi group) corresponding to the Abelian extension of bnr.bnf defined by polrel, 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 given generators in bnr[5][3]", |
"rnfnormgroup(bnr,polrel): norm group (or Artin or Takagi group) corresponding to the Abelian extension of bnr.bnf defined by polrel, 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 given generators in bnr[5][3]", |
| "rnfpolred(nf,pol): given a pol with coefficients in nf, finds a list of relative polynomials defining some subfields, hopefully simpler", |
"rnfpolred(nf,pol): given a pol with coefficients in nf, finds a list of relative polynomials defining some subfields, hopefully simpler", |
| Line 422 char *helpmessages_basic[]={ |
|
| Line 432 char *helpmessages_basic[]={ |
|
| "setrand(n): reset the seed of the random number generator to n", |
"setrand(n): reset the seed of the random number generator to n", |
| "setsearch(x,y,{flag=0}): looks if y belongs to the set x. If flag is 0 or omitted, returns 0 if it is not, otherwise returns the index j such that y==x[j]. If flag is non-zero, return 0 if y belongs to x, otherwise the index j where it should be inserted", |
"setsearch(x,y,{flag=0}): looks if y belongs to the set x. If flag is 0 or omitted, returns 0 if it is not, otherwise returns the index j such that y==x[j]. If flag is non-zero, return 0 if y belongs to x, otherwise the index j where it should be inserted", |
| "setunion(x,y): union of the sets x and y", |
"setunion(x,y): union of the sets x and y", |
| "shift(x,n): shift x left n bits if n>=0, right -n bits if n<0", |
"shift(x,n,{flag=0}): shift x left n bits if n>=0, right -n bits if n<0. If flag is true and n is negative, will treat negative integer x as if modulo big power of 2, otherwise sign of x is ignored but preserved", |
| "shiftmul(x,n): multiply x by 2^n (n>=0 or n<0)", |
"shiftmul(x,n): multiply x by 2^n (n>=0 or n<0)", |
| "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", |
"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(x): sign of x, of type integer, real or fraction", |
"sign(x): sign of x, of type integer, real or fraction", |
| Line 459 char *helpmessages_basic[]={ |
|
| Line 469 char *helpmessages_basic[]={ |
|
| "vecextract(x,y,{z}): extraction of the components of the matrix or vector x according to y and z. If z is omitted, y designs 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.)", |
"vecextract(x,y,{z}): extraction of the components of the matrix or vector x according to y and z. If z is omitted, y designs 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(x): maximum of the elements of the vector/matrix x", |
"vecmax(x): maximum of the elements of the vector/matrix x", |
| "vecmin(x): minimum of the elements of the vector/matrix x", |
"vecmin(x): minimum of the elements of the vector/matrix x", |
| "vecsort(x,{k},{flag=0}): sorts the vector of vectors (or matrix) x, according to the value of its k-th component if k is not omitted. Binary digits of flag (if present) mean: 1: indirect sorting, return the permutation instead of the permuted vector, 2: sort using ascending lexicographic order", |
"vecsort(x,{k},{flag=0}): sorts the vector of vectors (or matrix) x in ascending order, according to the value of its k-th component if k is not omitted. Binary digits of flag (if present) mean: 1: indirect sorting, return the permutation instead of the permuted vector, 2: sort using lexicographic order, 4: use descending instead of ascending order", |
| "vector(n,{X},{expr=0}): row vector with n components of expression expr (X ranges from 1 to n). By default, fill with 0s", |
"vector(n,{X},{expr=0}): row vector with n components of expression expr (X ranges from 1 to n). By default, fill with 0s", |
| |
"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, fill with 0s", |
| "vectorv(n,{X},{expr=0}): column vector with n components of expression expr (X ranges from 1 to n). By default, fill with 0s", |
"vectorv(n,{X},{expr=0}): column vector with n components of expression expr (X ranges from 1 to n). By default, fill with 0s", |
| "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) such that (j=(f^24-16)^3/f^24), 1: function f1(x)=eta(x/2)/eta(x) such that (j=(f1^24+16)^3/f2^24), 2: function f2(x)=sqrt(2)*eta(2*x)/eta(x) such that (j=(f2^24+16)^3/f2^24)", |
"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) such that (j=(f^24-16)^3/f^24), 1: function f1(x)=eta(x/2)/eta(x) such that (j=(f1^24+16)^3/f2^24), 2: function f2(x)=sqrt(2)*eta(2*x)/eta(x) such that (j=(f2^24+16)^3/f2^24)", |
| "while(a,seq): while a is nonzero evaluate the expression sequence seq. Otherwise 0", |
"while(a,seq): while a is nonzero evaluate the expression sequence seq. Otherwise 0", |
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to helpmsg.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / pari-2.2 / src / language