Loosely speaking, an operator is a function, usually
attached to basic arithmetic operations, whose name contains only
non-alphanumeric characters. For instance `+`

or `-`

, but also
` = `

or ` += `

, or even `[ ]`

(the selection operator). As all
functions, operators take arguments, and return a value; *assignment*
operators also have side effects: besides returning a value, they change the
value of some variable.

Each operator has a fixed and unchangeable priority, which means that, in a given expression, the operations with the highest priority is performed first. Unless mentioned otherwise, operators at the same priority level are left-associative (performed from left to right), unless they are assignments, in which case they are right-associative. Anything enclosed between parenthesis is considered a complete subexpression, and is resolved recursively, independently of the surrounding context. For instance,

a + b + c --> (a + b) + c \\ left-associative a = b = c --> a = (b = c) \\ right-associative

Assuming that *op*_{1}, *op*_{2}, *op*_{3} are
binary operators with increasing priorities (think of `+`

,
`*`

, `^`

),
x *op*_{1} y *op*_{2} z *op*_{2} x *op*_{3} y is
equivalent to x *op*_{1} ((y *op*_{2} z) *op*_{2}
(x *op*_{3} y)).

GP contains many different operators, either unary (having only
one argument) or binary, plus a few special selection operators. Unary
operators are defined as either *prefix* or *postfix*, meaning
that they respectively precede (*op* x) and follow (x *op*) their
single argument. Some symbols are syntactically correct in both positions,
like `!`

, but then represent different operators: the `!`

symbol
represents the negation and factorial operators when in prefix and postfix
position respectively. Binary operators all use the (infix) syntax
x *op* y.

Most operators are standard (`+`

, `%`

, ` = `

), some are
borrowed from the C language (`++`

, ` << `

), and a few are
specific to GP (`\`

, `#`

). Beware that some GP operators differ
slightly from their C counterparts. For instance, GP's postfix `++`

returns the *new* value, like the prefix `++`

of C, and the binary
shifts ` << `

, ` >> `

have a priority which is different from (higher
than) that of their C counterparts. When in doubt, just surround everything
by parentheses; besides, your code will be more legible.

Here is the list of available operators, ordered by decreasing
priority, binary and left-associative unless mentioned otherwise. An
expression is an *lvalue* if something can be assigned to it. (The name
comes from left-value, to the left of a ` = `

operator; e.g.
`x`

, or `v[1]`

are lvalues, but `x + 1`

is not.)

***** Priority 14

`:`

as in `x:small`

, is used to indicate to the GP2C compiler that the
variable on the left-hand side always contains objects of the type specified
on the right hand-side (here, a small integer) in order to produce more
efficient or more readable C code. This is ignored by GP.

***** Priority 13
`( )`

is the function call operator. If f is a closure and *args*
is a comma-separated list of arguments (possibly empty),
f`(`

evaluates f on those arguments.*args*)

***** Priority 12

`++`

and `--`

(unary, postfix): if x is an `lvalue`

,
`x++`

assigns the value x+1 to x, then returns the new value of
x. This corresponds to the C statement `++x`

: there is no prefix
`++`

operator in GP. `x--`

does the same with x-1. These
operators are not associative, i.e. `x++++`

is invalid, since
`x++`

is not an lvalue.

***** Priority 11

`.`

*member* (unary, postfix): `x.`

extracts
*member**member* from structure x (see Section se:member).

`[ ]`

is the selection operator. `x[i]`

returns the i-th
component of vector x; `x[i,j]`

, `x[,j]`

and
`x[i,]`

respectively return the entry of coordinates (i,j), the
j-th column, and the i-th row of matrix x. If the assignment operator
(` = `

) immediately follows a sequence of selections, it assigns its right
hand side to the selected component. E.g `x[1][1] = 0`

is valid; but
beware that `(x[1])[1] = 0`

is not (because the parentheses force the
complete evaluation of `x[1]`

, and the result is not modifiable).

***** Priority 10

`'`

(unary, postfix): derivative with respect to the main variable.
If f is a function (`t_CLOSURE`

), f' is allowed and defines a new
function, which will perform numerical derivation when evaluated
at a scalar x; this is defined as (f(x+ϵ) - f(x-ϵ)) /
2ϵ for a suitably small epsilon depending on current precision.

? (x^2 + y*x + y^2)' \\ derive with respect to main variable`x`

%1 = 2*x + y ? SIN = cos' %2 = cos' ? SIN(Pi/6) \\ numerical derivation %3 = -0.5000000000000000000000000000 ? cos'(Pi/6) \\ works directly: no need for intermediate`SIN`

%4 = -0.5000000000000000000000000000

`~`

(unary, postfix): vector/matrix transpose.

`!`

(unary, postfix): factorial. x`!`

= x(x-1)...1.

`!`

(unary, prefix): logical *not*. `!x`

returns 1 if x is
equal to 0 (specifically, if `gequal0(x) == 1`

), and 0 otherwise.

***** Priority 9

`#`

(unary, prefix): cardinality; `#x`

returns `length(x)`

.

***** Priority 8

`^`

: powering. This operator is right associative:
`2^3^4`

is understood as `2^(3^4)`

.

***** Priority 7

`+`

, `-`

(unary, prefix): `-`

toggles the sign of its argument,
`+`

has no effect whatsoever.

***** Priority 6

`*`

: multiplication.

`/`

: exact division (`3/2`

yields 3/2, not 1.5).

`\`

, `%`

: Euclidean quotient and remainder, i.e. if x =
qy + r, then `x `

= q, `\ `

y`x%y`

= r. If x and y
are scalars, then q is an integer and r satisfies 0 ≤ r < |y|; if x
and y are polynomials, then q and r are polynomials such that deg r <
deg y and the leading terms of r and x have the same sign.

`\/`

: rounded Euclidean quotient for integers (rounded towards
+ oo when the exact quotient would be a half-integer).

` << `

, ` >> `

: left and right binary shift. By definition,
`x << n`

= x * 2^n if n > 0, and `truncate`

(x 2^{-n}) otherwise.
Right shift is defined by `x >> n`

= `x << (-n)`

.

***** Priority 5

`+`

, `-`

: addition/subtraction.

***** Priority 4

` < `

, ` > `

, ` <= `

, ` >= `

: the usual comparison operators,
returning 1 for `true`

and 0 for `false`

. For instance,
`x <= 1`

returns 1 if x ≤ 1 and 0 otherwise.

` <> `

, ` != `

: test for (exact) inequality.

` == `

: test for (exact) equality. `t_QFR`

having the same coefficients
but a different distance component are tested as equal.

` === `

: test whether two objects are identical component-wise. This is
stricter than ` == `

: for instance, the integer 0, a 0 polynomial or a
vector with 0 entries, are all tested equal by ` == `

, but they are not
identical.

***** Priority 3

`&&`

: logical *and*.

`||`

: logical (inclusive) *or*. Any sequence of logical
*or* and *and* operations is evaluated from left to right,
and aborted as soon as the final truth value is known. Thus, for instance,

x == 0 || test(1/x)

will never produce an error since `test(1/x)`

is not even evaluated
when the first test is true (hence the final truth value is true). Similarly

type(p) == "t_INT" && isprime(p)

does not evaluate `isprime(p)`

if `p`

is not an integer.

***** Priority 2

` = `

(assignment, *lvalue* ` = `

*expr*). The result of
`x = y`

is the value of the expression y, which is also assigned to
the variable `x`

. This assignment operator is right-associative. This is
*not* the equality test operator; a statement like `x = 1`

is always
true (i.e. non-zero), and sets `x`

to 1; the equality test would be
`x == 1`

. The right hand side of the assignment operator is evaluated
before the left hand side.

It is crucial that the left hand-side be an *lvalue* there, it avoids
ambiguities in expressions like `1 + x = 1`

. The latter evaluates as
`1 + (x = 1)`

, not as `(1 + x) = 1`

, even though the priority of
` = `

is lower than the priority of `+`

: `1 + x`

is not an lvalue.

If the expression cannot be parsed in a way where the left hand side is an lvalue, raise an error.

? x + 1 = 1 *** syntax error, unexpected '=', expecting $end or ';': x+1=1 *** ^--

Assignment to all variables is a deep copy: after x = y, modifying a
component of y will *not* change x. To globals it is a full copy to
the heap. Space used by local objects in local variables is released when
they go out of scope or when the value changes in local scope. Assigning a
value to a vector or matrix entry allocates room for that entry only (on the
heap).

, where *op* = *op* is any binary operator
among `+`

, `-`

, `*`

, `%`

, `/`

, `\`

, `\/`

,
` << `

, or
` >> `

(composed assignment *lvalue* *op*` = `

*expr*).
The expression `x `

assigns (*op* = y`x`

*op* y)
to `x`

, and returns the new value of `x`

. The result is *not*
an *lvalue*; thus

(x += 2) = 3

is invalid. These assignment operators are right-associative:

? x = 'x; x += x *= 2 %1 = 3*x

***** Priority 1
`- > `

(function definition): `(`

returns a
function object, of type *vars*)- > *expr*`t_CLOSURE`

.

**Remark.** Use the *op*` = `

operators as often as possible
since they make complex assignments more legible. Compare

v[i+j-1] = v[i+j-1] + 1 --> v[i+j-1]++ M[i,i+j] = M[i,i+j] * 2 --> M[i,i+j] *= 2

**Remark about efficiency.** the operators `++`

and `--`

are usually a little more efficient than their expended
counterpart:

? N = 10^7; ? i = 0; for(k = 1, N, i=i+1) time = 949 ms. ? i = 0; for(k = 1, N, i++) time = 933 ms.

On the other hand, this is not the case for the
*op*` = `

operators which may even be a little less efficient:

? i = 0; for(k = 1, N, i=i+10) time = 949 ms. ? i = 0; for(k = 1, N, i+=10) time = 1,064 ms.

Loosely speaking, an operator is a function, usually
attached to basic arithmetic operations, whose name contains only
non-alphanumeric characters. For instance `+`

or `-`

, but also
` = `

or ` += `

, or even `[ ]`

(the selection operator). As all
functions, operators take arguments, and return a value; *assignment*
operators also have side effects: besides returning a value, they change the
value of some variable.

Each operator has a fixed and unchangeable priority, which means that, in a given expression, the operations with the highest priority is performed first. Unless mentioned otherwise, operators at the same priority level are left-associative (performed from left to right), unless they are assignments, in which case they are right-associative. Anything enclosed between parenthesis is considered a complete subexpression, and is resolved recursively, independently of the surrounding context. For instance,

a + b + c --> (a + b) + c \\ left-associative a = b = c --> a = (b = c) \\ right-associative

Assuming that *op*_{1}, *op*_{2}, *op*_{3} are
binary operators with increasing priorities (think of `+`

,
`*`

, `^`

),
x *op*_{1} y *op*_{2} z *op*_{2} x *op*_{3} y is
equivalent to x *op*_{1} ((y *op*_{2} z) *op*_{2}
(x *op*_{3} y)).

GP contains many different operators, either unary (having only
one argument) or binary, plus a few special selection operators. Unary
operators are defined as either *prefix* or *postfix*, meaning
that they respectively precede (*op* x) and follow (x *op*) their
single argument. Some symbols are syntactically correct in both positions,
like `!`

, but then represent different operators: the `!`

symbol
represents the negation and factorial operators when in prefix and postfix
position respectively. Binary operators all use the (infix) syntax
x *op* y.

Most operators are standard (`+`

, `%`

, ` = `

), some are
borrowed from the C language (`++`

, ` << `

), and a few are
specific to GP (`\`

, `#`

). Beware that some GP operators differ
slightly from their C counterparts. For instance, GP's postfix `++`

returns the *new* value, like the prefix `++`

of C, and the binary
shifts ` << `

, ` >> `

have a priority which is different from (higher
than) that of their C counterparts. When in doubt, just surround everything
by parentheses; besides, your code will be more legible.

Here is the list of available operators, ordered by decreasing
priority, binary and left-associative unless mentioned otherwise. An
expression is an *lvalue* if something can be assigned to it. (The name
comes from left-value, to the left of a ` = `

operator; e.g.
`x`

, or `v[1]`

are lvalues, but `x + 1`

is not.)

***** Priority 14

`:`

as in `x:small`

, is used to indicate to the GP2C compiler that the
variable on the left-hand side always contains objects of the type specified
on the right hand-side (here, a small integer) in order to produce more
efficient or more readable C code. This is ignored by GP.

***** Priority 13
`( )`

is the function call operator. If f is a closure and *args*
is a comma-separated list of arguments (possibly empty),
f`(`

evaluates f on those arguments.*args*)

***** Priority 12

`++`

and `--`

(unary, postfix): if x is an `lvalue`

,
`x++`

assigns the value x+1 to x, then returns the new value of
x. This corresponds to the C statement `++x`

: there is no prefix
`++`

operator in GP. `x--`

does the same with x-1. These
operators are not associative, i.e. `x++++`

is invalid, since
`x++`

is not an lvalue.

***** Priority 11

`.`

*member* (unary, postfix): `x.`

extracts
*member**member* from structure x (see Section se:member).

`[ ]`

is the selection operator. `x[i]`

returns the i-th
component of vector x; `x[i,j]`

, `x[,j]`

and
`x[i,]`

respectively return the entry of coordinates (i,j), the
j-th column, and the i-th row of matrix x. If the assignment operator
(` = `

) immediately follows a sequence of selections, it assigns its right
hand side to the selected component. E.g `x[1][1] = 0`

is valid; but
beware that `(x[1])[1] = 0`

is not (because the parentheses force the
complete evaluation of `x[1]`

, and the result is not modifiable).

***** Priority 10

`'`

(unary, postfix): derivative with respect to the main variable.
If f is a function (`t_CLOSURE`

), f' is allowed and defines a new
function, which will perform numerical derivation when evaluated
at a scalar x; this is defined as (f(x+ϵ) - f(x-ϵ)) /
2ϵ for a suitably small epsilon depending on current precision.

? (x^2 + y*x + y^2)' \\ derive with respect to main variable`x`

%1 = 2*x + y ? SIN = cos' %2 = cos' ? SIN(Pi/6) \\ numerical derivation %3 = -0.5000000000000000000000000000 ? cos'(Pi/6) \\ works directly: no need for intermediate`SIN`

%4 = -0.5000000000000000000000000000

`~`

(unary, postfix): vector/matrix transpose.

`!`

(unary, postfix): factorial. x`!`

= x(x-1)...1.

`!`

(unary, prefix): logical *not*. `!x`

returns 1 if x is
equal to 0 (specifically, if `gequal0(x) == 1`

), and 0 otherwise.

***** Priority 9

`#`

(unary, prefix): cardinality; `#x`

returns `length(x)`

.

***** Priority 8

`^`

: powering. This operator is right associative:
`2^3^4`

is understood as `2^(3^4)`

.

***** Priority 7

`+`

, `-`

(unary, prefix): `-`

toggles the sign of its argument,
`+`

has no effect whatsoever.

***** Priority 6

`*`

: multiplication.

`/`

: exact division (`3/2`

yields 3/2, not 1.5).

`\`

, `%`

: Euclidean quotient and remainder, i.e. if x =
qy + r, then `x `

= q, `\ `

y`x%y`

= r. If x and y
are scalars, then q is an integer and r satisfies 0 ≤ r < |y|; if x
and y are polynomials, then q and r are polynomials such that deg r <
deg y and the leading terms of r and x have the same sign.

`\/`

: rounded Euclidean quotient for integers (rounded towards
+ oo when the exact quotient would be a half-integer).

` << `

, ` >> `

: left and right binary shift. By definition,
`x << n`

= x * 2^n if n > 0, and `truncate`

(x 2^{-n}) otherwise.
Right shift is defined by `x >> n`

= `x << (-n)`

.

***** Priority 5

`+`

, `-`

: addition/subtraction.

***** Priority 4

` < `

, ` > `

, ` <= `

, ` >= `

: the usual comparison operators,
returning 1 for `true`

and 0 for `false`

. For instance,
`x <= 1`

returns 1 if x ≤ 1 and 0 otherwise.

` <> `

, ` != `

: test for (exact) inequality.

` == `

: test for (exact) equality. `t_QFR`

having the same coefficients
but a different distance component are tested as equal.

` === `

: test whether two objects are identical component-wise. This is
stricter than ` == `

: for instance, the integer 0, a 0 polynomial or a
vector with 0 entries, are all tested equal by ` == `

, but they are not
identical.

***** Priority 3

`&&`

: logical *and*.

`||`

: logical (inclusive) *or*. Any sequence of logical
*or* and *and* operations is evaluated from left to right,
and aborted as soon as the final truth value is known. Thus, for instance,

x == 0 || test(1/x)

will never produce an error since `test(1/x)`

is not even evaluated
when the first test is true (hence the final truth value is true). Similarly

type(p) == "t_INT" && isprime(p)

does not evaluate `isprime(p)`

if `p`

is not an integer.

***** Priority 2

` = `

(assignment, *lvalue* ` = `

*expr*). The result of
`x = y`

is the value of the expression y, which is also assigned to
the variable `x`

. This assignment operator is right-associative. This is
*not* the equality test operator; a statement like `x = 1`

is always
true (i.e. non-zero), and sets `x`

to 1; the equality test would be
`x == 1`

. The right hand side of the assignment operator is evaluated
before the left hand side.

It is crucial that the left hand-side be an *lvalue* there, it avoids
ambiguities in expressions like `1 + x = 1`

. The latter evaluates as
`1 + (x = 1)`

, not as `(1 + x) = 1`

, even though the priority of
` = `

is lower than the priority of `+`

: `1 + x`

is not an lvalue.

If the expression cannot be parsed in a way where the left hand side is an lvalue, raise an error.

? x + 1 = 1 *** syntax error, unexpected '=', expecting $end or ';': x+1=1 *** ^--

Assignment to all variables is a deep copy: after x = y, modifying a
component of y will *not* change x. To globals it is a full copy to
the heap. Space used by local objects in local variables is released when
they go out of scope or when the value changes in local scope. Assigning a
value to a vector or matrix entry allocates room for that entry only (on the
heap).

, where *op* = *op* is any binary operator
among `+`

, `-`

, `*`

, `%`

, `/`

, `\`

, `\/`

,
` << `

, or
` >> `

(composed assignment *lvalue* *op*` = `

*expr*).
The expression `x `

assigns (*op* = y`x`

*op* y)
to `x`

, and returns the new value of `x`

. The result is *not*
an *lvalue*; thus

(x += 2) = 3

is invalid. These assignment operators are right-associative:

? x = 'x; x += x *= 2 %1 = 3*x

***** Priority 1
`- > `

(function definition): `(`

returns a
function object, of type *vars*)- > *expr*`t_CLOSURE`

.

**Remark.** Use the *op*` = `

operators as often as possible
since they make complex assignments more legible. Compare

v[i+j-1] = v[i+j-1] + 1 --> v[i+j-1]++ M[i,i+j] = M[i,i+j] * 2 --> M[i,i+j] *= 2

**Remark about efficiency.** the operators `++`

and `--`

are usually a little more efficient than their expended
counterpart:

? N = 10^7; ? i = 0; for(k = 1, N, i=i+1) time = 949 ms. ? i = 0; for(k = 1, N, i++) time = 933 ms.

On the other hand, this is not the case for the
*op*` = `

operators which may even be a little less efficient:

? i = 0; for(k = 1, N, i=i+10) time = 949 ms. ? i = 0; for(k = 1, N, i+=10) time = 1,064 ms.

Loosely speaking, an operator is a function, usually
attached to basic arithmetic operations, whose name contains only
non-alphanumeric characters. For instance `+`

or `-`

, but also
` = `

or ` += `

, or even `[ ]`

(the selection operator). As all
functions, operators take arguments, and return a value; *assignment*
operators also have side effects: besides returning a value, they change the
value of some variable.

Each operator has a fixed and unchangeable priority, which means that, in a given expression, the operations with the highest priority is performed first. Unless mentioned otherwise, operators at the same priority level are left-associative (performed from left to right), unless they are assignments, in which case they are right-associative. Anything enclosed between parenthesis is considered a complete subexpression, and is resolved recursively, independently of the surrounding context. For instance,

a + b + c --> (a + b) + c \\ left-associative a = b = c --> a = (b = c) \\ right-associative

Assuming that *op*_{1}, *op*_{2}, *op*_{3} are
binary operators with increasing priorities (think of `+`

,
`*`

, `^`

),
x *op*_{1} y *op*_{2} z *op*_{2} x *op*_{3} y is
equivalent to x *op*_{1} ((y *op*_{2} z) *op*_{2}
(x *op*_{3} y)).

GP contains many different operators, either unary (having only
one argument) or binary, plus a few special selection operators. Unary
operators are defined as either *prefix* or *postfix*, meaning
that they respectively precede (*op* x) and follow (x *op*) their
single argument. Some symbols are syntactically correct in both positions,
like `!`

, but then represent different operators: the `!`

symbol
represents the negation and factorial operators when in prefix and postfix
position respectively. Binary operators all use the (infix) syntax
x *op* y.

Most operators are standard (`+`

, `%`

, ` = `

), some are
borrowed from the C language (`++`

, ` << `

), and a few are
specific to GP (`\`

, `#`

). Beware that some GP operators differ
slightly from their C counterparts. For instance, GP's postfix `++`

returns the *new* value, like the prefix `++`

of C, and the binary
shifts ` << `

, ` >> `

have a priority which is different from (higher
than) that of their C counterparts. When in doubt, just surround everything
by parentheses; besides, your code will be more legible.

Here is the list of available operators, ordered by decreasing
priority, binary and left-associative unless mentioned otherwise. An
expression is an *lvalue* if something can be assigned to it. (The name
comes from left-value, to the left of a ` = `

operator; e.g.
`x`

, or `v[1]`

are lvalues, but `x + 1`

is not.)

***** Priority 14

`:`

as in `x:small`

, is used to indicate to the GP2C compiler that the
variable on the left-hand side always contains objects of the type specified
on the right hand-side (here, a small integer) in order to produce more
efficient or more readable C code. This is ignored by GP.

***** Priority 13
`( )`

is the function call operator. If f is a closure and *args*
is a comma-separated list of arguments (possibly empty),
f`(`

evaluates f on those arguments.*args*)

***** Priority 12

`++`

and `--`

(unary, postfix): if x is an `lvalue`

,
`x++`

assigns the value x+1 to x, then returns the new value of
x. This corresponds to the C statement `++x`

: there is no prefix
`++`

operator in GP. `x--`

does the same with x-1. These
operators are not associative, i.e. `x++++`

is invalid, since
`x++`

is not an lvalue.

***** Priority 11

`.`

*member* (unary, postfix): `x.`

extracts
*member**member* from structure x (see Section se:member).

`[ ]`

is the selection operator. `x[i]`

returns the i-th
component of vector x; `x[i,j]`

, `x[,j]`

and
`x[i,]`

respectively return the entry of coordinates (i,j), the
j-th column, and the i-th row of matrix x. If the assignment operator
(` = `

) immediately follows a sequence of selections, it assigns its right
hand side to the selected component. E.g `x[1][1] = 0`

is valid; but
beware that `(x[1])[1] = 0`

is not (because the parentheses force the
complete evaluation of `x[1]`

, and the result is not modifiable).

***** Priority 10

`'`

(unary, postfix): derivative with respect to the main variable.
If f is a function (`t_CLOSURE`

), f' is allowed and defines a new
function, which will perform numerical derivation when evaluated
at a scalar x; this is defined as (f(x+ϵ) - f(x-ϵ)) /
2ϵ for a suitably small epsilon depending on current precision.

? (x^2 + y*x + y^2)' \\ derive with respect to main variable`x`

%1 = 2*x + y ? SIN = cos' %2 = cos' ? SIN(Pi/6) \\ numerical derivation %3 = -0.5000000000000000000000000000 ? cos'(Pi/6) \\ works directly: no need for intermediate`SIN`

%4 = -0.5000000000000000000000000000

`~`

(unary, postfix): vector/matrix transpose.

`!`

(unary, postfix): factorial. x`!`

= x(x-1)...1.

`!`

(unary, prefix): logical *not*. `!x`

returns 1 if x is
equal to 0 (specifically, if `gequal0(x) == 1`

), and 0 otherwise.

***** Priority 9

`#`

(unary, prefix): cardinality; `#x`

returns `length(x)`

.

***** Priority 8

`^`

: powering. This operator is right associative:
`2^3^4`

is understood as `2^(3^4)`

.

***** Priority 7

`+`

, `-`

(unary, prefix): `-`

toggles the sign of its argument,
`+`

has no effect whatsoever.

***** Priority 6

`*`

: multiplication.

`/`

: exact division (`3/2`

yields 3/2, not 1.5).

`\`

, `%`

: Euclidean quotient and remainder, i.e. if x =
qy + r, then `x `

= q, `\ `

y`x%y`

= r. If x and y
are scalars, then q is an integer and r satisfies 0 ≤ r < |y|; if x
and y are polynomials, then q and r are polynomials such that deg r <
deg y and the leading terms of r and x have the same sign.

`\/`

: rounded Euclidean quotient for integers (rounded towards
+ oo when the exact quotient would be a half-integer).

` << `

, ` >> `

: left and right binary shift. By definition,
`x << n`

= x * 2^n if n > 0, and `truncate`

(x 2^{-n}) otherwise.
Right shift is defined by `x >> n`

= `x << (-n)`

.

***** Priority 5

`+`

, `-`

: addition/subtraction.

***** Priority 4

` < `

, ` > `

, ` <= `

, ` >= `

: the usual comparison operators,
returning 1 for `true`

and 0 for `false`

. For instance,
`x <= 1`

returns 1 if x ≤ 1 and 0 otherwise.

` <> `

, ` != `

: test for (exact) inequality.

` == `

: test for (exact) equality. `t_QFR`

having the same coefficients
but a different distance component are tested as equal.

` === `

: test whether two objects are identical component-wise. This is
stricter than ` == `

: for instance, the integer 0, a 0 polynomial or a
vector with 0 entries, are all tested equal by ` == `

, but they are not
identical.

***** Priority 3

`&&`

: logical *and*.

`||`

: logical (inclusive) *or*. Any sequence of logical
*or* and *and* operations is evaluated from left to right,
and aborted as soon as the final truth value is known. Thus, for instance,

x == 0 || test(1/x)

will never produce an error since `test(1/x)`

is not even evaluated
when the first test is true (hence the final truth value is true). Similarly

type(p) == "t_INT" && isprime(p)

does not evaluate `isprime(p)`

if `p`

is not an integer.

***** Priority 2

` = `

(assignment, *lvalue* ` = `

*expr*). The result of
`x = y`

is the value of the expression y, which is also assigned to
the variable `x`

. This assignment operator is right-associative. This is
*not* the equality test operator; a statement like `x = 1`

is always
true (i.e. non-zero), and sets `x`

to 1; the equality test would be
`x == 1`

. The right hand side of the assignment operator is evaluated
before the left hand side.

It is crucial that the left hand-side be an *lvalue* there, it avoids
ambiguities in expressions like `1 + x = 1`

. The latter evaluates as
`1 + (x = 1)`

, not as `(1 + x) = 1`

, even though the priority of
` = `

is lower than the priority of `+`

: `1 + x`

is not an lvalue.

If the expression cannot be parsed in a way where the left hand side is an lvalue, raise an error.

? x + 1 = 1 *** syntax error, unexpected '=', expecting $end or ';': x+1=1 *** ^--

Assignment to all variables is a deep copy: after x = y, modifying a
component of y will *not* change x. To globals it is a full copy to
the heap. Space used by local objects in local variables is released when
they go out of scope or when the value changes in local scope. Assigning a
value to a vector or matrix entry allocates room for that entry only (on the
heap).

, where *op* = *op* is any binary operator
among `+`

, `-`

, `*`

, `%`

, `/`

, `\`

, `\/`

,
` << `

, or
` >> `

(composed assignment *lvalue* *op*` = `

*expr*).
The expression `x `

assigns (*op* = y`x`

*op* y)
to `x`

, and returns the new value of `x`

. The result is *not*
an *lvalue*; thus

(x += 2) = 3

is invalid. These assignment operators are right-associative:

? x = 'x; x += x *= 2 %1 = 3*x

***** Priority 1
`- > `

(function definition): `(`

returns a
function object, of type *vars*)- > *expr*`t_CLOSURE`

.

**Remark.** Use the *op*` = `

operators as often as possible
since they make complex assignments more legible. Compare

v[i+j-1] = v[i+j-1] + 1 --> v[i+j-1]++ M[i,i+j] = M[i,i+j] * 2 --> M[i,i+j] *= 2

**Remark about efficiency.** the operators `++`

and `--`

are usually a little more efficient than their expended
counterpart:

? N = 10^7; ? i = 0; for(k = 1, N, i=i+1) time = 949 ms. ? i = 0; for(k = 1, N, i++) time = 933 ms.

On the other hand, this is not the case for the
*op*` = `

operators which may even be a little less efficient:

? i = 0; for(k = 1, N, i=i+10) time = 949 ms. ? i = 0; for(k = 1, N, i+=10) time = 1,064 ms.

`+`

or `-`

, but also
` = `

or ` += `

, or even `[ ]`

(the selection operator). As all
functions, operators take arguments, and return a value; *assignment*
operators also have side effects: besides returning a value, they change the
value of some variable.

a + b + c --> (a + b) + c \\ left-associative a = b = c --> a = (b = c) \\ right-associative

*op*_{1}, *op*_{2}, *op*_{3} are
binary operators with increasing priorities (think of `+`

,
`*`

, `^`

),
x *op*_{1} y *op*_{2} z *op*_{2} x *op*_{3} y is
equivalent to x *op*_{1} ((y *op*_{2} z) *op*_{2}
(x *op*_{3} y)).

*prefix* or *postfix*, meaning
that they respectively precede (*op* x) and follow (x *op*) their
single argument. Some symbols are syntactically correct in both positions,
like `!`

, but then represent different operators: the `!`

symbol
represents the negation and factorial operators when in prefix and postfix
position respectively. Binary operators all use the (infix) syntax
x *op* y.

`+`

, `%`

, ` = `

), some are
borrowed from the C language (`++`

, ` << `

), and a few are
specific to GP (`\`

, `#`

). Beware that some GP operators differ
slightly from their C counterparts. For instance, GP's postfix `++`

returns the *new* value, like the prefix `++`

of C, and the binary
shifts ` << `

, ` >> `

have a priority which is different from (higher
than) that of their C counterparts. When in doubt, just surround everything
by parentheses; besides, your code will be more legible.

*lvalue* if something can be assigned to it. (The name
comes from left-value, to the left of a ` = `

operator; e.g.
`x`

, or `v[1]`

are lvalues, but `x + 1`

is not.)

***** Priority 14

`:`

as in `x:small`

, is used to indicate to the GP2C compiler that the
variable on the left-hand side always contains objects of the type specified
on the right hand-side (here, a small integer) in order to produce more
efficient or more readable C code. This is ignored by GP.

***** Priority 13
`( )`

is the function call operator. If f is a closure and *args*
is a comma-separated list of arguments (possibly empty),
f`(`

evaluates f on those arguments.*args*)

***** Priority 12

`++`

and `--`

(unary, postfix): if x is an `lvalue`

,
`x++`

assigns the value x+1 to x, then returns the new value of
x. This corresponds to the C statement `++x`

: there is no prefix
`++`

operator in GP. `x--`

does the same with x-1. These
operators are not associative, i.e. `x++++`

is invalid, since
`x++`

is not an lvalue.

***** Priority 11

`.`

*member* (unary, postfix): `x.`

extracts
*member**member* from structure x (see Section se:member).

`[ ]`

is the selection operator. `x[i]`

returns the i-th
component of vector x; `x[i,j]`

, `x[,j]`

and
`x[i,]`

respectively return the entry of coordinates (i,j), the
j-th column, and the i-th row of matrix x. If the assignment operator
(` = `

) immediately follows a sequence of selections, it assigns its right
hand side to the selected component. E.g `x[1][1] = 0`

is valid; but
beware that `(x[1])[1] = 0`

is not (because the parentheses force the
complete evaluation of `x[1]`

, and the result is not modifiable).

***** Priority 10

`'`

(unary, postfix): derivative with respect to the main variable.
If f is a function (`t_CLOSURE`

), f' is allowed and defines a new
function, which will perform numerical derivation when evaluated
at a scalar x; this is defined as (f(x+ϵ) - f(x-ϵ)) /
2ϵ for a suitably small epsilon depending on current precision.

`x`

%1 = 2*x + y ? SIN = cos' %2 = cos' ? SIN(Pi/6) \\ numerical derivation %3 = -0.5000000000000000000000000000 ? cos'(Pi/6) \\ works directly: no need for intermediate`SIN`

%4 = -0.5000000000000000000000000000

`~`

(unary, postfix): vector/matrix transpose.

`!`

(unary, postfix): factorial. x`!`

= x(x-1)...1.

`!`

(unary, prefix): logical *not*. `!x`

returns 1 if x is
equal to 0 (specifically, if `gequal0(x) == 1`

), and 0 otherwise.

***** Priority 9

`#`

(unary, prefix): cardinality; `#x`

returns `length(x)`

.

***** Priority 8

`^`

: powering. This operator is right associative:
`2^3^4`

is understood as `2^(3^4)`

.

***** Priority 7

`+`

, `-`

(unary, prefix): `-`

toggles the sign of its argument,
`+`

has no effect whatsoever.

***** Priority 6

`*`

: multiplication.

`/`

: exact division (`3/2`

yields 3/2, not 1.5).

`\`

, `%`

: Euclidean quotient and remainder, i.e. if x =
qy + r, then `x `

= q, `\ `

y`x%y`

= r. If x and y
are scalars, then q is an integer and r satisfies 0 ≤ r < |y|; if x
and y are polynomials, then q and r are polynomials such that deg r <
deg y and the leading terms of r and x have the same sign.

`\/`

: rounded Euclidean quotient for integers (rounded towards
+ oo when the exact quotient would be a half-integer).

` << `

, ` >> `

: left and right binary shift. By definition,
`x << n`

= x * 2^n if n > 0, and `truncate`

(x 2^{-n}) otherwise.
Right shift is defined by `x >> n`

= `x << (-n)`

.

***** Priority 5

`+`

, `-`

: addition/subtraction.

***** Priority 4

` < `

, ` > `

, ` <= `

, ` >= `

: the usual comparison operators,
returning 1 for `true`

and 0 for `false`

. For instance,
`x <= 1`

returns 1 if x ≤ 1 and 0 otherwise.

` <> `

, ` != `

: test for (exact) inequality.

` == `

: test for (exact) equality. `t_QFR`

having the same coefficients
but a different distance component are tested as equal.

` === `

: test whether two objects are identical component-wise. This is
stricter than ` == `

: for instance, the integer 0, a 0 polynomial or a
vector with 0 entries, are all tested equal by ` == `

, but they are not
identical.

***** Priority 3

`&&`

: logical *and*.

`||`

: logical (inclusive) *or*. Any sequence of logical
*or* and *and* operations is evaluated from left to right,
and aborted as soon as the final truth value is known. Thus, for instance,

x == 0 || test(1/x)

`test(1/x)`

is not even evaluated
when the first test is true (hence the final truth value is true). Similarly

type(p) == "t_INT" && isprime(p)

does not evaluate `isprime(p)`

if `p`

is not an integer.

***** Priority 2

` = `

(assignment, *lvalue* ` = `

*expr*). The result of
`x = y`

is the value of the expression y, which is also assigned to
the variable `x`

. This assignment operator is right-associative. This is
*not* the equality test operator; a statement like `x = 1`

is always
true (i.e. non-zero), and sets `x`

to 1; the equality test would be
`x == 1`

. The right hand side of the assignment operator is evaluated
before the left hand side.

*lvalue* there, it avoids
ambiguities in expressions like `1 + x = 1`

. The latter evaluates as
`1 + (x = 1)`

, not as `(1 + x) = 1`

, even though the priority of
` = `

is lower than the priority of `+`

: `1 + x`

is not an lvalue.

If the expression cannot be parsed in a way where the left hand side is an lvalue, raise an error.

? x + 1 = 1 *** syntax error, unexpected '=', expecting $end or ';': x+1=1 *** ^--

*not* change x. To globals it is a full copy to
the heap. Space used by local objects in local variables is released when
they go out of scope or when the value changes in local scope. Assigning a
value to a vector or matrix entry allocates room for that entry only (on the
heap).

, where *op* = *op* is any binary operator
among `+`

, `-`

, `*`

, `%`

, `/`

, `\`

, `\/`

,
` << `

, or
` >> `

(composed assignment *lvalue* *op*` = `

*expr*).
The expression `x `

assigns (*op* = y`x`

*op* y)
to `x`

, and returns the new value of `x`

. The result is *not*
an *lvalue*; thus

(x += 2) = 3

is invalid. These assignment operators are right-associative:

? x = 'x; x += x *= 2 %1 = 3*x

***** Priority 1
`- > `

(function definition): `(`

returns a
function object, of type *vars*)- > *expr*`t_CLOSURE`

.

**Remark.** Use the *op*` = `

operators as often as possible
since they make complex assignments more legible. Compare

v[i+j-1] = v[i+j-1] + 1 --> v[i+j-1]++ M[i,i+j] = M[i,i+j] * 2 --> M[i,i+j] *= 2

**Remark about efficiency.** the operators `++`

and `--`

are usually a little more efficient than their expended
counterpart:

? N = 10^7; ? i = 0; for(k = 1, N, i=i+1) time = 949 ms. ? i = 0; for(k = 1, N, i++) time = 933 ms.

*op*` = `

operators which may even be a little less efficient:

? i = 0; for(k = 1, N, i=i+10) time = 949 ms. ? i = 0; for(k = 1, N, i+=10) time = 1,064 ms.

`+`

or `-`

, but also
` = `

or ` += `

, or even `[ ]`

(the selection operator). As all
functions, operators take arguments, and return a value; *assignment*
operators also have side effects: besides returning a value, they change the
value of some variable.

a + b + c --> (a + b) + c \\ left-associative a = b = c --> a = (b = c) \\ right-associative

*op*_{1}, *op*_{2}, *op*_{3} are
binary operators with increasing priorities (think of `+`

,
`*`

, `^`

),
x *op*_{1} y *op*_{2} z *op*_{2} x *op*_{3} y is
equivalent to x *op*_{1} ((y *op*_{2} z) *op*_{2}
(x *op*_{3} y)).

*prefix* or *postfix*, meaning
that they respectively precede (*op* x) and follow (x *op*) their
single argument. Some symbols are syntactically correct in both positions,
like `!`

, but then represent different operators: the `!`

symbol
represents the negation and factorial operators when in prefix and postfix
position respectively. Binary operators all use the (infix) syntax
x *op* y.

`+`

, `%`

, ` = `

), some are
borrowed from the C language (`++`

, ` << `

), and a few are
specific to GP (`\`

, `#`

). Beware that some GP operators differ
slightly from their C counterparts. For instance, GP's postfix `++`

returns the *new* value, like the prefix `++`

of C, and the binary
shifts ` << `

, ` >> `

have a priority which is different from (higher
than) that of their C counterparts. When in doubt, just surround everything
by parentheses; besides, your code will be more legible.

*lvalue* if something can be assigned to it. (The name
comes from left-value, to the left of a ` = `

operator; e.g.
`x`

, or `v[1]`

are lvalues, but `x + 1`

is not.)

***** Priority 14

`:`

as in `x:small`

, is used to indicate to the GP2C compiler that the
variable on the left-hand side always contains objects of the type specified
on the right hand-side (here, a small integer) in order to produce more
efficient or more readable C code. This is ignored by GP.

***** Priority 13
`( )`

is the function call operator. If f is a closure and *args*
is a comma-separated list of arguments (possibly empty),
f`(`

evaluates f on those arguments.*args*)

***** Priority 12

`++`

and `--`

(unary, postfix): if x is an `lvalue`

,
`x++`

assigns the value x+1 to x, then returns the new value of
x. This corresponds to the C statement `++x`

: there is no prefix
`++`

operator in GP. `x--`

does the same with x-1. These
operators are not associative, i.e. `x++++`

is invalid, since
`x++`

is not an lvalue.

***** Priority 11

`.`

*member* (unary, postfix): `x.`

extracts
*member**member* from structure x (see Section se:member).

`[ ]`

is the selection operator. `x[i]`

returns the i-th
component of vector x; `x[i,j]`

, `x[,j]`

and
`x[i,]`

respectively return the entry of coordinates (i,j), the
j-th column, and the i-th row of matrix x. If the assignment operator
(` = `

) immediately follows a sequence of selections, it assigns its right
hand side to the selected component. E.g `x[1][1] = 0`

is valid; but
beware that `(x[1])[1] = 0`

is not (because the parentheses force the
complete evaluation of `x[1]`

, and the result is not modifiable).

***** Priority 10

`'`

(unary, postfix): derivative with respect to the main variable.
If f is a function (`t_CLOSURE`

), f' is allowed and defines a new
function, which will perform numerical derivation when evaluated
at a scalar x; this is defined as (f(x+ϵ) - f(x-ϵ)) /
2ϵ for a suitably small epsilon depending on current precision.

`x`

%1 = 2*x + y ? SIN = cos' %2 = cos' ? SIN(Pi/6) \\ numerical derivation %3 = -0.5000000000000000000000000000 ? cos'(Pi/6) \\ works directly: no need for intermediate`SIN`

%4 = -0.5000000000000000000000000000

`~`

(unary, postfix): vector/matrix transpose.

`!`

(unary, postfix): factorial. x`!`

= x(x-1)...1.

`!`

(unary, prefix): logical *not*. `!x`

returns 1 if x is
equal to 0 (specifically, if `gequal0(x) == 1`

), and 0 otherwise.

***** Priority 9

`#`

(unary, prefix): cardinality; `#x`

returns `length(x)`

.

***** Priority 8

`^`

: powering. This operator is right associative:
`2^3^4`

is understood as `2^(3^4)`

.

***** Priority 7

`+`

, `-`

(unary, prefix): `-`

toggles the sign of its argument,
`+`

has no effect whatsoever.

***** Priority 6

`*`

: multiplication.

`/`

: exact division (`3/2`

yields 3/2, not 1.5).

`\`

, `%`

: Euclidean quotient and remainder, i.e. if x =
qy + r, then `x `

= q, `\ `

y`x%y`

= r. If x and y
are scalars, then q is an integer and r satisfies 0 ≤ r < |y|; if x
and y are polynomials, then q and r are polynomials such that deg r <
deg y and the leading terms of r and x have the same sign.

`\/`

: rounded Euclidean quotient for integers (rounded towards
+ oo when the exact quotient would be a half-integer).

` << `

, ` >> `

: left and right binary shift. By definition,
`x << n`

= x * 2^n if n > 0, and `truncate`

(x 2^{-n}) otherwise.
Right shift is defined by `x >> n`

= `x << (-n)`

.

***** Priority 5

`+`

, `-`

: addition/subtraction.

***** Priority 4

` < `

, ` > `

, ` <= `

, ` >= `

: the usual comparison operators,
returning 1 for `true`

and 0 for `false`

. For instance,
`x <= 1`

returns 1 if x ≤ 1 and 0 otherwise.

` <> `

, ` != `

: test for (exact) inequality.

` == `

: test for (exact) equality. `t_QFR`

having the same coefficients
but a different distance component are tested as equal.

` === `

: test whether two objects are identical component-wise. This is
stricter than ` == `

: for instance, the integer 0, a 0 polynomial or a
vector with 0 entries, are all tested equal by ` == `

, but they are not
identical.

***** Priority 3

`&&`

: logical *and*.

`||`

: logical (inclusive) *or*. Any sequence of logical
*or* and *and* operations is evaluated from left to right,
and aborted as soon as the final truth value is known. Thus, for instance,

x == 0 || test(1/x)

`test(1/x)`

is not even evaluated
when the first test is true (hence the final truth value is true). Similarly

type(p) == "t_INT" && isprime(p)

does not evaluate `isprime(p)`

if `p`

is not an integer.

***** Priority 2

` = `

(assignment, *lvalue* ` = `

*expr*). The result of
`x = y`

is the value of the expression y, which is also assigned to
the variable `x`

. This assignment operator is right-associative. This is
*not* the equality test operator; a statement like `x = 1`

is always
true (i.e. non-zero), and sets `x`

to 1; the equality test would be
`x == 1`

. The right hand side of the assignment operator is evaluated
before the left hand side.

*lvalue* there, it avoids
ambiguities in expressions like `1 + x = 1`

. The latter evaluates as
`1 + (x = 1)`

, not as `(1 + x) = 1`

, even though the priority of
` = `

is lower than the priority of `+`

: `1 + x`

is not an lvalue.

If the expression cannot be parsed in a way where the left hand side is an lvalue, raise an error.

? x + 1 = 1 *** syntax error, unexpected '=', expecting $end or ';': x+1=1 *** ^--

*not* change x. To globals it is a full copy to
the heap. Space used by local objects in local variables is released when
they go out of scope or when the value changes in local scope. Assigning a
value to a vector or matrix entry allocates room for that entry only (on the
heap).

, where *op* = *op* is any binary operator
among `+`

, `-`

, `*`

, `%`

, `/`

, `\`

, `\/`

,
` << `

, or
` >> `

(composed assignment *lvalue* *op*` = `

*expr*).
The expression `x `

assigns (*op* = y`x`

*op* y)
to `x`

, and returns the new value of `x`

. The result is *not*
an *lvalue*; thus

(x += 2) = 3

is invalid. These assignment operators are right-associative:

? x = 'x; x += x *= 2 %1 = 3*x

***** Priority 1
`- > `

(function definition): `(`

returns a
function object, of type *vars*)- > *expr*`t_CLOSURE`

.

**Remark.** Use the *op*` = `

operators as often as possible
since they make complex assignments more legible. Compare

v[i+j-1] = v[i+j-1] + 1 --> v[i+j-1]++ M[i,i+j] = M[i,i+j] * 2 --> M[i,i+j] *= 2

**Remark about efficiency.** the operators `++`

and `--`

are usually a little more efficient than their expended
counterpart:

? N = 10^7; ? i = 0; for(k = 1, N, i=i+1) time = 949 ms. ? i = 0; for(k = 1, N, i++) time = 933 ms.

*op*` = `

operators which may even be a little less efficient:

? i = 0; for(k = 1, N, i=i+10) time = 949 ms. ? i = 0; for(k = 1, N, i+=10) time = 1,064 ms.

The expression `x \y`

is the
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.

`+`

or `-`

, but also
` = `

or ` += `

, or even `[ ]`

(the selection operator). As all
functions, operators take arguments, and return a value; *assignment*
operators also have side effects: besides returning a value, they change the
value of some variable.

a + b + c --> (a + b) + c \\ left-associative a = b = c --> a = (b = c) \\ right-associative

*op*_{1}, *op*_{2}, *op*_{3} are
binary operators with increasing priorities (think of `+`

,
`*`

, `^`

),
x *op*_{1} y *op*_{2} z *op*_{2} x *op*_{3} y is
equivalent to x *op*_{1} ((y *op*_{2} z) *op*_{2}
(x *op*_{3} y)).

*prefix* or *postfix*, meaning
that they respectively precede (*op* x) and follow (x *op*) their
single argument. Some symbols are syntactically correct in both positions,
like `!`

, but then represent different operators: the `!`

symbol
represents the negation and factorial operators when in prefix and postfix
position respectively. Binary operators all use the (infix) syntax
x *op* y.

`+`

, `%`

, ` = `

), some are
borrowed from the C language (`++`

, ` << `

), and a few are
specific to GP (`\`

, `#`

). Beware that some GP operators differ
slightly from their C counterparts. For instance, GP's postfix `++`

returns the *new* value, like the prefix `++`

of C, and the binary
shifts ` << `

, ` >> `

have a priority which is different from (higher
than) that of their C counterparts. When in doubt, just surround everything
by parentheses; besides, your code will be more legible.

*lvalue* if something can be assigned to it. (The name
comes from left-value, to the left of a ` = `

operator; e.g.
`x`

, or `v[1]`

are lvalues, but `x + 1`

is not.)

***** Priority 14

`:`

as in `x:small`

, is used to indicate to the GP2C compiler that the
variable on the left-hand side always contains objects of the type specified
on the right hand-side (here, a small integer) in order to produce more
efficient or more readable C code. This is ignored by GP.

***** Priority 13
`( )`

is the function call operator. If f is a closure and *args*
is a comma-separated list of arguments (possibly empty),
f`(`

evaluates f on those arguments.*args*)

***** Priority 12

`++`

and `--`

(unary, postfix): if x is an `lvalue`

,
`x++`

assigns the value x+1 to x, then returns the new value of
x. This corresponds to the C statement `++x`

: there is no prefix
`++`

operator in GP. `x--`

does the same with x-1. These
operators are not associative, i.e. `x++++`

is invalid, since
`x++`

is not an lvalue.

***** Priority 11

`.`

*member* (unary, postfix): `x.`

extracts
*member**member* from structure x (see Section se:member).

`[ ]`

is the selection operator. `x[i]`

returns the i-th
component of vector x; `x[i,j]`

, `x[,j]`

and
`x[i,]`

respectively return the entry of coordinates (i,j), the
j-th column, and the i-th row of matrix x. If the assignment operator
(` = `

) immediately follows a sequence of selections, it assigns its right
hand side to the selected component. E.g `x[1][1] = 0`

is valid; but
beware that `(x[1])[1] = 0`

is not (because the parentheses force the
complete evaluation of `x[1]`

, and the result is not modifiable).

***** Priority 10

`'`

(unary, postfix): derivative with respect to the main variable.
If f is a function (`t_CLOSURE`

), f' is allowed and defines a new
function, which will perform numerical derivation when evaluated
at a scalar x; this is defined as (f(x+ϵ) - f(x-ϵ)) /
2ϵ for a suitably small epsilon depending on current precision.

`x`

%1 = 2*x + y ? SIN = cos' %2 = cos' ? SIN(Pi/6) \\ numerical derivation %3 = -0.5000000000000000000000000000 ? cos'(Pi/6) \\ works directly: no need for intermediate`SIN`

%4 = -0.5000000000000000000000000000

`~`

(unary, postfix): vector/matrix transpose.

`!`

(unary, postfix): factorial. x`!`

= x(x-1)...1.

`!`

(unary, prefix): logical *not*. `!x`

returns 1 if x is
equal to 0 (specifically, if `gequal0(x) == 1`

), and 0 otherwise.

***** Priority 9

`#`

(unary, prefix): cardinality; `#x`

returns `length(x)`

.

***** Priority 8

`^`

: powering. This operator is right associative:
`2^3^4`

is understood as `2^(3^4)`

.

***** Priority 7

`+`

, `-`

(unary, prefix): `-`

toggles the sign of its argument,
`+`

has no effect whatsoever.

***** Priority 6

`*`

: multiplication.

`/`

: exact division (`3/2`

yields 3/2, not 1.5).

`\`

, `%`

: Euclidean quotient and remainder, i.e. if x =
qy + r, then `x `

= q, `\ `

y`x%y`

= r. If x and y
are scalars, then q is an integer and r satisfies 0 ≤ r < |y|; if x
and y are polynomials, then q and r are polynomials such that deg r <
deg y and the leading terms of r and x have the same sign.

`\/`

: rounded Euclidean quotient for integers (rounded towards
+ oo when the exact quotient would be a half-integer).

` << `

, ` >> `

: left and right binary shift. By definition,
`x << n`

= x * 2^n if n > 0, and `truncate`

(x 2^{-n}) otherwise.
Right shift is defined by `x >> n`

= `x << (-n)`

.

***** Priority 5

`+`

, `-`

: addition/subtraction.

***** Priority 4

` < `

, ` > `

, ` <= `

, ` >= `

: the usual comparison operators,
returning 1 for `true`

and 0 for `false`

. For instance,
`x <= 1`

returns 1 if x ≤ 1 and 0 otherwise.

` <> `

, ` != `

: test for (exact) inequality.

` == `

: test for (exact) equality. `t_QFR`

having the same coefficients
but a different distance component are tested as equal.

` === `

: test whether two objects are identical component-wise. This is
stricter than ` == `

: for instance, the integer 0, a 0 polynomial or a
vector with 0 entries, are all tested equal by ` == `

, but they are not
identical.

***** Priority 3

`&&`

: logical *and*.

`||`

: logical (inclusive) *or*. Any sequence of logical
*or* and *and* operations is evaluated from left to right,
and aborted as soon as the final truth value is known. Thus, for instance,

x == 0 || test(1/x)

`test(1/x)`

is not even evaluated
when the first test is true (hence the final truth value is true). Similarly

type(p) == "t_INT" && isprime(p)

does not evaluate `isprime(p)`

if `p`

is not an integer.

***** Priority 2

` = `

(assignment, *lvalue* ` = `

*expr*). The result of
`x = y`

is the value of the expression y, which is also assigned to
the variable `x`

. This assignment operator is right-associative. This is
*not* the equality test operator; a statement like `x = 1`

is always
true (i.e. non-zero), and sets `x`

to 1; the equality test would be
`x == 1`

. The right hand side of the assignment operator is evaluated
before the left hand side.

*lvalue* there, it avoids
ambiguities in expressions like `1 + x = 1`

. The latter evaluates as
`1 + (x = 1)`

, not as `(1 + x) = 1`

, even though the priority of
` = `

is lower than the priority of `+`

: `1 + x`

is not an lvalue.

If the expression cannot be parsed in a way where the left hand side is an lvalue, raise an error.

? x + 1 = 1 *** syntax error, unexpected '=', expecting $end or ';': x+1=1 *** ^--

*not* change x. To globals it is a full copy to
the heap. Space used by local objects in local variables is released when
they go out of scope or when the value changes in local scope. Assigning a
value to a vector or matrix entry allocates room for that entry only (on the
heap).

, where *op* = *op* is any binary operator
among `+`

, `-`

, `*`

, `%`

, `/`

, `\`

, `\/`

,
` << `

, or
` >> `

(composed assignment *lvalue* *op*` = `

*expr*).
The expression `x `

assigns (*op* = y`x`

*op* y)
to `x`

, and returns the new value of `x`

. The result is *not*
an *lvalue*; thus

(x += 2) = 3

is invalid. These assignment operators are right-associative:

? x = 'x; x += x *= 2 %1 = 3*x

***** Priority 1
`- > `

(function definition): `(`

returns a
function object, of type *vars*)- > *expr*`t_CLOSURE`

.

**Remark.** Use the *op*` = `

operators as often as possible
since they make complex assignments more legible. Compare

v[i+j-1] = v[i+j-1] + 1 --> v[i+j-1]++ M[i,i+j] = M[i,i+j] * 2 --> M[i,i+j] *= 2

**Remark about efficiency.** the operators `++`

and `--`

are usually a little more efficient than their expended
counterpart:

? N = 10^7; ? i = 0; for(k = 1, N, i=i+1) time = 949 ms. ? i = 0; for(k = 1, N, i++) time = 933 ms.

*op*` = `

operators which may even be a little less efficient:

? i = 0; for(k = 1, N, i=i+10) time = 949 ms. ? i = 0; for(k = 1, N, i+=10) time = 1,064 ms.

The expression x^n is powering.

***** If the exponent n is an integer, then exact operations are performed
using binary (left-shift) powering techniques. 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 representative of the class, which is
always reduced if the input was. (In particular, `x^1`

returns x
itself, whether it is reduced or not.)

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 n is not an integer, powering is treated as the
transcendental function exp(nlog x), and in particular acts
componentwise on vector or matrices, even square matrices ! (See
Section se:trans.)

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

x, 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`

x, the behavior is the same:

? Mod(x^2, x^3-x)^(-1) *** at top-level: Mod(x^2,x^3-x)^(-1) *** ^ — -- *** _^_: impossible inverse in RgXQ_inv: Mod(x^2, x^3 - x).

Note that the underlying algorihm (subresultant) assumes the base ring is a domain:

? a = Mod(3*y^3+1, 4); b = y^6+y^5+y^4+y^3+y^2+y+1; c = Mod(a,b); ? c^(-1) *** at top-level: Mod(a,b)^(-1) *** ^ — -- *** _^_: impossible inverse modulo: Mod(2, 4).

In fact c is invertible, but ℤ/4ℤ is not a domain and the algorithm fails. It is possible for the algorithm to succeed in such situations and any returned 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 also try the following approach

? inversemod(a, b) = { my(m, v = variable(b)); m = polsylvestermatrix(polrecip(a), polrecip(b)); m = matinverseimage(m, matid(#m)[,1]); Polrev(m[1..poldegree(b)], v); } ? 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 `matinverseimage`

must also
invert pivots. See Section se:linear_algebra.

For a `t_MAT`

x, the matrix is expected to be square and invertible, except
in the special case `x^(-1)`

which returns a left inverse if one exists
(rectangular x with full column rank).

? x = Mat([1;2]) %1 = [1] [2] ? x^(-1) %2 = [1 0]

The library syntax is `GEN `

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

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. It has no
mathematical meaning but satisfies the following properties when comparing
entries of the same type:

***** two `t_INT`

s compare as usual (i.e. `cmp`

(x,y) < 0 if and only
if x < y);

***** two `t_VECSMALL`

s of the same length compare lexicographically;

***** two `t_STR`

s compare lexicographically.

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 = -1

This function is mostly useful to handle sorted lists or
vectors of arbitrary objects. 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)

For non-negative n, return the vector with n+1 components
[1,x,...,x^n] if `x0`

is omitted, and [x_{0}, x_{0}*x, ..., x_{0}*x^n]
otherwise.

? powers(Mod(3,17), 4) %1 = [Mod(1, 17), Mod(3, 17), Mod(9, 17), Mod(10, 17), Mod(13, 17)] ? powers(Mat([1,2;3,4]), 3) %2 = [[1, 0; 0, 1], [1, 2; 3, 4], [7, 10; 15, 22], [37, 54; 81, 118]] ? powers(3, 5, 2) %3 = [2, 6, 18, 54, 162, 486]

When n < 0, the function returns the empty vector `[]`

.

The library syntax is `GEN `

.
Also available is
**gpowers0**(GEN x, long n, GEN x0 = NULL)`GEN `

when **gpowers**(GEN x, long n)`x0`

is `NULL`

.

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; `t_QUAD`

with positive discriminants and
`t_INFINITY`

are also supported.

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 `

.
When v is not needed, the function **vecmax0**(GEN x, GEN *v = NULL)`GEN `

is
also available.**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 `

.
When v is not needed, the function **vecmin0**(GEN x, GEN *v = NULL)`GEN `

is also
available.**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 compared using
the standard lexicographic order, and comparing them to objects
of a different type raises an exception.

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.