The expressions `+`

x and `-`

x refer
to monadic operators (the first does nothing, the second negates x).

The library syntax is `GEN `

for **gneg**(GEN x)`-`

x.

The expression x `+`

y is the sum of x and y.
Addition between a scalar type x and a `t_COL`

or `t_MAT`

y returns
respectively [y[1] + x, y[2],...] and y + x {Id}. Other additions
between a scalar type and a vector or a matrix, or between vector/matrices of
incompatible sizes are forbidden.

The library syntax is `GEN `

.**gadd**(GEN x, GEN y)

The expression x `+`

y is the sum of x and y.
Addition between a scalar type x and a `t_COL`

or `t_MAT`

y returns
respectively [y[1] + x, y[2],...] and y + x {Id}. Other additions
between a scalar type and a vector or a matrix, or between vector/matrices of
incompatible sizes are forbidden.

The library syntax is `GEN `

.**gadd**(GEN x, GEN 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 a `t_INTMOD`

or `t_PADIC`

Restricted to scalars, `*`

is commutative; because of vector and matrix
operations, it is not commutative in general.

Multiplication between two `t_VEC`

s or two `t_COL`

s is not
allowed; to take the scalar product of two vectors of the same length,
transpose one of the vectors (using the operator `~`

or the function
`mattranspose`

, see Section [**Label: se:linear_algebra**]) and multiply a line vector
by a column vector:

? a = [1,2,3]; ? a * a *** at top-level: a*a *** ^-- *** _*_: forbidden multiplication t_VEC * t_VEC. ? a * a~ %2 = 14

If x,y are binary quadratic forms, compose them; see also
`qfbnucomp`

and `qfbnupow`

. If x,y are `t_VECSMALL`

of the same
length, understand them as permutations and compose them.

The library syntax is `GEN `

for x **gmul**(GEN x, GEN y)`*`

y.
Also available is `GEN `

for x **gsqr**(GEN x)`*`

x.

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 `GEN `

for x **gdiv**(GEN x, GEN y)`/`

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 `GEN `

for x **gdivent**(GEN x, GEN y)`\`

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 `GEN `

for x **gdivround**(GEN x, GEN y)`\/`

y.

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) *** at top-level: 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) *** at top-level: 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); *** at top-level: Mod(a,b)^(-1) *** ^----- *** _^_: impossible inverse modulo: Mod(0, 4).

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**/4**Z**, 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) = { my(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 `GEN `

for x{**gpow**(GEN x, GEN n, long prec)`^`

}n.

Gives the result of a comparison between arbitrary objects x and y
(as -1, 0 or 1). The underlying order relation is transitive,
the function returns 0 if and only if x ` == = `

y, and its
restriction to integers coincides with the customary one. Besides that,
it has no useful mathematical meaning.

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:

? cmp(1, 2) %1 = -1 ? cmp(2, 1) %2 = 1 ? cmp(1, 1.0) \\ note that 1 == 1.0, but (1===1.0) is false. %3 = -1 ? cmp(x + Pi, []) %4 = -1This function is mostly useful to handle sorted lists or vectors of arbitrary objets. For instance, if v is a vector, the construction

`vecsort(v, cmp)`

is equivalent to `Set(v)`

.
The library syntax is `GEN `

.**cmp_universal**(GEN x, GEN y)

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`

; no GP operator corresponds to it:

? divrem(1/2, 3)[2] %1 = 1/2 ? (1/2) % 3 %2 = 2 ? divrem(Mod(2,9), 3)[2] *** at top-level: divrem(Mod(2,9),3)[2 *** ^-------------------- *** forbidden division t_INTMOD \ t_INT. ? Mod(2,9) % 6 %3 = Mod(2,3)

The library syntax is `GEN `

, where **divrem**(GEN x, GEN y, long v = -1)`v`

is a variable number.
Also available is `GEN `

when v is
not needed.**gdiventres**(GEN x, GEN 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 `GEN `

.**lexcmp**(GEN x, GEN y)

Creates the maximum of x and y when they can be compared.

The library syntax is `GEN `

.**gmax**(GEN x, GEN y)

Creates the maximum of x and y when they can be compared.

The library syntax is `GEN `

.**gmax**(GEN x, GEN y)

Shifts x componentwise left by n bits if n `>=`

0 and right by |n|
bits if n < 0. May be abbreviated as x ` << `

n or x ` >> `

(-n).
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 `GEN `

.**gshift**(GEN x, long 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 `GEN `

.**gmul2n**(GEN x, long n)

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

The library syntax is `GEN `

.**gsigne**(GEN x)

If x is a vector or a matrix, returns the largest entry of x, otherwise returns a copy of x. Error if x is empty.

If v is given, set it to the index of a largest entry (indirect maximum), when x is a vector. If x is a matrix, set v to coordinates [i,j] such that x[i,j] is a largest entry. This flag is ignored if x is not a vector or matrix.

? vecmax([10, 20, -30, 40]) %1 = 40 ? vecmax([10, 20, -30, 40], &v); v %2 = 4 ? vecmax([10, 20; -30, 40], &v); v %3 = [2, 2]

The library syntax is `GEN `

.
Also available is **vecmax0**(GEN x, GEN *v = NULL)`GEN `

.**vecmax**(GEN x)

If x is a vector or a matrix, returns the smallest entry of x, otherwise returns a copy of x. Error if x is empty.

If v is given, set it to the index of a smallest entry (indirect minimum), when x is a vector. If x is a matrix, set v to coordinates [i,j] such that x[i,j] is a smallest entry. This is ignored if x is not a vector or matrix.

? vecmin([10, 20, -30, 40]) %1 = -30 ? vecmin([10, 20, -30, 40], &v); v %2 = 3 ? vecmin([10, 20; -30, 40], &v); v %3 = [2, 1]

The library syntax is `GEN `

.
Also available is **vecmin0**(GEN x, GEN *v = NULL)`GEN `

.**vecmin**(GEN x)

The six
standard comparison operators ` <= `

, ` < `

, ` >= `

, ` > `

,
` == `

, ` != `

are available in GP. The result is 1 if the comparison is
true, 0 if it is false. The operator ` == `

is quite liberal : for
instance, the integer 0, a 0 polynomial, and a vector with 0 entries are all
tested equal.

The extra operator ` == = `

tests whether two objects are identical and is
much stricter than ` == `

: objects of different type or length are never
identical.

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.

GP accepts ` < > `

as a synonym for ` != `

. On the other hand, ` = `

is
definitely *not* a synonym for ` == `

: it is the assignment statement.

The standard boolean operators `||`

(inclusive or), `&&`

(and) and `!`

(not) are also available.