Matrices

overlaps(x::RealMatrix, y::RealMatrix)

Returns true if all entries of $x$ overlap with the corresponding entry of $y$, otherwise return false.

overlaps(x::ComplexMatrix, y::ComplexMatrix)

Returns true if all entries of $x$ overlap with the corresponding entry of $y$, otherwise return false.

contains(x::RealMatrix, y::RealMatrix)

Returns true if all entries of $x$ contain the corresponding entry of $y$, otherwise return false.

contains(x::ComplexMatrix, y::ComplexMatrix)

Returns true if all entries of $x$ contain the corresponding entry of $y$, otherwise return false.

<<(x::ZZMatrix, y::Int)

Return $2^yx$.

>>(x::ZZMatrix, y::Int)

Return $x/2^y$ where rounding is towards zero.

det_divisor(x::ZZMatrix)

Return some positive divisor of the determinant of $x$, if the determinant is nonzero, otherwise return zero.

det_given_divisor(x::ZZMatrix, d::Integer, proved=true)

Return the determinant of $x$ given a positive divisor of its determinant. If proved == true (the default), the output is guaranteed to be correct, otherwise a heuristic algorithm is used.

det_given_divisor(x::ZZMatrix, d::ZZRingElem, proved=true)

Return the determinant of $x$ given a positive divisor of its determinant. If proved == true (the default), the output is guaranteed to be correct, otherwise a heuristic algorithm is used.

pseudo_inv(x::ZZMatrix)

Return a tuple $(z, d)$ consisting of a matrix $z$ and denominator $d$ such that $z/d$ is the inverse of $x$.

Examples

julia> A = ZZ[1 0 1; 2 3 1; 5 6 7]
[1   0   1]
[2   3   1]
[5   6   7]

julia> B, d = pseudo_inv(A)
([15 6 -3; -9 2 1; -3 -6 3], 12)

nullspace_right_rational(x::ZZMatrix)

Return a tuple $(r, U)$ consisting of a matrix $U$ such that the first $r$ columns form the right rational nullspace of $x$, i.e. a set of vectors over $\mathbb{Z}$ giving a $\mathbb{Q}$-basis for the nullspace of $x$ considered as a matrix over $\mathbb{Q}$.

reduce_mod(x::ZZMatrix, y::Integer)

Reduce the entries of $x$ modulo $y$ and return the result.

reduce_mod(x::ZZMatrix, y::ZZRingElem)

Reduce the entries of $x$ modulo $y$ and return the result.

lift(a::T) where {T <: Zmodn_mat}

Return a lift of the matrix $a$ to a matrix over $\mathbb{Z}$, i.e. where the entries of the returned matrix are those of $a$ lifted to $\mathbb{Z}$.

lift(M::smodule{T}, SM::smodule{T}) where T

Represents the generators of SM in terms of the generators of M. If SM is in M, rest is the null module, otherwise rest = reduce(SM, std(M)). Returns (result, rest) with for global orderings: Matrix(SM) - Matrix(rest) = Matrix(M)*Matrix(result) for non-global orderings: Matrix(SM)*U - Matrix(rest) = Matrix(M)*Matrix(result) where U is some diagonal matrix of units. To compute this U, see lift(M::smodule, SM::smodule, goodShape::Bool, isSB::Bool, divide::Bool).

lift(M::smodule{T}, SM::smodule{T}, goodShape::Bool, isSB::Bool, divide::Bool) where T

Represents the generators of SM in terms of the generators of M. Returns (result, rest, U) with Matrix(SM)*U - Matrix(rest) = Matrix(M)*Matrix(result) If SM is in M, then rest is the null module. Otherwise, rest = SM if !divide, and rest = normalform(SM, std(M)) if divide. U is a diagonal matrix of units, differing from the identity matrix only for local ring orderings.

There are three boolean options. goodShape: maximal non-zero index in generators of SM <= that of M, which should be come from a rank check rank(SM)==rank(M). isSB: generators of M form a Groebner basis. divide: allow SM not to be a submodule of M.

lift(M::sideal{T}, SM::sideal{T}) where T

Represents the generators of SM in terms of the generators of M. If SM is in M, rest is the null module, otherwise rest = reduce(SM, std(M)). Returns (result, rest) with for global orderings: Matrix(SM) - Matrix(rest) = Matrix(M)*Matrix(result) for non-global orderings: Matrix(SM)*U - Matrix(rest) = Matrix(M)*Matrix(result) where U is some diagonal matrix of units. To compute this U, see lift(M::sideal, SM::sideal, goodShape::Bool, isSB::Bool, divide::Bool).

lift(M::sideal{T}, SM::sideal{T}, goodShape::Bool, isSB::Bool, divide::Bool) where T

Represents the generators of SM in terms of the generators of M. Returns (result, rest, U) with Matrix(SM)*U - Matrix(rest) = Matrix(M)*Matrix(result) If SM is in M, then rest is the null module. Otherwise, rest = SM if !divide, and rest = normalform(SM, std(M)) if divide. U is a diagonal matrix of units, differing from the identity matrix only for local ring orderings.

There are three boolean options. goodShape: maximal non-zero index in generators of SM <= that of M, which should be come from a rank check rank(SM)==rank(M). isSB: generators of M form a Groebner basis divide: allow SM not to be a submodule of M, which is useful for division with remainder.

lift(a::T) where {T <: Zmodn_mat}

Return a lift of the matrix $a$ to a matrix over $\mathbb{Z}$, i.e. where the entries of the returned matrix are those of $a$ lifted to $\mathbb{Z}$.

lift(M::smodule{T}, SM::smodule{T}) where T

Represents the generators of SM in terms of the generators of M. If SM is in M, rest is the null module, otherwise rest = reduce(SM, std(M)). Returns (result, rest) with for global orderings: Matrix(SM) - Matrix(rest) = Matrix(M)*Matrix(result) for non-global orderings: Matrix(SM)*U - Matrix(rest) = Matrix(M)*Matrix(result) where U is some diagonal matrix of units. To compute this U, see lift(M::smodule, SM::smodule, goodShape::Bool, isSB::Bool, divide::Bool).

lift(M::smodule{T}, SM::smodule{T}, goodShape::Bool, isSB::Bool, divide::Bool) where T

Represents the generators of SM in terms of the generators of M. Returns (result, rest, U) with Matrix(SM)*U - Matrix(rest) = Matrix(M)*Matrix(result) If SM is in M, then rest is the null module. Otherwise, rest = SM if !divide, and rest = normalform(SM, std(M)) if divide. U is a diagonal matrix of units, differing from the identity matrix only for local ring orderings.

There are three boolean options. goodShape: maximal non-zero index in generators of SM <= that of M, which should be come from a rank check rank(SM)==rank(M). isSB: generators of M form a Groebner basis. divide: allow SM not to be a submodule of M.

lift(M::sideal{T}, SM::sideal{T}) where T

Represents the generators of SM in terms of the generators of M. If SM is in M, rest is the null module, otherwise rest = reduce(SM, std(M)). Returns (result, rest) with for global orderings: Matrix(SM) - Matrix(rest) = Matrix(M)*Matrix(result) for non-global orderings: Matrix(SM)*U - Matrix(rest) = Matrix(M)*Matrix(result) where U is some diagonal matrix of units. To compute this U, see lift(M::sideal, SM::sideal, goodShape::Bool, isSB::Bool, divide::Bool).

lift(M::sideal{T}, SM::sideal{T}, goodShape::Bool, isSB::Bool, divide::Bool) where T

Represents the generators of SM in terms of the generators of M. Returns (result, rest, U) with Matrix(SM)*U - Matrix(rest) = Matrix(M)*Matrix(result) If SM is in M, then rest is the null module. Otherwise, rest = SM if !divide, and rest = normalform(SM, std(M)) if divide. U is a diagonal matrix of units, differing from the identity matrix only for local ring orderings.

There are three boolean options. goodShape: maximal non-zero index in generators of SM <= that of M, which should be come from a rank check rank(SM)==rank(M). isSB: generators of M form a Groebner basis divide: allow SM not to be a submodule of M, which is useful for division with remainder.

hadamard(R::ZZMatrixSpace)

Return the Hadamard matrix for the given matrix space. The number of rows and columns must be equal.

is_hadamard(x::ZZMatrix)

Return true if the given matrix is Hadamard, otherwise return false.

hilbert(R::QQMatrixSpace)

Return the Hilbert matrix in the given matrix space. This is the matrix with entries $H_{i,j} = 1/(i + j - 1)$.

hnf(x::ZZMatrix)

Return the Hermite Normal Form of $x$.

hnf_with_transform(x::ZZMatrix)

Compute a tuple $(H, T)$ where $H$ is the Hermite normal form of $x$ and $T$ is a transformation matrix so that $H = Tx$.

hnf_modular(x::ZZMatrix, d::ZZRingElem)

Compute the Hermite normal form of $x$ given that $d$ is a multiple of the determinant of the nonzero rows of $x$.

hnf_modular_eldiv(x::ZZMatrix, d::ZZRingElem)

Compute the Hermite normal form of $x$ given that $d$ is a multiple of the largest elementary divisor of $x$. The matrix $x$ must have full rank.

is_hnf(x::ZZMatrix)

Return true if the given matrix is in Hermite Normal Form, otherwise return false.

lll(x::ZZMatrix, ctx::LLLContext = LLLContext(0.99, 0.51))

Return a matrix $L$ whose rows form an LLL-reduced basis of the $\mathbb{Z}$-lattice generated by the rows of $x$. $L$ may contain additional zero rows.

By default, the LLL is performed with reduction parameters $\delta = 0.99$ and $\eta = 0.51$. These defaults can be overridden by specifying an optional context object.

See lll_gram for a function taking the Gram matrix as input.

lll_with_transform(x::ZZMatrix, ctx::LLLContext = LLLContext(0.99, 0.51))

Return a tuple $(L, T)$ where the rows of $L$ form an LLL-reduced basis of the $\mathbb{Z}$-lattice generated by the rows of $x$ and $T$ is a transformation matrix so that $L = Tx$. $L$ may contain additional zero rows. See lll for the used default parameters which can be overridden by supplying an optional context object.

See lll_gram_with_transform for a function taking the Gram matrix as input.

lll_gram(x::ZZMatrix, ctx::LLLContext = LLLContext(0.99, 0.51, :gram))

Return the Gram matrix $L$ of an LLL-reduced basis of the lattice given by the Gram matrix $x$. The matrix $x$ must be symmetric and non-singular.

By default, the LLL is performed with reduction parameters $\delta = 0.99$ and $\eta = 0.51$. These defaults can be overridden by specifying an optional context object.

lll_gram_with_transform(x::ZZMatrix, ctx::LLLContext = LLLContext(0.99, 0.51, :gram))

Return a tuple $(L, T)$ where $L$ is the Gram matrix of an LLL-reduced basis of the lattice given by the Gram matrix $x$ and $T$ is a transformation matrix with $L = T^\top x T$. The matrix $x$ must be symmetric and non-singular.

See lll_gram for the used default parameters which can be overridden by supplying an optional context object.

lll_with_removal(x::ZZMatrix, b::ZZRingElem, ctx::LLLContext = LLLContext(0.99, 0.51))

Compute the LLL reduction of $x$ and throw away rows whose norm exceeds the given bound $b$. Return a tuple $(r, L)$ where the first $r$ rows of $L$ are the rows remaining after removal.

lll_with_removal_transform(x::ZZMatrix, b::ZZRingElem, ctx::LLLContext = LLLContext(0.99, 0.51))

Compute a tuple $(r, L, T)$ where the first $r$ rows of $L$ are those remaining from the LLL reduction after removal of vectors with norm exceeding the bound $b$ and $T$ is a transformation matrix so that $L = Tx$.

lll!(x::ZZMatrix, ctx::LLLContext = LLLContext(0.99, 0.51))

Compute an LLL-reduced basis of the $\mathbb{Z}$-lattice generated by the rows of $x$ inplace.

By default, the LLL is performed with reduction parameters $\delta = 0.99$ and $\eta = 0.51$. These defaults can be overridden by specifying an optional context object.

See lll_gram! for a function taking the Gram matrix as input.

lll_gram!(x::ZZMatrix, ctx::LLLContext = LLLContext(0.99, 0.51, :gram))

Compute the Gram matrix of an LLL-reduced basis of the lattice given by the Gram matrix $x$ inplace. The matrix $x$ must be symmetric and non-singular.

By default, the LLL is performed with reduction parameters $\delta = 0.99$ and $\eta = 0.51$. These defaults can be overridden by specifying an optional context object.

snf(x::ZZMatrix)

Compute the Smith normal form of $x$.

snf_diagonal(x::ZZMatrix)

Given a diagonal matrix $x$ compute the Smith normal form of $x$.

is_snf(x::ZZMatrix)

Return true if $x$ is in Smith normal form, otherwise return false.

strong_echelon_form(a::zzModMatrix)

Return the strong echeleon form of $a$. The matrix $a$ must have at least as many rows as columns.

strong_echelon_form(a::fpMatrix)

Return the strong echeleon form of $a$. The matrix $a$ must have at least as many rows as columns.

howell_form(a::zzModMatrix)

Return the Howell normal form of $a$. The matrix $a$ must have at least as many rows as columns.

howell_form(a::fpMatrix)

Return the Howell normal form of $a$. The matrix $a$ must have at least as many rows as columns.

gram_schmidt_orthogonalisation(x::QQMatrix)

Takes the columns of $x$ as the generators of a subset of $\mathbb{Q}^m$ and returns a matrix whose columns are an orthogonal generating set for the same subspace.

Examples

julia> S = matrix_space(QQ, 3, 3);

julia> A = S([4 7 3; 2 9 1; 0 5 3])
[4   7   3]
[2   9   1]
[0   5   3]

julia> B = gram_schmidt_orthogonalisation(A)
[4   -11//5     95//123]
[2    22//5   -190//123]
[0        5    209//123]

bound_inf_norm(x::RealMatrix)

Returns a non-negative element $z$ of type ArbFieldElem, such that $z$ is an upper bound for the infinity norm for every matrix in $x$

bound_inf_norm(x::ComplexMatrix)

Returns a non-negative element $z$ of type AcbFieldElem, such that $z$ is an upper bound for the infinity norm for every matrix in $x$

eigenvalues(A::ComplexMatrix)

Return the eigenvalues of A.

This function is experimental.

eigenvalues_with_multiplicities(A::ComplexMatrix)

Return the eigenvalues of A with their algebraic multiplicities as a vector of tuples (ComplexFieldElem, Int). Each tuple (z, k) corresponds to a cluster of k eigenvalues of $A$.

This function is experimental.

eigenvalues_simple(A::ComplexMatrix, algorithm::Symbol = :default)

Returns the eigenvalues of A as a vector of AcbFieldElem. It is assumed that A has only simple eigenvalues.

The algorithm used can be changed by setting the algorithm keyword to :vdhoeven_mourrain or :rump.

This function is experimental.