The expression x{ ^}n is powering. If the exponent is an integer, then exact operations are performed using binary (left-shift) powering techniques. In particular, in this case x cannot be a vector or matrix unless it is a square matrix (invertible if the exponent is negative). If x is a p-adic number, its precision will increase if v_p(n) > 0. Powering a binary quadratic form (types t_QFI and t_QFR) returns a reduced representative of the class, provided the input is reduced. In particular, x{ ^}1 is identical to x.

PARI is able to rewrite the multiplication x * x of two identical objects as x^2, or sqr(x). Here, identical means the operands are two different labels referencing the same chunk of memory; no equality test is performed. This is no longer true when more than two arguments are involved.

If the exponent is not of type integer, this is treated as a transcendental function (see Section [Label: se:trans]), and in particular has the effect of componentwise powering on vector or matrices.

As an exception, if the exponent is a rational number p/q and x an integer modulo a prime or a p-adic number, return a solution y of y^q = x^p if it exists. Currently, q must not have large prime factors. Beware that

    ? Mod(7,19)^(1/2)
     %1 = Mod(11, 19) /* is any square root */
     ? sqrt(Mod(7,19))
     %2 = Mod(8, 19)  /* is the smallest square root */
     ? Mod(7,19)^(3/5)
     %3 = Mod(1, 19)
     ? %3^(5/3)
     %4 = Mod(1, 19)  /* Mod(7,19) is just another cubic root */

If the exponent is a negative integer, an inverse must be computed. For non-invertible t_INTMOD, this will fail and implicitly exhibit a non trivial factor of the modulus:

    ? Mod(4,6)^(-1)
       ***   impossible inverse modulo: Mod(2, 6).

(Here, a factor 2 is obtained directly. In general, take the gcd of the representative and the modulus.) This is most useful when performing complicated operations modulo an integer N whose factorization is unknown. Either the computation succeeds and all is well, or a factor d is discovered and the computation may be restarted modulo d or N/d.

For non-invertible t_POLMOD, this will fail without exhibiting a factor.

    ? Mod(x^2, x^3-x)^(-1)
       ***   non-invertible polynomial in RgXQ_inv.
 
     ? a = Mod(3,4)*y^3 + Mod(1,4); b = y^6+y^5+y^4+y^3+y^2+y+1;
     ? Mod(a, b)^(-1);
       ***   non-invertible polynomial in RgXQ_inv.

In fact the latter polynomial is invertible, but the algorithm used (subresultant) assumes the base ring is a domain. If it is not the case, as here for Z/4Z, a result will be correct but chances are an error will occur first. In this specific case, one should work with 2-adics. In general, one can try the following approach

    ? inversemod(a, b) =
     { local(m);
       m = polsylvestermatrix(polrecip(a), polrecip(b));
       m = matinverseimage(m, matid(#m)[,1]);
       Polrev( vecextract(m, Str("..", poldegree(b))), variable(b) )
     }
     ? inversemod(a,b)
     %2 = Mod(2,4)*y^5 + Mod(3,4)*y^3 + Mod(1,4)*y^2 + Mod(3,4)*y + Mod(2,4)
 

This is not guaranteed to work either since it must invert pivots. See Section [Label: se:linear_algebra].

The library syntax is gpow(x,n,prec) for x{ ^}n.

Euler's constant gamma = 0.57721.... Note that Euler is one of the few special reserved names which cannot be used for variables (the others are I and Pi, as well as all function names).

The library syntax is mpeuler(prec) where prec must be given. Note that this creates gamma on the PARI stack, but a copy is also created on the heap for quicker computations next time the function is called.

the complex number sqrt{-1}.

The library syntax is the global variable gi (of type GEN).

the constant Pi (3.14159...).

The library syntax is mppi(prec) where prec must be given. Note that this creates Pi on the PARI stack, but a copy is also created on the heap for quicker computations next time the function is called.

absolute value of x (modulus if x is complex). Rational functions are not allowed. Contrary to most transcendental functions, an exact argument is not converted to a real number before applying abs and an exact result is returned if possible.

? abs(-1)
 %1 = 1
 ? abs(3/7 + 4/7*I)
 %2 = 5/7
 ? abs(1 + I)
 %3 = 1.414213562373095048801688724

If x is a polynomial, returns -x if the leading coefficient is real and negative else returns x. For a power series, the constant coefficient is considered instead.

The library syntax is gabs(x,prec).

principal branch of {cos}^{-1}(x), i.e.such that {Re(acos}(x)) belongs to [0,Pi]. If x belongs to R and |x| > 1, then {acos}(x) is complex.

The library syntax is gacos(x,prec).

principal branch of {cosh}^{-1}(x), i.e.such that {Im(acosh}(x)) belongs to [0,Pi]. If x belongs to R and x < 1, then {acosh}(x) is complex.

The library syntax is gach(x,prec).

arithmetic-geometric mean of x and y. In the case of complex or negative numbers, the principal square root is always chosen. p-adic or power series arguments are also allowed. Note that a p-adic agm exists only if x/y is congruent to 1 modulo p (modulo 16 for p = 2). x and y cannot both be vectors or matrices.

The library syntax is agm(x,y,prec).

argument of the complex number x, such that -Pi < {arg}(x) <= Pi.

The library syntax is garg(x,prec).

principal branch of {sin}^{-1}(x), i.e.such that {Re(asin}(x)) belongs to [-Pi/2,Pi/2]. If x belongs to R and |x| > 1 then {asin}(x) is complex.

The library syntax is gasin(x,prec).

principal branch of {sinh}^{-1}(x), i.e.such that {Im(asinh}(x)) belongs to [-Pi/2,Pi/2].

The library syntax is gash(x,prec).

principal branch of {tan}^{-1}(x), i.e.such that {Re(atan}(x)) belongs to ]-Pi/2,Pi/2[.

The library syntax is gatan(x,prec).

principal branch of {tanh}^{-1}(x), i.e.such that {Im(atanh}(x)) belongs to ]-Pi/2,Pi/2]. If x belongs to R and |x| > 1 then {atanh}(x) is complex.

The library syntax is gath(x,prec).

Bernoulli number B_x, where B_0 = 1, B_1 = -1/2, B_2 = 1/6,..., expressed as a rational number. The argument x should be of type integer.

The library syntax is bernfrac(x).

Bernoulli number B_x, as bernfrac, but B_x is returned as a real number (with the current precision).

The library syntax is bernreal(x,prec).

creates a vector containing, as rational numbers, the Bernoulli numbers B_0, B_2,..., B_{2x}. This routine is obsolete. Use bernfrac instead each time you need a Bernoulli number in exact form.

Note: this routine is implemented using repeated independent calls to bernfrac, which is faster than the standard recursion in exact arithmetic. It is only kept for backward compatibility: it is not faster than individual calls to bernfrac, its output uses a lot of memory space, and coping with the index shift is awkward.

The library syntax is bernvec(x).

H^1-Bessel function of index nu and argument x.

The library syntax is hbessel1(nu,x,prec).

H^2-Bessel function of index nu and argument x.

The library syntax is hbessel2(nu,x,prec).

I-Bessel function of index nu and argument x. If x converts to a power series, the initial factor (x/2)^nu/Gamma(nu+1) is omitted (since it cannot be represented in PARI when nu is not integral).

The library syntax is ibessel(nu,x,prec).

J-Bessel function of index nu and argument x. If x converts to a power series, the initial factor (x/2)^nu/Gamma(nu+1) is omitted (since it cannot be represented in PARI when nu is not integral).

The library syntax is jbessel(nu,x,prec).

J-Bessel function of half integral index. More precisely, besseljh(n,x) computes J_{n+1/2}(x) where n must be of type integer, and x is any element of C. In the present version 2.3.1, this function is not very accurate when x is small.

The library syntax is jbesselh(n,x,prec).

K-Bessel function of index nu (which can be complex) and argument x. Only real and positive arguments x are allowed in the present version 2.3.1. If flag is equal to 1, uses another implementation of this function which is faster when x >> 1.

The library syntax is kbessel(nu,x,prec) and kbessel2(nu,x,prec) respectively.

N-Bessel function of index nu and argument x.

The library syntax is nbessel(nu,x,prec).

cosine of x.

The library syntax is gcos(x,prec).

hyperbolic cosine of x.

The library syntax is gch(x,prec).

cotangent of x.

The library syntax is gcotan(x,prec).

principal branch of the dilogarithm of x, i.e.analytic continuation of the power series log_2(x) = sum_{n >= 1}x^n/n^2.

The library syntax is dilog(x,prec).

exponential integral int_x^ oo (e^{-t})/(t)dt (x belongs to R)

If n is present, outputs the n-dimensional vector [ eint1(x),..., eint1(nx)] (x >= 0). This is faster than repeatedly calling eint1(i * x).

The library syntax is veceint1(x,n,prec). Also available is eint1(x,prec).

complementary error function (2/sqrtPi)int_x^ oo e^{-t^2}dt (x belongs to R).

The library syntax is erfc(x,prec).

Dedekind's eta function, without the q^{1/24}. This means the following: if x is a complex number with positive imaginary part, the result is prod_{n = 1}^ oo (1-q^n), where q = e^{2iPi x}. If x is a power series (or can be converted to a power series) with positive valuation, the result is prod_{n = 1}^ oo (1-x^n).

If flag = 1 and x can be converted to a complex number (i.e.is not a power series), computes the true eta function, including the leading q^{1/24}.

The library syntax is eta(x,prec).

exponential of x. p-adic arguments with positive valuation are accepted.

The library syntax is gexp(x,prec).

gamma function evaluated at the argument x+1/2.

The library syntax is ggamd(x,prec).

gamma function of x.

The library syntax is ggamma(x,prec).

U-confluent hypergeometric function with parameters a and b. The parameters a and b can be complex but the present implementation requires x to be positive.

The library syntax is hyperu(a,b,x,prec).

incomplete gamma function. The argument x and s are complex numbers (x must be a positive real number if s = 0). The result returned is int_x^ oo e^{-t}t^{s-1}dt. When y is given, assume (of course without checking!) that y = Gamma(s). For small x, this will speed up the computation.

The library syntax is incgam(s,x,prec) and incgam0(s,x,y,prec), respectively (an omitted y is coded as NULL).

complementary incomplete gamma function. The arguments x and s are complex numbers such that s is not a pole of Gamma and |x|/(|s|+1) is not much larger than 1 (otherwise the convergence is very slow). The result returned is int_0^x e^{-t}t^{s-1}dt.

The library syntax is incgamc(s,x,prec).

principal branch of the natural logarithm of x, i.e.such that {Im(log}(x)) belongs to ]-Pi,Pi]. The result is complex (with imaginary part equal to Pi) if x belongs to R and x < 0. In general, the algorithm uses the formula log(x) ~ (Pi)/(2{agm}(1, 4/s)) - m log 2, if s = x 2^m is large enough. (The result is exact to B bits provided s > 2^{B/2}.) At low accuracies, the series expansion near 1 is used.

p-adic arguments are also accepted for x, with the convention that log(p) = 0. Hence in particular exp(log(x))/x is not in general equal to 1 but to a (p-1)-th root of unity (or ±1 if p = 2) times a power of p.

The library syntax is glog(x,prec).

principal branch of the logarithm of the gamma function of x. This function is analytic on the complex plane with non-positive integers removed. Can have much larger arguments than gamma itself. The p-adic lngamma function is not implemented.

The library syntax is glngamma(x,prec).

one of the different polylogarithms, depending on flag:

If flag = 0 or is omitted: m^{th} polylogarithm of x, i.e.analytic continuation of the power series {Li}_m(x) = sum_{n >= 1}x^n/n^m (x < 1). Uses the functional equation linking the values at x and 1/x to restrict to the case |x| <= 1, then the power series when |x|^2 <= 1/2, and the power series expansion in log(x) otherwise.

Using flag, computes a modified m^{th} polylogarithm of x. We use Zagier's notations; let Re_m denotes Re or Im depending whether m is odd or even:

If flag = 1: compute ~ D_m(x), defined for |x| <= 1 by Re_m(sum_{k = 0}^{m-1} ((-log|x|)^k)/(k!){Li}_{m-k}(x) +((-log|x|)^{m-1})/(m!)log|1-x|).

If flag = 2: compute D_m(x), defined for |x| <= 1 by Re_m(sum_{k = 0}^{m-1}((-log|x|)^k)/(k!){Li}_{m-k}(x) -(1)/(2)((-log|x|)^m)/(m!)).

If flag = 3: compute P_m(x), defined for |x| <= 1 by Re_m(sum_{k = 0}^{m-1}(2^kB_k)/(k!)(log|x|)^k{Li}_{m-k}(x) -(2^{m-1}B_m)/(m!)(log|x|)^m).

These three functions satisfy the functional equation f_m(1/x) = (-1)^{m-1}f_m(x).

The library syntax is polylog0(m,x,flag,prec).

the psi-function of x, i.e.the logarithmic derivative Gamma'(x)/Gamma(x).

The library syntax is gpsi(x,prec).

sine of x.

The library syntax is gsin(x,prec).

hyperbolic sine of x.

The library syntax is gsh(x,prec).

square of x. This operation is not completely straightforward, i.e.identical to x * x, since it can usually be computed more efficiently (roughly one-half of the elementary multiplications can be saved). Also, squaring a 2-adic number increases its precision. For example,

? (1 + O(2^4))^2
 %1 = 1 + O(2^5)
 ? (1 + O(2^4)) * (1 + O(2^4))
 %2 = 1 + O(2^4)

Note that this function is also called whenever one multiplies two objects which are known to be identical, e.g.they are the value of the same variable, or we are computing a power.

? x = (1 + O(2^4)); x * x
 %3 = 1 + O(2^5)
 ? (1 + O(2^4))^4
 %4 = 1 + O(2^6)

(note the difference between %2 and %3 above).

The library syntax is gsqr(x).

principal branch of the square root of x, i.e.such that {Arg}({sqrt}(x)) belongs to ]-Pi/2, Pi/2], or in other words such that Re({sqrt}(x)) > 0 or Re({sqrt}(x)) = 0 and Im({sqrt}(x)) >= 0. If x belongs to R and x < 0, then the result is complex with positive imaginary part.

Intmod a prime and p-adics are allowed as arguments. In that case, the square root (if it exists) which is returned is the one whose first p-adic digit (or its unique p-adic digit in the case of intmods) is in the interval [0,p/2]. When the argument is an intmod a non-prime (or a non-prime-adic), the result is undefined.

The library syntax is gsqrt(x,prec).

principal branch of the nth root of x, i.e.such that {Arg}({sqrt}(x)) belongs to ]-Pi/n, Pi/n]. Intmod a prime and p-adics are allowed as arguments.

If z is present, it is set to a suitable root of unity allowing to recover all the other roots. If it was not possible, z is set to zero. In the case this argument is present and no square root exist, 0 is returned instead or raising an error.

? sqrtn(Mod(2,7), 2)
 %1 = Mod(4, 7)
 ? sqrtn(Mod(2,7), 2, &z); z
 %2 = Mod(6, 7)
 ? sqrtn(Mod(2,7), 3)
   *** sqrtn: nth-root does not exist in gsqrtn.
 ? sqrtn(Mod(2,7), 3,  &z)
 %2 = 0
 ? z
 %3 = 0

The following script computes all roots in all possible cases:

sqrtnall(x,n)=
 {
   local(V,r,z,r2);
   r = sqrtn(x,n, &z);
   if (!z, error("Impossible case in sqrtn"));
   if (type(x) == "t_INTMOD" || type(x)=="t_PADIC" ,
     r2 = r*z; n = 1;
     while (r2!=r, r2*=z;n++));
   V = vector(n); V[1] = r;
   for(i=2, n, V[i] = V[i-1]*z);
   V
 }
 addhelp(sqrtnall,"sqrtnall(x,n):compute the vector of nth-roots of x");

The library syntax is gsqrtn(x,n,&z,prec).

tangent of x.

The library syntax is gtan(x,prec).

hyperbolic tangent of x.

The library syntax is gth(x,prec).

Teichmüller character of the p-adic number x, i.e. the unique (p-1)-th root of unity congruent to x / p^{v_p(x)} modulo p.

The library syntax is teich(x).

Jacobi sine theta-function.

The library syntax is theta(q,z,prec).

k-th derivative at z = 0 of theta(q,z).

The library syntax is thetanullk(q,k,prec), where k is a long.

one of Weber's three f functions. If flag = 0, returns f(x) = exp(-iPi/24).eta((x+1)/2)/eta(x) {such that} j = (f^{24}-16)^3/f^{24}, where j is the elliptic j-invariant (see the function ellj). If flag = 1, returns f_1(x) = eta(x/2)/eta(x) {such that} j = (f_1^{24}+16)^3/f_1^{24}. Finally, if flag = 2, returns f_2(x) = sqrt{2}eta(2x)/eta(x) {such that} j = (f_2^{24}+16)^3/f_2^{24}. Note the identities f^8 = f_1^8+f_2^8 and ff_1f_2 = sqrt2.

The library syntax is weber0(x,flag,prec). Associated to the various values of flag, the following functions are also available: werberf(x,prec), werberf1(x,prec) or werberf2(x,prec).

For s a complex number, Riemann's zeta function zeta(s) = sum_{n >= 1}n^{-s}, computed using the Euler-Maclaurin summation formula, except when s is of type integer, in which case it is computed using Bernoulli numbers for s <= 0 or s > 0 and even, and using modular forms for s > 0 and odd.

For s a p-adic number, Kubota-Leopoldt zeta function at s, that is the unique continuous p-adic function on the p-adic integers that interpolates the values of (1 - p^{-k}) zeta(k) at negative integers k such that k = 1 (mod p-1) (resp. k is odd) if p is odd (resp. p = 2).

The library syntax is gzeta(s,prec).