Sparse integer matrices#
AUTHORS:
William Stein (2007-02-21)
Soroosh Yazdani (2007-02-21)
- class sage.matrix.matrix_integer_sparse.Matrix_integer_sparse#
Bases:
Matrix_sparse
Create a sparse matrix over the integers.
INPUT:
parent
– a matrix space overZZ
entries
– seematrix()
copy
– ignored (for backwards compatibility)coerce
– if False, assume without checking that the entries are of typeInteger
.
- charpoly(var='x', algorithm=None)#
Return the characteristic polynomial of this matrix.
INPUT:
var
– (optional, default'x'
) the name of the variable of the polynomialalgorithm
– (optional, defaultNone
) one ofNone
,'linbox'
, or an algorithm accepted bysage.matrix.matrix_sparse.Matrix_sparse.charpoly()
EXAMPLES:
sage: M = MatrixSpace(ZZ, 4, sparse=True) sage: m = M() sage: m[0,0] = m[1,2] = m[2,3] = m[3,3] = 1 sage: m[0,2] = m[1,3] = m[2,0] = m[3,0] = -3 sage: m[1,1] = 2 sage: m [ 1 0 -3 0] [ 0 2 1 -3] [-3 0 0 1] [-3 0 0 1] sage: m.charpoly() x^4 - 4*x^3 - 4*x^2 + 16*x
- elementary_divisors(algorithm='pari')#
Return the elementary divisors of self, in order.
The elementary divisors are the invariants of the finite abelian group that is the cokernel of left multiplication by this matrix. They are ordered in reverse by divisibility.
INPUT:
self – matrix
algorithm – (default: ‘pari’)
‘pari’: works robustly, but is slower.
‘linbox’ – use linbox (currently off, broken)
OUTPUT:
list of integers
EXAMPLES:
sage: matrix(3, range(9),sparse=True).elementary_divisors() [1, 3, 0] sage: M = matrix(ZZ, 3, [1,5,7, 3,6,9, 0,1,2], sparse=True) sage: M.elementary_divisors() [1, 1, 6]
This returns a copy, which is safe to change:
sage: edivs = M.elementary_divisors() sage: edivs.pop() 6 sage: M.elementary_divisors() [1, 1, 6]
See also
- hermite_form(algorithm='default', cutoff=0, **kwds)#
Return the echelon form of
self
.Note
This row reduction does not use division if the matrix is not over a field (e.g., if the matrix is over the integers). If you want to calculate the echelon form using division, then use
rref()
, which assumes that the matrix entries are in a field (specifically, the field of fractions of the base ring of the matrix).INPUT:
algorithm
– string. Which algorithm to use. Choices are'default'
: Let Sage choose an algorithm (default).'classical'
: Gauss elimination.'partial_pivoting'
: Gauss elimination, using partial pivoting (if base ring has absolute value)'scaled_partial_pivoting'
: Gauss elimination, using scaled partial pivoting (if base ring has absolute value)'scaled_partial_pivoting_valuation'
: Gauss elimination, using scaled partial pivoting (if base ring has valuation)'strassen'
: use a Strassen divide and conquer algorithm (if available)
cutoff
– integer. Only used if the Strassen algorithm is selected.transformation
– boolean. Whether to also return the transformation matrix. Some matrix backends do not provide this information, in which case this option is ignored.
OUTPUT:
The reduced row echelon form of
self
, as an immutable matrix. Note that self is not changed by this command. Useechelonize()
to changeself
in place.If the optional parameter
transformation=True
is specified, the output consists of a pair \((E,T)\) of matrices where \(E\) is the echelon form ofself
and \(T\) is the transformation matrix.EXAMPLES:
sage: MS = MatrixSpace(GF(19), 2, 3) sage: C = MS.matrix([1,2,3,4,5,6]) sage: C.rank() 2 sage: C.nullity() 0 sage: C.echelon_form() [ 1 0 18] [ 0 1 2]
The matrix library used for \(\ZZ/p\)-matrices does not return the transformation matrix, so the
transformation
option is ignored:sage: C.echelon_form(transformation=True) [ 1 0 18] [ 0 1 2] sage: D = matrix(ZZ, 2, 3, [1,2,3,4,5,6]) sage: D.echelon_form(transformation=True) ( [1 2 3] [ 1 0] [0 3 6], [ 4 -1] ) sage: E, T = D.echelon_form(transformation=True) sage: T*D == E True
- minpoly(var='x', algorithm=None)#
Return the minimal polynomial of this matrix.
INPUT:
var
– (optional, default'x'
) the name of the variable of the polynomialalgorithm
– (optional, defaultNone
) one ofNone
,'linbox'
, or an algorithm accepted bysage.matrix.matrix_sparse.Matrix_sparse.minpoly()
EXAMPLES:
sage: M = MatrixSpace(ZZ, 4, sparse=True) sage: m = M({(0, 0):2, (1, 1):1, (2, 1):-8, (2, 2):2, (2, 3):-1, (3, 3):1}) sage: m [ 2 0 0 0] [ 0 1 0 0] [ 0 -8 2 -1] [ 0 0 0 1] sage: m.minpoly() x^2 - 3*x + 2
- rank(algorithm=None)#
Compute the rank of this matrix.
INPUT:
algorithm
– (optional) one ofNone
,'linbox'
or'generic'
EXAMPLES:
sage: M = MatrixSpace(ZZ, 3, 2, sparse=True) sage: m = M([1, 0, 2, 3, -1, 0]) sage: m.rank() 2
- rational_reconstruction(N)#
Use rational reconstruction to lift
self
to a matrix over the rational numbers (if possible), where we viewself
as a matrix modulo \(N\).EXAMPLES:
sage: A = matrix(ZZ, 3, 4, [(1/3)%500, 2, 3, (-4)%500, ....: 7, 2, 2, 3, ....: 4, 3, 4, (5/7)%500], sparse=True) sage: A.rational_reconstruction(500) [1/3 2 3 -4] [ 7 2 2 3] [ 4 3 4 5/7]
- smith_form(transformation=True, integral=None)#
Return the smith normal form of this matrix, that is the diagonal matrix \(S\) with diagonal entries the ordered elementary divisors of this matrix.
INPUT:
transformation
– a boolean (default:True
); whether to return the transformation matrices \(U\) and \(V\) such that \(S = U\cdot self\cdot V\).integral
– a subring of the base ring orTrue
(default:None
); ignored for matrices with integer entries.
This version is for sparse matrices and simply makes the matrix dense and calls the version for dense integer matrices.
Note
The
elementary_divisors()
function, which returns the diagonal entries of S, is VASTLY faster than this function.The elementary divisors are the invariants of the finite abelian group that is the cokernel of this matrix. They are ordered in reverse by divisibility.
EXAMPLES:
sage: A = MatrixSpace(IntegerRing(), 3, sparse=True)(range(9)) sage: D, U, V = A.smith_form() sage: D [1 0 0] [0 3 0] [0 0 0] sage: U [ 0 2 -1] [ 0 -1 1] [ 1 -2 1] sage: V [ 0 0 1] [-1 2 -2] [ 1 -1 1] sage: U*A*V [1 0 0] [0 3 0] [0 0 0]
It also makes sense for nonsquare matrices:
sage: A = Matrix(ZZ,3,2,range(6), sparse=True) sage: D, U, V = A.smith_form() sage: D [1 0] [0 2] [0 0] sage: U [ 0 2 -1] [ 0 -1 1] [ 1 -2 1] sage: V [-1 1] [ 1 0] sage: U * A * V [1 0] [0 2] [0 0]
The examples above show that github issue #10626 has been implemented.
See also