### Standard monadic or dyadic operators

#### +/-

The expressions `+`x and `-`x refer to monadic operators (the first does nothing, the second negates x).

The library syntax is gneg(x) for `-`x.

#### +

, `-`: The expression x `+` y is the sum and x `-` y is the difference of x and y. Among the prominent impossibilities are addition/subtraction between a scalar type and a vector or a matrix, between vector/matrices of incompatible sizes and between an intmod and a real number.

The library syntax is gadd(x,y) x `+` y, `gsub(x,y)` for x `-` y.

#### *

The expression x `*` y is the product of x and y. Among the prominent impossibilities are multiplication between vector/matrices of incompatible sizes, between an intmod and a real number. Note that because of vector and matrix operations, `*` is not necessarily commutative. Note also that since multiplication between two column or two row vectors is not allowed, to obtain the scalar product of two vectors of the same length, you must multiply a line vector by a column vector, if necessary by transposing one of the vectors (using the operator `~` or the function `mattranspose`, see Section [Label: se:linear_algebra]).

If x and y are binary quadratic forms, compose them. See also `qfbnucomp` and `qfbnupow`.

The library syntax is gmul(x,y) for x `*` y. Also available is `gsqr(x)` for x `*` x (faster of course!).

#### /

The expression x `/` y is the quotient of x and y. In addition to the impossibilities for multiplication, note that if the divisor is a matrix, it must be an invertible square matrix, and in that case the result is x*y^{-1}. Furthermore note that the result is as exact as possible: in particular, division of two integers always gives a rational number (which may be an integer if the quotient is exact) and not the Euclidean quotient (see x `\` y for that), and similarly the quotient of two polynomials is a rational function in general. To obtain the approximate real value of the quotient of two integers, add `0.` to the result; to obtain the approximate p-adic value of the quotient of two integers, add `O(p^k)` to the result; finally, to obtain the Taylor series expansion of the quotient of two polynomials, add `O(X^k)` to the result or use the `taylor` function (see Section [Label: se:taylor]).

The library syntax is gdiv(x,y) for x `/` y.

#### \

The expression `x \y` is the \idx{Euclidean quotient} of x and y. If y is a real scalar, this is defined as `floor(x/y)` if y > 0, and `ceil(x/y)` if y < 0 and the division is not exact. Hence the remainder `x - (x\y)*y` is in [0, |y|[.

Note that when y is an integer and x a polynomial, y is first promoted to a polynomial of degree 0. When x is a vector or matrix, the operator is applied componentwise.

The library syntax is gdivent(x,y) for x `\` y.

#### \/

The expression x `\/` y evaluates to the rounded Euclidean quotient of x and y. This is the same as `x \y` except for scalar division: the quotient is such that the corresponding remainder is smallest in absolute value and in case of a tie the quotient closest to + oo is chosen (hence the remainder would belong to ]-|y|/2, |y|/2]).

When x is a vector or matrix, the operator is applied componentwise.

The library syntax is gdivround(x,y) for x `\/` y.

#### divrem(x,y,{v})

creates a column vector with two components, the first being the Euclidean quotient (`x \y`), the second the Euclidean remainder (`x - (x\y)*y`), of the division of x by y. This avoids the need to do two divisions if one needs both the quotient and the remainder. If v is present, and x, y are multivariate polynomials, divide with respect to the variable v.

Beware that `divrem(x,y)[2]` is in general not the same as `x % y`; there is no operator to obtain it in GP:

    ? divrem(1/2, 3)[2]
     %1 = 1/2
     ? (1/2) % 3
     %2 = 2
     ? divrem(Mod(2,9), 3)[2]
       ***   forbidden division t_INTMOD \ t_INT.
     ? Mod(2,9) % 6
     %3 = Mod(2,3)

The library syntax is divrem(x,y,v),where v is a `long`. Also available as `gdiventres(x,y)` when v is not needed.

#### ^

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.

#### bittest(x,n)

outputs the n^{{th}} bit of x starting from the right (i.e.the coefficient of 2^n in the binary expansion of x). The result is 0 or 1. To extract several bits at once as a vector, pass a vector for n.

See Section [Label: se:bitand] for the behaviour at negative arguments.

The library syntax is bittest(x,n), where n and the result are `long`s.

#### shift(x,n)

or x `<<` n ( = x `>>` (-n)): shifts x componentwise left by n bits if n `>=` 0 and right by |n| bits if n < 0. A left shift by n corresponds to multiplication by 2^n. A right shift of an integer x by |n| corresponds to a Euclidean division of x by 2^{|n|} with a remainder of the same sign as x, hence is not the same (in general) as x `\` 2^n.

The library syntax is gshift(x,n) where n is a `long`.

#### shiftmul(x,n)

multiplies x by 2^n. The difference with `shift` is that when n < 0, ordinary division takes place, hence for example if x is an integer the result may be a fraction, while for shifts Euclidean division takes place when n < 0 hence if x is an integer the result is still an integer.

The library syntax is gmul2n(x,n) where n is a `long`.

#### Comparison and boolean operators

. The six standard comparison operators `<=` , `<` , `>=` , `>` , `==` , `!=` are available in GP, and in library mode under the names `gle`, `glt`, `gge`, `ggt`, `geq`, `gne` respectively. The library syntax is co(x,y), where co is the comparison operator. The result is 1 (as a `GEN`) if the comparison is true, 0 (as a `GEN`) if it is false. For the purpose of comparison, `t_STR` objects are strictly larger than any other non-string type; two `t_STR` objects are compared using the standard lexicographic order.

The standard boolean functions `||` (inclusive or), `&&` (and) and `!` (not) are also available, and the library syntax is `gor(x,y)`, `gand(x,y)` and `gnot(x)` respectively.

In library mode, it is in fact usually preferable to use the two basic functions which are `gcmp(x,y)` which gives the sign (1, 0, or -1) of x-y, where x and y must be in R, and `gequal(x,y)` which can be applied to any two PARI objects x and y and gives 1 (i.e.true) if they are equal (but not necessarily identical), 0 (i.e.false) otherwise. Comparisons to special constants are implemented and should be used instead of `gequal`: `gcmp0(x)` (x == 0 ?), `gcmp1(x)` (x == 1 ?), and `gcmp_1(x)` (x == -1 ?).

Note that `gcmp0`(x) tests whether x is equal to zero, even if x is not an exact object. To test whether x is an exact object which is equal to zero, one must use `isexactzero(x)`.

Also note that the `gcmp` and `gequal` functions return a C-integer, and not a `GEN` like `gle` etc.

GP accepts the following synonyms for some of the above functions: since we thought it might easily lead to confusion, we don't use the customary C operators for bitwise `and` or bitwise `or` (use `bitand` or `bitor`), hence `|` and `&` are accepted as\sidx{bitwise and} synonyms of `||` and `&&` respectively. Also, `< >` is accepted as a synonym for `!=` . On the other hand, `=` is definitely not a synonym for `==` since it is the assignment statement.

#### lex(x,y)

gives the result of a lexicographic comparison between x and y (as -1, 0 or 1). This is to be interpreted in quite a wide sense: It is admissible to compare objects of different types (scalars, vectors, matrices), provided the scalars can be compared, as well as vectors/matrices of different lengths. The comparison is recursive.

In case all components are equal up to the smallest length of the operands, the more complex is considered to be larger. More precisely, the longest is the largest; when lengths are equal, we have matrix > vector > scalar. For example:

    ? lex([1,3], [1,2,5])
     %1 = 1
     ? lex([1,3], [1,3,-1])
     %2 = -1
     ? lex([1], [[1]])
     %3 = -1
     ? lex([1], [1]~)
     %4 = 0

The library syntax is lexcmp(x,y).

#### sign(x)

sign (0, 1 or -1) of x, which must be of type integer, real or fraction.

The library syntax is gsigne(x). The result is a `long`.

#### max(x,y)

and `min(x,y)`: creates the maximum and minimum of x and y when they can be compared.

The library syntax is gmax(x,y) and `gmin(x,y)`.

#### vecmax(x)

if x is a vector or a matrix, returns the maximum of the elements of x, otherwise returns a copy of x. Error if x is empty.

The library syntax is vecmax(x).

#### vecmin(x)

if x is a vector or a matrix, returns the minimum of the elements of x, otherwise returns a copy of x. Error if x is empty.

The library syntax is vecmin(x).