Pari/GP Reference Documentation | Contents - Global index - GP keyboard shortcuts |
! * + +/- ++ - -- / Boolean operators Comparison Equality \# % \ \/ ^ cmp divrem lex max min op= shift shiftmul sign vecmax vecmin | |
Boolean operators | |
Any nonzero value is interpreted as true and any zero as false
(this includes empty vectors or matrices). The standard boolean operators
? a && b \\ 1 iff a and b are nonzero ? a || b \\ 1 iff a or b is nonzero ? !a \\ 1 iff a is zero
| |
Comparison | |
The standard real comparison operators
By extension, two character strings (
| |
Equality | |
Two operators allow to test for equality:
The operator
? 4 == Mod(1,3) \\ equal %1 = 1 ? 4 === Mod(1,3) \\ but not identical %2 = 0 ? 'x == 'y \\ not equal (nonconstant and different variables) %3 = 0 ? Pol(0,'x) == Pol(0,'y) \\ equal (constant: ignore variable) %4 = 1 ? Pol(0,'x) === Pol(0,'y) \\ not identical %5 = 0 ? 0 == Pol(0) \\ equal (not identical) %6 = 1 ? [0] == 0 \\ equal (not identical) %7 = 1 ? [0, 0] == 0 \\ equal (not identical) %8 = 1 ? [0] == [0,0] \\ not equal %9 = 0
In particular
Do not mistake
| |
+/- | |
The expressions
The library syntax is
| |
+ | |
The expression x
The library syntax is
| |
- | |
The expression x
The library syntax is
| |
* | |
The expression x
Multiplication between two
? 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
The library syntax is
| |
/ | |
The expression x
The library syntax is
| |
\ | |
The expression 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
| |
\/ | |
The expression x When x is a vector or matrix, the operator is applied componentwise.
The library syntax is
| |
% | |
The expression
? (1/2) % 3 %1 = 2 ? 0.5 % 3 %2 = 0.5000000000000000000000000000 ? (1/2) % 3.0 %3 = 1/2 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
| |
! | |
The expression
The library syntax is
| |
# | |
The expression
The library syntax is
| |
op = | |
When
? v[1] += 10 \\ increment v[1] by 10 ? a /= 2 \\ divide a by 2
| |
++ | |
| |
-- | |
| |
^ | |
The expression x^n is powering. * If the exponent n is an integer, then exact operations are performed using binary (left-shift) powering techniques. By definition, x0 is (an empty product interpreted as) an exact 1 in the underlying prime ring:
? 0.0 ^ 0 %1 = 1 ? (1 + O(2^3)) ^ 0 %2 = 1 ? (1 + O(x)) ^ 0 %3 = 1 ? Mod(2,4)^0 %4 = Mod(1,4) ? Mod(x,x^2)^0 %5 = Mod(1, x^2)
If x is a p-adic number, its precision will increase if vp(n) > 0 and
n ! = 0. Powering a binary quadratic form (type PARI rewrites the multiplication x * x of two identical objects as x2. Here, identical means the operands are reference the same chunk of memory; no equality test is performed. This is no longer true when more than two arguments are involved.
? a = 1 + O(2); b = a; ? a * a \\ = a^2, precision increases %2 = 1 + O(2^3) ? a * b \\ not rewritten as a^2 %3 = 1 + O(2) ? a*a*a \\ not rewritten as a^3 %4 = 1 + O(2) * If the exponent is a rational number p/q the behaviour depends on x. If x is a complex number, return exp(n log x) (principal branch), in an exact form if possible:
? 4^(1/2) \\ 4 being a square, this is exact %1 = 2 ? 2^(1/2) \\ now inexact %2 = 1.4142135623730950488016887242096980786 ? (-1/4)^(1/2) \\ exact again %3 = 1/2*I ? (-1)^(1/3) %4 = 0.500...+ 0.866...*I Note that even though -1 is an exact cube root of -1, it is not exp(log(-1)/3); the latter is returned. Otherwise return a solution y of yq = xp if it exists; beware that this is defined up to q-th roots of 1 in the base field. Intmods modulo composite numbers are not supported.
? 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(1,4)^(1/2) *** at top-level: Mod(1,4)^(1/2) *** ^ — — *** _^_: not a prime number in gpow: 4.
* If the exponent is a negative integer or rational number,
an inverse must be computed. For noninvertible
? 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 noninvertible
? 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 that 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 that 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
For a
? x = Mat([1;2]) %1 = [1] [2] ? x^(-1) %2 = [1 0] * Finally, if the exponent n is not an rational number, powering is treated as the transcendental function exp(nlog x), although it will be more precise than the latter when n and x are exact:
? s = 1/2 + 10^14 * I ? localprec(200); z = 2^s \\ for reference ? exponent(2^s - z) %3 = -127 \\ perfect ? exponent(exp(s * log(2)) - z) %4 = -84 \\ not so good The second computation is less precise because log(2) is first computed to 38 decimal digits, then multiplied by s, which has a huge imaginary part amplifying the error.
In this case, x
? 4 ^ 1.0 %1 = 4.0000000000000000000000000000000000000 ? 0^ 0.0 *** at top-level: 0^0.0 *** ^ — - *** _^_: domain error in gpow(0,n): n <= 0
The library syntax is
| |
cmp(x, y) | |
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
* two
* two
* two 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
The library syntax is
| |
divrem(x, y, {v}) | |
Creates a column vector with two components, the first being the Euclidean
quotient (
Beware that
? 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
| |
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; finally, when comparing two scalars, a complex number a + I*b is interpreted as a vector [a,b] and a real number a as [a,0]. 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 ? lex(2 - I, 1) %5 = 1 ? lex(2 - I, 2) %6 = -1
The library syntax is
| |
max(x, y) | |
Creates the maximum of x and y when they can be compared.
The library syntax is
| |
min(x, y) | |
Creates the minimum of x and y when they can be compared.
The library syntax is
| |
shift(x, n) | |
Shifts x componentwise left by n bits if n ≥ 0 and right by |n|
bits if n < 0. May be abbreviated as x
The library syntax is
| |
shiftmul(x, n) | |
Multiplies x by 2n. The difference with
The library syntax is
| |
sign(x) | |
sign (0, 1 or -1) of x, which must be of
type integer, real or fraction;
The library syntax is
| |
vecmax(x, {&v}) | |
If x is a list, vector or matrix, returns the largest entry of x,
otherwise returns a copy of x. Error if x is empty. Here, largest
refers to the ordinary real ordering ( If v is given, set it to the index of a largest entry (indirect maximum), when x is a vector or list. If x is a matrix, set v to coordinates [i,j] such that x[i,j] is a largest entry. This argument v is ignored for other types. When the vector has equal largest entries, the first occurence is chosen; in a matrix, the smallest j is chosen first, then the smallest i. 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
| |
vecmin(x, {&v}) | |
If x is a list, vector or matrix, returns the smallest entry of x,
otherwise returns a copy of x. Error if x is empty. Here, smallest
refers to the ordinary real ordering ( If v is given, set it to the index of a smallest entry (indirect minimum), when x is a vector or list. If x is a matrix, set v to coordinates [i,j] such that x[i,j] is a smallest entry. This argument v is ignored for other types. When a vector has equal smallest entries, the first occurence is chosen; in a matrix, the smallest j is chosen first, then the smallest i.
? 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] ? vecmin([1,0;0,0], &v); v %3 = [2, 1]
The library syntax is
| |