[Next] [Prev] [Right] [Left] [Up] [Index] [Root]
Element Operations

Element Operations

Subsections

Arithmetic Operations

The only extraordinary arithmetic operations on integers are mod and div.

+ n : RngIntElt -> RngIntElt
- n : RngIntElt -> RngIntElt
m + n : RngIntElt, RngIntElt -> RngIntElt
m - n : RngIntElt, RngIntElt -> RngIntElt
m * n : RngIntElt, RngIntElt -> RngIntElt
n ^ k : RngIntElt, RngIntElt -> RngIntElt
m / n : RngIntElt, RngIntElt -> RngIntElt
m +:= n : RngIntElt, RngIntElt -> RngIntElt
m -:= n : RngIntElt, RngIntElt -> RngIntElt
m *:= n : RngIntElt, RngIntElt -> RngIntElt
m /:= n : RngIntElt, RngIntElt -> RngIntElt
m ^:= k : RngIntElt, RngIntElt -> RngIntElt
n div:= m : RngIntElt, RngIntElt -> RngIntElt
n mod:= m : RngIntElt, RngIntElt -> RngIntElt
n div m : RngIntElt, RngIntElt -> RngIntElt
The quotient q of the division with remainder n=qm + r, where 0 <= r<m or m<r <= 0 (depending on the sign of m), for integers n and m != 0.
n mod m : RngIntElt, RngIntElt -> RngIntElt
The remainder r of the division with remainder n=qm + r, where 0 <= r<m or m<r <= 0 (depending on the sign of m), for integers n and m != 0.
ExactQuotient(n, d) : RngIntElt, RngIntElt -> RngIntElt
Assuming that the integer n is exactly divisible by the integer d, return the exact quotient of n by d (as an integer). An error results if d does not divide n exactly.

Equality and Membership

m eq n : RngIntElt, RngIntElt -> BoolElt
m ne n : RngInRngIntt, RngIntElt -> BoolElt
n in R : RngIntElt, Rng -> BoolElt
n notin R : RngIntElt, Rng -> BoolElt

Parent and Category

Parent(n) : RngIntElt -> RngInt
Category(n) : RngIntElt -> Cat

Predicates on Ring Elements

IsZero(n) : RngIntElt -> BoolElt
IsOne(n) : RngIntElt -> BoolElt
IsMinusOne(n) : RngIntElt -> BoolElt
IsNilpotent(n) : RngIntElt -> BoolElt
IsIdempotent(n) : RngIntElt -> BoolElt
IsUnit(n) : RngIntElt -> BoolElt
IsZeroDivisor(n) : RngIntElt -> BoolElt
IsRegular(n) : RngInt -> BoolElt
IsIrreducible(n) : RngIntElt -> BoolElt
IsPrime(n) : RngIntElt -> BoolElt
IsEven(n) : RngIntElt -> BoolElt
True if the integer n is even, otherwise false.
IsOdd(n) : RngIntElt -> BoolElt
True if the integer n is odd, otherwise false.
IsDivisibleBy(n, d) : RngIntElt, RngIntElt -> BoolElt, RngIntElt
True if and only if the integer n is divisible by the integer d; if true, the quotient of n by d is also returned.
IsSquare(n) : RngIntElt -> BoolElt, RngIntElt
True if the non-negative integer n is the square of an integer, false otherwise. If n is a square, its positive square root is also returned.
IsSquareFree(n) : RngIntElt -> BoolElt
True if the non-zero integer n is not divisible by the square of any prime, false otherwise.
IsPower(n) : RngIntElt -> BoolElt
If the integer n>1 is a power n=b^k of an integer b, with k>1, this function returns true, the minimal positive b and its associated k; if it is not such integer power the function returns false.
IsPower(n, k) : RngIntElt -> BoolElt
If the integer n>1 is k-th power (k>1) of some integer b, so n=b^k, this function returns true, and b; if it is not a k-th integer power the function returns false.
IsPrime(n) : RngIntElt -> BoolElt
    Proof: BoolElt                      Default: true
True iff the integer n is a prime. A rigorous primality test and proof will be used (unless the parameter Proof is false; see the section on Primes and Factorization for a complete description of this function).

Example RngInt_IsPrime (H24E3)

Find some 10-digit primes that are 3 modulo 4 such that (p - 1)/2 is also prime:

> { p : p in [10^10+3..10^10+1000 by 4] |
>        IsPrime(p) and IsPrime((p-1) div 2) };
{ 10000000259, 10000000643 }

IsIntegral(n) : RngIntElt -> BoolElt
Returns true if and only if a is integral, which is of course true for every integer n.
IsSinglePrecision(n) : RngIntElt -> BoolElt
Returns true if n fits in a single word in the internal representation of integers in Magma, that is, if | n|<2^(30), false otherwise.

Comparison of Ring Elements

m gt n : RngIntElt, RngIntElt -> BoolElt
m ge n : RngIntElt, RngIntElt -> BoolElt
m lt n : RngIntElt, RngIntElt -> BoolElt
m le n : RngIntElt, RngIntElt -> BoolElt
Maximum(m, n) : RngIntElt, RngIntElt -> RngIntElt
Maximum(Q) : [RngIntElt] -> RngIntElt
Minimum(m, n) : RngIntElt, RngIntElt -> RngIntElt
Minimum(Q) : [RngIntElt] -> RngIntElt

Conjugates, Norm and Trace

ComplexConjugate(n) : RngIntElt -> RngIntElt
The complex conjugate of n, which will be the integer n itself.
Conjugate(n) : RngIntElt -> RngIntElt
The conjugate of n, which will be the integer n itself.
Norm(n) : RngIntElt -> RngIntElt
The norm (in Q) of n, which will be the integer n itself.
EuclideanNorm(n) : RngIntElt -> RngIntElt
The Euclidean norm (length) of n, which will equal the absolute value of n.
Trace(n) : RngIntElt -> RngIntElt
The trace (in Q) of n, which will be the integer n itself.
MinimalPolynomial(n) : RngIntElt -> RngUPolElt
Returns the minimal polynomial of the integer n, which is the monic linear polynomial with constant coefficient n in a univariate polynomial ring R over the integers. (If R has not been created before with a name for its indeterminate, $.1-n will be returned.)

Other Elementary Functions

AbsoluteValue(n) : RngIntElt -> RngIntElt
Abs(n) : RngIntElt -> RngIntElt
Absolute value of the integer n.
Ilog2(n) : RngIntElt -> RngIntElt
The integral part of the logarithm to the base two of the positive integer n.
Ilog(b, n) : RngIntElt, RngIntElt -> RngIntElt
The integral part of the logarithm to the base b of the positive integer n (i.e., the largest integer k such that b^k <= n). b must be greater than or equal to two.
Quotrem(m, n) : RngIntElt, RngIntElt -> RngIntElt, RngIntElt
Returns both the quotient q and remainder r obtained upon dividing the integer m by the integer n, that is, m = q.n + r, with 0 <= r < |n|.
Valuation(x, p) : RngIntElt, RngIntElt -> RngIntElt, RngIntElt
The valuation of the integer x at the prime p. This is the largest integer v for which p^v divides x. If x = 0 then v = Infinity. The optional second return value is the integer u such that x = p^v u.
Random(a, b) : RngIntElt, RngIntElt -> RngIntElt
A random integer lying in the interval [a, b], where a, b are positive integers and a <= b.
Random(b) : RngIntElt -> RngIntElt
A random integer lying in the interval [0, b], where b is a positive integer.
RandomBits(n) : RngIntElt -> RngIntElt
A random integer m such that 0 <= m < 2^n, where n is a small positive integer (i.e. so m has n random bits with a probability of 1/2 for each bit).
RandomConsecutiveBits(n, a, b) : RngIntElt, RngIntElt -> RngIntElt
A integer m such that 0 <= m < 2^n, and the binary expansion of n consists of consecutive strings of zeros or ones each of random length in the range [a ... b].
Iroot(a, n) : RngIntElt, RngIntElt -> RngIntElt
Given a positive integer a, return the integer b= Floor(root n of a), i.e. the integral part of the n-th root of a. (To obtain the root itself (as a real number), a has to be coerced into a real field, and Root can be applied.)
Sign(n) : RngIntElt -> RngIntElt
Returns -1, 0 or 1 depending upon whether the integer n is negative, zero or positive, respectively.
Ceiling(n) : RngIntElt -> RngIntElt
The ceiling of the integer n, that is, n itself.
Floor(n) : RngIntElt -> RngIntElt
The floor of the integer n, that is, n itself.
Round(n) : RngIntElt -> RngIntElt
This function rounds the integer n to itself.
Truncate(n) : RngIntElt -> RngIntElt
This function returns the integer truncation of the integer n, that is, n itself.
SquareFreeFactorization(n) : RngIntElt -> RngIntElt, RngIntElt
SquareFree(n) : RngIntElt -> RngIntElt, RngIntElt
Given a non-negative integer n, return a squarefree integer x as well as a positive integer y, such that n=xy^2.
Isqrt(n) : RngIntElt -> RngIntElt
Given a positive integer n, return the integer Floor(sqrt n), i.e., the integral part of the square root of the integer n.
[Next] [Prev] [Right] [Left] [Up] [Index] [Root]