init.h (pari-2.13.0) | : | init.h (pari-2.13.1) | ||
---|---|---|---|---|

skipping to change at line 294 | skipping to change at line 294 | |||

{"bitnegimply",0,(void*)gbitnegimply,3,"GG","bitnegimply(x,y): bitwise \"negated imply\" of two integers x and y, in other words, x BITAND BITNEG(y). Negative n umbers behave as if modulo big power of 2."}, | {"bitnegimply",0,(void*)gbitnegimply,3,"GG","bitnegimply(x,y): bitwise \"negated imply\" of two integers x and y, in other words, x BITAND BITNEG(y). Negative n umbers behave as if modulo big power of 2."}, | |||

{"bitor",0,(void*)gbitor,3,"GG","bitor(x,y): bitwise \"or\" of two integers x an d y. Negative numbers behave as if modulo big power of 2."}, | {"bitor",0,(void*)gbitor,3,"GG","bitor(x,y): bitwise \"or\" of two integers x an d y. Negative numbers behave as if modulo big power of 2."}, | |||

{"bitprecision",0,(void*)bitprecision00,3,"GDG","bitprecision(x,{n}): if n is pr esent and positive, return x at precision n bits. If n is omitted, return real p recision of object x in bits."}, | {"bitprecision",0,(void*)bitprecision00,3,"GDG","bitprecision(x,{n}): if n is pr esent and positive, return x at precision n bits. If n is omitted, return real p recision of object x in bits."}, | |||

{"bittest",0,(void*)gbittest,3,"GL","bittest(x,n): gives bit number n (coefficie nt of 2^n) of the integer x. Negative numbers behave as if modulo big power of 2 ."}, | {"bittest",0,(void*)gbittest,3,"GL","bittest(x,n): gives bit number n (coefficie nt of 2^n) of the integer x. Negative numbers behave as if modulo big power of 2 ."}, | |||

{"bitxor",0,(void*)gbitxor,3,"GG","bitxor(x,y): bitwise \"exclusive or\" of two integers x and y. Negative numbers behave as if modulo big power of 2."}, | {"bitxor",0,(void*)gbitxor,3,"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,10,"lGD0,L,","bnfcertify(bnf,{flag = 0}): cer tify 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 com puted in bnf (much simpler in general)."}, | {"bnfcertify",0,(void*)bnfcertify0,10,"lGD0,L,","bnfcertify(bnf,{flag = 0}): cer tify 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 com puted in bnf (much simpler in general)."}, | |||

{"bnfdecodemodule",0,(void*)decodemodule,10,"GG","bnfdecodemodule(nf,m): given a coded module m as in bnrdisclist, gives the true module."}, | {"bnfdecodemodule",0,(void*)decodemodule,10,"GG","bnfdecodemodule(nf,m): given a coded module m as in bnrdisclist, gives the true module."}, | |||

{"bnfinit",0,(void*)bnfinit0,10,"GD0,L,DGp","bnfinit(P,{flag=0},{tech=[]}): comp ute the necessary data for future use in ideal and unit group computations, incl uding fundamental units if they are not too large. flag and tech are both option al. flag can be any of 0: default, 1: include all data in algebraic form (compac t units). See manual for details about tech."}, | {"bnfinit",0,(void*)bnfinit0,10,"GD0,L,DGp","bnfinit(P,{flag=0},{tech=[]}): comp ute the necessary data for future use in ideal and unit group computations, incl uding fundamental units if they are not too large. flag and tech are both option al. flag can be any of 0: default, 1: include all data in algebraic form (compac t units). See manual for details about tech."}, | |||

{"bnfisintnorm",0,(void*)bnfisintnorm,10,"GG","bnfisintnorm(bnf,x): compute a co mplete system of solutions (modulo units of positive norm) of the absolute norm equation N(a)=x, where a belongs to the maximal order of big number field bnf (i f bnf is not certified, this depends on GRH)."}, | {"bnfisintnorm",0,(void*)bnfisintnorm,10,"GG","bnfisintnorm(bnf,x): compute a co mplete system of solutions (modulo units of positive norm) of the absolute norm equation N(a)=x, where a belongs to the maximal order of big number field bnf (i f bnf is not certified, this depends on GRH)."}, | |||

{"bnfisnorm",0,(void*)bnfisnorm,10,"GGD1,L,","bnfisnorm(bnf,x,{flag=1}): tries t o tell whether x (in Q) is the norm of some fractional y (in bnf). Returns a vec tor [a,b] where x=Norm(a)*b. Looks for a solution which is a S-unit, with S a ce rtain list of primes (in bnf) containing (among others) all primes dividing x. I f 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 f lag<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 12.log(disc(Bnf))^2, where Bnf i s the Galois closure of bnf."}, | {"bnfisnorm",0,(void*)bnfisnorm,10,"GGD1,L,","bnfisnorm(bnf,x,{flag=1}): tries t o tell whether x (in Q) is the norm of some fractional y (in bnf). Returns a vec tor [a,b] where x=Norm(a)*b. Looks for a solution which is a S-unit, with S a ce rtain list of primes (in bnf) containing (among others) all primes dividing x. I f 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 f lag<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 12.log(disc(Bnf))^2, where Bnf i s the Galois closure of bnf."}, | |||

{"bnfisprincipal",0,(void*)bnfisprincipal0,10,"GGD1,L,","bnfisprincipal(bnf,x,{f lag=1}): bnf being output by bnfinit, gives [e,t], where e is the vector of expo nents on the class group generators and t is the generator of the resulting prin cipal ideal. In particular x is principal if and only if v is the zero vector. f lag is optional, whose binary digits mean 1: output [e,t] (only e if unset); 2: increase precision until alpha can be computed (do not insist if unset); 4: retu rn alpha in factored form (compact representation)."}, | {"bnfisprincipal",0,(void*)bnfisprincipal0,10,"GGD1,L,","bnfisprincipal(bnf,x,{f lag=1}): bnf being output by bnfinit, gives [e,t], where e is the vector of expo nents on the class group generators and t is the generator of the resulting prin cipal ideal. In particular x is principal if and only if e is the zero vector. f lag is optional, whose binary digits mean 1: output [e,t] (only e if unset); 2: increase precision until alpha can be computed (do not insist if unset); 4: retu rn alpha in factored form (compact representation)."}, | |||

{"bnfissunit",0,(void*)bnfissunit,10,"GGG","bnfissunit(bnf,sfu,x): this function is obsolete, use bnfisunit."}, | {"bnfissunit",0,(void*)bnfissunit,10,"GGG","bnfissunit(bnf,sfu,x): this function is obsolete, use bnfisunit."}, | |||

{"bnfisunit",0,(void*)bnfisunit0,10,"GGDG","bnfisunit(bnf,x, {U}): bnf being out put by bnfinit, give the column vector of exponents of x on the fundamental unit s and the roots of unity if x is a unit, the empty vector otherwise. If U is pre sent, as given by bnfunits, decompose x on the attached S-units generators."}, | {"bnfisunit",0,(void*)bnfisunit0,10,"GGDG","bnfisunit(bnf,x, {U}): bnf being out put by bnfinit, give the column vector of exponents of x on the fundamental unit s and the roots of unity if x is a unit, the empty vector otherwise. If U is pre sent, as given by bnfunits, decompose x on the attached S-units generators."}, | |||

{"bnflog",0,(void*)bnflog,10,"GG","bnflog(bnf, l): let bnf be attached to a numb er field F and let l be a prime number. Return the logarithmic l-class group Cl~ _F."}, | {"bnflog",0,(void*)bnflog,10,"GG","bnflog(bnf, l): let bnf be attached to a numb er field F and let l be a prime number. Return the logarithmic l-class group Cl~ _F."}, | |||

{"bnflogdegree",0,(void*)bnflogdegree,10,"GGG","bnflogdegree(nf, A, l): let A be an ideal, return exp(deg_F A) the exponential of the l-adic logarithmic degree. "}, | {"bnflogdegree",0,(void*)bnflogdegree,10,"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,10,"GG","bnflogef(nf,pr): return [e~, f~] the loga rithmic ramification and residue degrees for the maximal ideal pr."}, | {"bnflogef",0,(void*)bnflogef,10,"GG","bnflogef(nf,pr): return [e~, f~] the loga rithmic ramification and residue degrees for the maximal ideal pr."}, | |||

{"bnfnarrow",0,(void*)bnfnarrow,10,"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."}, | {"bnfnarrow",0,(void*)bnfnarrow,10,"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,10,"G","bnfsignunit(bnf): matrix of signs of t he real embeddings of the system of fundamental units found by bnfinit."}, | {"bnfsignunit",0,(void*)signunits,10,"G","bnfsignunit(bnf): matrix of signs of t he real embeddings of the system of fundamental units found by bnfinit."}, | |||

{"bnfsunit",0,(void*)bnfsunit,10,"GGp","bnfsunit(bnf,S): compute the fundamental S-units of the number field bnf output by bnfinit, S being a list of prime idea ls. res[1] contains the S-units, res[5] the S-classgroup."}, | {"bnfsunit",0,(void*)bnfsunit,10,"GGp","bnfsunit(bnf,S): compute the fundamental S-units of the number field bnf output by bnfinit, S being a list of prime idea ls. res[1] contains the S-units, res[5] the S-classgroup."}, | |||

{"bnfunits",0,(void*)bnfunits,10,"GDG","bnfunits(bnf,{S}): return the fundamenta l 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 th e result contains the S-units, followed by fundamental units, followed by the to rsion unit. The result may be used as an optional argument to bnfisunit."}, | {"bnfunits",0,(void*)bnfunits,10,"GDG","bnfunits(bnf,{S}): return the fundamenta l 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 th e result contains the S-units, followed by fundamental units, followed by the to rsion unit. The result may be used as an optional argument to bnfisunit."}, | |||

{"bnrL1",0,(void*)bnrL1,10,"GDGD0,L,p","bnrL1(bnr, {H}, {flag=0}): bnr being out put 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 su bgroup, 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 ter m 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 nontri vial characters), 2: if 0 then compute the value of the primitive L-function att ached 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: r eturn also the characters."}, | {"bnrL1",0,(void*)bnrL1,10,"GDGD0,L,p","bnrL1(bnr, {H}, {flag=0}): bnr being out put 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 su bgroup, 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 ter m 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 nontri vial characters), 2: if 0 then compute the value of the primitive L-function att ached 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: r eturn also the characters."}, | |||

End of changes. 1 change blocks. | ||||

1 lines changed or deleted | | 1 lines changed or added |