=================================================================== RCS file: /home/cvs/OpenXM_contrib/pari-2.2/src/language/Attic/helpmsg.c,v retrieving revision 1.1.1.1 retrieving revision 1.2 diff -u -p -r1.1.1.1 -r1.2 --- OpenXM_contrib/pari-2.2/src/language/Attic/helpmsg.c 2001/10/02 11:17:10 1.1.1.1 +++ OpenXM_contrib/pari-2.2/src/language/Attic/helpmsg.c 2002/09/11 07:27:04 1.2 @@ -1,4 +1,4 @@ -/* $Id: helpmsg.c,v 1.1.1.1 2001/10/02 11:17:10 noro Exp $ +/* $Id: helpmsg.c,v 1.2 2002/09/11 07:27:04 noro Exp $ Copyright (C) 2000 The PARI group. @@ -44,8 +44,13 @@ char *helpmessages_basic[]={ "bernfrac(x): Bernoulli number B_x, as a rational number", "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)", + "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", "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", "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", @@ -54,9 +59,9 @@ char *helpmessages_basic[]={ "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", "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", - "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", "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", @@ -74,7 +79,7 @@ char *helpmessages_basic[]={ "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", "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", "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", @@ -86,13 +91,13 @@ 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", "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", - "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", "ceil(x): ceiling of x=smallest integer>=x", "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", "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 \".\" ", "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", @@ -113,7 +118,7 @@ char *helpmessages_basic[]={ "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", "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)", "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", @@ -132,6 +137,7 @@ char *helpmessages_basic[]={ "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", "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", "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", @@ -150,7 +156,7 @@ char *helpmessages_basic[]={ "eval(x): evaluation of x, replacing variables by their value", "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)", - "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", "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", @@ -170,11 +176,14 @@ char *helpmessages_basic[]={ "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", "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", - "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", "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", "getrand(): current value of random number seed", "getstack(): current value of stack pointer avma", @@ -212,12 +221,12 @@ 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", "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", - "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", "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", "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", "lex(x,y): compare x and y lexicographically (1 if x>y, 0 if x=y, -1 if x0. 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", - "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", + "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", + "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", "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", @@ -422,7 +432,7 @@ char *helpmessages_basic[]={ "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", "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)", "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", @@ -459,8 +469,9 @@ 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.)", "vecmax(x): maximum 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", + "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", "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",