Common Matrices¶
MatrixCommon Class Reference¶
-
class
sympy.matrices.common.
MatrixCommon
[source]¶ All common matrix operations including basic arithmetic, shaping, and special matrices like \(zeros\), and \(eye\).
-
C
¶ By-element conjugation.
-
H
¶ Return Hermite conjugate.
Examples
>>> from sympy import Matrix, I >>> m = Matrix((0, 1 + I, 2, 3)) >>> m Matrix([ [ 0], [1 + I], [ 2], [ 3]]) >>> m.H Matrix([[0, 1 - I, 2, 3]])
See also
conjugate
By-element conjugation
D
Dirac conjugation
-
T
¶ Matrix transposition.
-
adjoint
()¶ Conjugate transpose or Hermitian conjugation.
-
applyfunc
(f)¶ Apply a function to each element of the matrix.
Examples
>>> from sympy import Matrix >>> m = Matrix(2, 2, lambda i, j: i*2+j) >>> m Matrix([ [0, 1], [2, 3]]) >>> m.applyfunc(lambda i: 2*i) Matrix([ [0, 2], [4, 6]])
-
as_real_imag
()¶ Returns a tuple containing the (real, imaginary) part of matrix.
-
atoms
(*types)¶ Returns the atoms that form the current object.
Examples
>>> from sympy.abc import x, y >>> from sympy.matrices import Matrix >>> Matrix([[x]]) Matrix([[x]]) >>> _.atoms() {x}
-
col
(j)¶ Elementary column selector.
Examples
>>> from sympy import eye >>> eye(2).col(0) Matrix([ [1], [0]])
See also
row
,col_op
,col_swap
,col_del
,col_join
,col_insert
-
col_del
(col)¶ Delete the specified column.
-
col_insert
(pos, other)¶ Insert one or more columns at the given column position.
Examples
>>> from sympy import zeros, ones >>> M = zeros(3) >>> V = ones(3, 1) >>> M.col_insert(1, V) Matrix([ [0, 1, 0, 0], [0, 1, 0, 0], [0, 1, 0, 0]])
See also
-
col_join
(other)¶ Concatenates two matrices along self’s last and other’s first row.
Examples
>>> from sympy import zeros, ones >>> M = zeros(3) >>> V = ones(1, 3) >>> M.col_join(V) Matrix([ [0, 0, 0], [0, 0, 0], [0, 0, 0], [1, 1, 1]])
-
conjugate
()¶ Return the by-element conjugation.
Examples
>>> from sympy.matrices import SparseMatrix >>> from sympy import I >>> a = SparseMatrix(((1, 2 + I), (3, 4), (I, -I))) >>> a Matrix([ [1, 2 + I], [3, 4], [I, -I]]) >>> a.C Matrix([ [ 1, 2 - I], [ 3, 4], [-I, I]])
-
classmethod
diag
(*args, **kwargs)¶ Returns a matrix with the specified diagonal. If matrices are passed, a block-diagonal matrix is created.
Kwargs
- rowsrows of the resulting matrix; computed if
not given.
- colscolumns of the resulting matrix; computed if
not given.
cls : class for the resulting matrix
Examples
>>> from sympy.matrices import Matrix >>> Matrix.diag(1, 2, 3) Matrix([ [1, 0, 0], [0, 2, 0], [0, 0, 3]]) >>> Matrix.diag([1, 2, 3]) Matrix([ [1, 0, 0], [0, 2, 0], [0, 0, 3]])
The diagonal elements can be matrices; diagonal filling will continue on the diagonal from the last element of the matrix:
>>> from sympy.abc import x, y, z >>> a = Matrix([x, y, z]) >>> b = Matrix([[1, 2], [3, 4]]) >>> c = Matrix([[5, 6]]) >>> Matrix.diag(a, 7, b, c) Matrix([ [x, 0, 0, 0, 0, 0], [y, 0, 0, 0, 0, 0], [z, 0, 0, 0, 0, 0], [0, 7, 0, 0, 0, 0], [0, 0, 1, 2, 0, 0], [0, 0, 3, 4, 0, 0], [0, 0, 0, 0, 5, 6]])
A given band off the diagonal can be made by padding with a vertical or horizontal “kerning” vector:
>>> hpad = Matrix(0, 2, []) >>> vpad = Matrix(2, 0, []) >>> Matrix.diag(vpad, 1, 2, 3, hpad) + Matrix.diag(hpad, 4, 5, 6, vpad) Matrix([ [0, 0, 4, 0, 0], [0, 0, 0, 5, 0], [1, 0, 0, 0, 6], [0, 2, 0, 0, 0], [0, 0, 3, 0, 0]])
The type of the resulting matrix can be affected with the
cls
keyword.>>> type(Matrix.diag(1)) <class 'sympy.matrices.dense.MutableDenseMatrix'> >>> from sympy.matrices import ImmutableMatrix >>> type(Matrix.diag(1, cls=ImmutableMatrix)) <class 'sympy.matrices.immutable.ImmutableDenseMatrix'>
-
evalf
(prec=None, **options)¶ Apply evalf() to each element of self.
-
expand
(deep=True, modulus=None, power_base=True, power_exp=True, mul=True, log=True, multinomial=True, basic=True, **hints)¶ Apply core.function.expand to each entry of the matrix.
Examples
>>> from sympy.abc import x >>> from sympy.matrices import Matrix >>> Matrix(1, 1, [x*(x+1)]) Matrix([[x*(x + 1)]]) >>> _.expand() Matrix([[x**2 + x]])
-
extract
(rowsList, colsList)¶ Return a submatrix by specifying a list of rows and columns. Negative indices can be given. All indices must be in the range -n <= i < n where n is the number of rows or columns.
Examples
>>> from sympy import Matrix >>> m = Matrix(4, 3, range(12)) >>> m Matrix([ [0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]) >>> m.extract([0, 1, 3], [0, 1]) Matrix([ [0, 1], [3, 4], [9, 10]])
Rows or columns can be repeated:
>>> m.extract([0, 0, 1], [-1]) Matrix([ [2], [2], [5]])
Every other row can be taken by using range to provide the indices:
>>> m.extract(range(0, m.rows, 2), [-1]) Matrix([ [2], [8]])
RowsList or colsList can also be a list of booleans, in which case the rows or columns corresponding to the True values will be selected:
>>> m.extract([0, 1, 2, 3], [True, False, True]) Matrix([ [0, 2], [3, 5], [6, 8], [9, 11]])
-
classmethod
eye
(rows, cols=None, **kwargs)¶ Returns an identity matrix.
Args
rows : rows of the matrix cols : cols of the matrix (if None, cols=rows)
Kwargs
cls : class of the returned matrix
-
free_symbols
¶ Returns the free symbols within the matrix.
Examples
>>> from sympy.abc import x >>> from sympy.matrices import Matrix >>> Matrix([[x], [1]]).free_symbols {x}
-
get_diag_blocks
()¶ Obtains the square sub-matrices on the main diagonal of a square matrix.
Useful for inverting symbolic matrices or solving systems of linear equations which may be decoupled by having a block diagonal structure.
Examples
>>> from sympy import Matrix >>> from sympy.abc import x, y, z >>> A = Matrix([[1, 3, 0, 0], [y, z*z, 0, 0], [0, 0, x, 0], [0, 0, 0, 0]]) >>> a1, a2, a3 = A.get_diag_blocks() >>> a1 Matrix([ [1, 3], [y, z**2]]) >>> a2 Matrix([[x]]) >>> a3 Matrix([[0]])
-
has
(*patterns)¶ Test whether any subexpression matches any of the patterns.
Examples
>>> from sympy import Matrix, SparseMatrix, Float >>> from sympy.abc import x, y >>> A = Matrix(((1, x), (0.2, 3))) >>> B = SparseMatrix(((1, x), (0.2, 3))) >>> A.has(x) True >>> A.has(y) False >>> A.has(Float) True >>> B.has(x) True >>> B.has(y) False >>> B.has(Float) True
-
classmethod
hstack
(*args)¶ Return a matrix formed by joining args horizontally (i.e. by repeated application of row_join).
Examples
>>> from sympy.matrices import Matrix, eye >>> Matrix.hstack(eye(2), 2*eye(2)) Matrix([ [1, 0, 2, 0], [0, 1, 0, 2]])
-
is_anti_symmetric
(simplify=True)¶ Check if matrix M is an antisymmetric matrix, that is, M is a square matrix with all M[i, j] == -M[j, i].
When
simplify=True
(default), the sum M[i, j] + M[j, i] is simplified before testing to see if it is zero. By default, the SymPy simplify function is used. To use a custom function set simplify to a function that accepts a single argument which returns a simplified expression. To skip simplification, set simplify to False but note that although this will be faster, it may induce false negatives.Examples
>>> from sympy import Matrix, symbols >>> m = Matrix(2, 2, [0, 1, -1, 0]) >>> m Matrix([ [ 0, 1], [-1, 0]]) >>> m.is_anti_symmetric() True >>> x, y = symbols('x y') >>> m = Matrix(2, 3, [0, 0, x, -y, 0, 0]) >>> m Matrix([ [ 0, 0, x], [-y, 0, 0]]) >>> m.is_anti_symmetric() False
>>> from sympy.abc import x, y >>> m = Matrix(3, 3, [0, x**2 + 2*x + 1, y, ... -(x + 1)**2 , 0, x*y, ... -y, -x*y, 0])
Simplification of matrix elements is done by default so even though two elements which should be equal and opposite wouldn’t pass an equality test, the matrix is still reported as anti-symmetric:
>>> m[0, 1] == -m[1, 0] False >>> m.is_anti_symmetric() True
If ‘simplify=False’ is used for the case when a Matrix is already simplified, this will speed things up. Here, we see that without simplification the matrix does not appear anti-symmetric:
>>> m.is_anti_symmetric(simplify=False) False
But if the matrix were already expanded, then it would appear anti-symmetric and simplification in the is_anti_symmetric routine is not needed:
>>> m = m.expand() >>> m.is_anti_symmetric(simplify=False) True
-
is_diagonal
()¶ Check if matrix is diagonal, that is matrix in which the entries outside the main diagonal are all zero.
Examples
>>> from sympy import Matrix, diag >>> m = Matrix(2, 2, [1, 0, 0, 2]) >>> m Matrix([ [1, 0], [0, 2]]) >>> m.is_diagonal() True
>>> m = Matrix(2, 2, [1, 1, 0, 2]) >>> m Matrix([ [1, 1], [0, 2]]) >>> m.is_diagonal() False
>>> m = diag(1, 2, 3) >>> m Matrix([ [1, 0, 0], [0, 2, 0], [0, 0, 3]]) >>> m.is_diagonal() True
-
is_hermitian
¶ Checks if the matrix is Hermitian.
In a Hermitian matrix element i,j is the complex conjugate of element j,i.
Examples
>>> from sympy.matrices import Matrix >>> from sympy import I >>> from sympy.abc import x >>> a = Matrix([[1, I], [-I, 1]]) >>> a Matrix([ [ 1, I], [-I, 1]]) >>> a.is_hermitian True >>> a[0, 0] = 2*I >>> a.is_hermitian False >>> a[0, 0] = x >>> a.is_hermitian >>> a[0, 1] = a[1, 0]*I >>> a.is_hermitian False
-
is_lower
¶ Check if matrix is a lower triangular matrix. True can be returned even if the matrix is not square.
Examples
>>> from sympy import Matrix >>> m = Matrix(2, 2, [1, 0, 0, 1]) >>> m Matrix([ [1, 0], [0, 1]]) >>> m.is_lower True
>>> m = Matrix(4, 3, [0, 0, 0, 2, 0, 0, 1, 4 , 0, 6, 6, 5]) >>> m Matrix([ [0, 0, 0], [2, 0, 0], [1, 4, 0], [6, 6, 5]]) >>> m.is_lower True
>>> from sympy.abc import x, y >>> m = Matrix(2, 2, [x**2 + y, y**2 + x, 0, x + y]) >>> m Matrix([ [x**2 + y, x + y**2], [ 0, x + y]]) >>> m.is_lower False
See also
-
is_lower_hessenberg
¶ Checks if the matrix is in the lower-Hessenberg form.
The lower hessenberg matrix has zero entries above the first superdiagonal.
Examples
>>> from sympy.matrices import Matrix >>> a = Matrix([[1, 2, 0, 0], [5, 2, 3, 0], [3, 4, 3, 7], [5, 6, 1, 1]]) >>> a Matrix([ [1, 2, 0, 0], [5, 2, 3, 0], [3, 4, 3, 7], [5, 6, 1, 1]]) >>> a.is_lower_hessenberg True
See also
-
is_square
¶ Checks if a matrix is square.
A matrix is square if the number of rows equals the number of columns. The empty matrix is square by definition, since the number of rows and the number of columns are both zero.
Examples
>>> from sympy import Matrix >>> a = Matrix([[1, 2, 3], [4, 5, 6]]) >>> b = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> c = Matrix([]) >>> a.is_square False >>> b.is_square True >>> c.is_square True
-
is_symbolic
()¶ Checks if any elements contain Symbols.
Examples
>>> from sympy.matrices import Matrix >>> from sympy.abc import x, y >>> M = Matrix([[x, y], [1, 0]]) >>> M.is_symbolic() True
-
is_symmetric
(simplify=True)¶ Check if matrix is symmetric matrix, that is square matrix and is equal to its transpose.
By default, simplifications occur before testing symmetry. They can be skipped using ‘simplify=False’; while speeding things a bit, this may however induce false negatives.
Examples
>>> from sympy import Matrix >>> m = Matrix(2, 2, [0, 1, 1, 2]) >>> m Matrix([ [0, 1], [1, 2]]) >>> m.is_symmetric() True
>>> m = Matrix(2, 2, [0, 1, 2, 0]) >>> m Matrix([ [0, 1], [2, 0]]) >>> m.is_symmetric() False
>>> m = Matrix(2, 3, [0, 0, 0, 0, 0, 0]) >>> m Matrix([ [0, 0, 0], [0, 0, 0]]) >>> m.is_symmetric() False
>>> from sympy.abc import x, y >>> m = Matrix(3, 3, [1, x**2 + 2*x + 1, y, (x + 1)**2 , 2, 0, y, 0, 3]) >>> m Matrix([ [ 1, x**2 + 2*x + 1, y], [(x + 1)**2, 2, 0], [ y, 0, 3]]) >>> m.is_symmetric() True
If the matrix is already simplified, you may speed-up is_symmetric() test by using ‘simplify=False’.
>>> bool(m.is_symmetric(simplify=False)) False >>> m1 = m.expand() >>> m1.is_symmetric(simplify=False) True
-
is_upper
¶ Check if matrix is an upper triangular matrix. True can be returned even if the matrix is not square.
Examples
>>> from sympy import Matrix >>> m = Matrix(2, 2, [1, 0, 0, 1]) >>> m Matrix([ [1, 0], [0, 1]]) >>> m.is_upper True
>>> m = Matrix(4, 3, [5, 1, 9, 0, 4 , 6, 0, 0, 5, 0, 0, 0]) >>> m Matrix([ [5, 1, 9], [0, 4, 6], [0, 0, 5], [0, 0, 0]]) >>> m.is_upper True
>>> m = Matrix(2, 3, [4, 2, 5, 6, 1, 1]) >>> m Matrix([ [4, 2, 5], [6, 1, 1]]) >>> m.is_upper False
See also
-
is_upper_hessenberg
¶ Checks if the matrix is the upper-Hessenberg form.
The upper hessenberg matrix has zero entries below the first subdiagonal.
Examples
>>> from sympy.matrices import Matrix >>> a = Matrix([[1, 4, 2, 3], [3, 4, 1, 7], [0, 2, 3, 4], [0, 0, 1, 3]]) >>> a Matrix([ [1, 4, 2, 3], [3, 4, 1, 7], [0, 2, 3, 4], [0, 0, 1, 3]]) >>> a.is_upper_hessenberg True
See also
-
is_zero
¶ Checks if a matrix is a zero matrix.
A matrix is zero if every element is zero. A matrix need not be square to be considered zero. The empty matrix is zero by the principle of vacuous truth. For a matrix that may or may not be zero (e.g. contains a symbol), this will be None
Examples
>>> from sympy import Matrix, zeros >>> from sympy.abc import x >>> a = Matrix([[0, 0], [0, 0]]) >>> b = zeros(3, 4) >>> c = Matrix([[0, 1], [0, 0]]) >>> d = Matrix([]) >>> e = Matrix([[x, 0], [0, 0]]) >>> a.is_zero True >>> b.is_zero True >>> c.is_zero False >>> d.is_zero True >>> e.is_zero
-
classmethod
jordan_block
(size=None, eigenvalue=None, **kwargs)¶ Returns a Jordan block
- Parameters
size : Integer, optional
Specifies the shape of the Jordan block matrix.
eigenvalue : Number or Symbol
Specifies the value for the main diagonal of the matrix.
Note
The keyword
eigenval
is also specified as an alias of this keyword, but it is not recommended to use.We may deprecate the alias in later release.
band : ‘upper’ or ‘lower’, optional
Specifies the position of the off-diagonal to put \(1\) s on.
cls : Matrix, optional
Specifies the matrix class of the output form.
If it is not specified, the class type where the method is being executed on will be returned.
rows, cols : Integer, optional
Specifies the shape of the Jordan block matrix. See Notes section for the details of how these key works.
Note
This feature will be deprecated in the future.
- Returns
Matrix
A Jordan block matrix.
- Raises
ValueError
If insufficient arguments are given for matrix size specification, or no eigenvalue is given.
Examples
Creating a default Jordan block:
>>> from sympy import Matrix >>> from sympy.abc import x >>> Matrix.jordan_block(4, x) Matrix([ [x, 1, 0, 0], [0, x, 1, 0], [0, 0, x, 1], [0, 0, 0, x]])
Creating an alternative Jordan block matrix where \(1\) is on lower off-diagonal:
>>> Matrix.jordan_block(4, x, band='lower') Matrix([ [x, 0, 0, 0], [1, x, 0, 0], [0, 1, x, 0], [0, 0, 1, x]])
Creating a Jordan block with keyword arguments
>>> Matrix.jordan_block(size=4, eigenvalue=x) Matrix([ [x, 1, 0, 0], [0, x, 1, 0], [0, 0, x, 1], [0, 0, 0, x]])
Notes
Note
This feature will be deprecated in the future.
The keyword arguments
size
,rows
,cols
relates to the Jordan block size specifications.If you want to create a square Jordan block, specify either one of the three arguments.
If you want to create a rectangular Jordan block, specify
rows
andcols
individually.Arguments Given
Matrix Shape
size
rows
cols
rows
cols
size
Any
size
size
None
None
ValueError
rows
None
rows
rows
None
cols
cols
cols
rows
cols
rows
cols
References
-
multiply_elementwise
(other)¶ Return the Hadamard product (elementwise product) of A and B
Examples
>>> from sympy.matrices import Matrix >>> A = Matrix([[0, 1, 2], [3, 4, 5]]) >>> B = Matrix([[1, 10, 100], [100, 10, 1]]) >>> A.multiply_elementwise(B) Matrix([ [ 0, 10, 200], [300, 40, 5]])
See also
cross
,dot
,multiply
-
n
(prec=None, **options)¶ Apply evalf() to each element of self.
-
classmethod
ones
(rows, cols=None, **kwargs)¶ Returns a matrix of ones.
Args
rows : rows of the matrix cols : cols of the matrix (if None, cols=rows)
Kwargs
cls : class of the returned matrix
-
permute
(perm, orientation='rows', direction='forward')¶ Permute the rows or columns of a matrix by the given list of swaps.
- Parameters
perm : a permutation. This may be a list swaps (e.g., \([[1, 2], [0, 3]]\)),
or any valid input to the \(Permutation\) constructor, including a \(Permutation()\) itself. If \(perm\) is given explicitly as a list of indices or a \(Permutation\), \(direction\) has no effect.
orientation : (‘rows’ or ‘cols’) whether to permute the rows or the columns
direction : (‘forward’, ‘backward’) whether to apply the permutations from
the start of the list first, or from the back of the list first
Examples
>>> from sympy.matrices import eye >>> M = eye(3) >>> M.permute([[0, 1], [0, 2]], orientation='rows', direction='forward') Matrix([ [0, 0, 1], [1, 0, 0], [0, 1, 0]])
>>> from sympy.matrices import eye >>> M = eye(3) >>> M.permute([[0, 1], [0, 2]], orientation='rows', direction='backward') Matrix([ [0, 1, 0], [0, 0, 1], [1, 0, 0]])
-
permute_cols
(swaps, direction='forward')¶ Alias for \(self.permute(swaps, orientation='cols', direction=direction)\)
See also
-
permute_rows
(swaps, direction='forward')¶ Alias for \(self.permute(swaps, orientation='rows', direction=direction)\)
See also
-
refine
(assumptions=True)¶ Apply refine to each element of the matrix.
Examples
>>> from sympy import Symbol, Matrix, Abs, sqrt, Q >>> x = Symbol('x') >>> Matrix([[Abs(x)**2, sqrt(x**2)],[sqrt(x**2), Abs(x)**2]]) Matrix([ [ Abs(x)**2, sqrt(x**2)], [sqrt(x**2), Abs(x)**2]]) >>> _.refine(Q.real(x)) Matrix([ [ x**2, Abs(x)], [Abs(x), x**2]])
-
replace
(F, G, map=False)¶ Replaces Function F in Matrix entries with Function G.
Examples
>>> from sympy import symbols, Function, Matrix >>> F, G = symbols('F, G', cls=Function) >>> M = Matrix(2, 2, lambda i, j: F(i+j)) ; M Matrix([ [F(0), F(1)], [F(1), F(2)]]) >>> N = M.replace(F,G) >>> N Matrix([ [G(0), G(1)], [G(1), G(2)]])
-
reshape
(rows, cols)¶ Reshape the matrix. Total number of elements must remain the same.
Examples
>>> from sympy import Matrix >>> m = Matrix(2, 3, lambda i, j: 1) >>> m Matrix([ [1, 1, 1], [1, 1, 1]]) >>> m.reshape(1, 6) Matrix([[1, 1, 1, 1, 1, 1]]) >>> m.reshape(3, 2) Matrix([ [1, 1], [1, 1], [1, 1]])
-
row
(i)¶ Elementary row selector.
Examples
>>> from sympy import eye >>> eye(2).row(0) Matrix([[1, 0]])
See also
col
,row_op
,row_swap
,row_del
,row_join
,row_insert
-
row_del
(row)¶ Delete the specified row.
-
row_insert
(pos, other)¶ Insert one or more rows at the given row position.
Examples
>>> from sympy import zeros, ones >>> M = zeros(3) >>> V = ones(1, 3) >>> M.row_insert(1, V) Matrix([ [0, 0, 0], [1, 1, 1], [0, 0, 0], [0, 0, 0]])
See also
-
row_join
(other)¶ Concatenates two matrices along self’s last and rhs’s first column
Examples
>>> from sympy import zeros, ones >>> M = zeros(3) >>> V = ones(3, 1) >>> M.row_join(V) Matrix([ [0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]])
-
shape
¶ The shape (dimensions) of the matrix as the 2-tuple (rows, cols).
Examples
>>> from sympy.matrices import zeros >>> M = zeros(2, 3) >>> M.shape (2, 3) >>> M.rows 2 >>> M.cols 3
-
simplify
(ratio=1.7, measure=<function count_ops>, rational=False, inverse=False)¶ Apply simplify to each element of the matrix.
Examples
>>> from sympy.abc import x, y >>> from sympy import sin, cos >>> from sympy.matrices import SparseMatrix >>> SparseMatrix(1, 1, [x*sin(y)**2 + x*cos(y)**2]) Matrix([[x*sin(y)**2 + x*cos(y)**2]]) >>> _.simplify() Matrix([[x]])
-
subs
(*args, **kwargs)¶ Return a new matrix with subs applied to each entry.
Examples
>>> from sympy.abc import x, y >>> from sympy.matrices import SparseMatrix, Matrix >>> SparseMatrix(1, 1, [x]) Matrix([[x]]) >>> _.subs(x, y) Matrix([[y]]) >>> Matrix(_).subs(y, x) Matrix([[x]])
-
tolist
()¶ Return the Matrix as a nested Python list.
Examples
>>> from sympy import Matrix, ones >>> m = Matrix(3, 3, range(9)) >>> m Matrix([ [0, 1, 2], [3, 4, 5], [6, 7, 8]]) >>> m.tolist() [[0, 1, 2], [3, 4, 5], [6, 7, 8]] >>> ones(3, 0).tolist() [[], [], []]
When there are no rows then it will not be possible to tell how many columns were in the original matrix:
>>> ones(0, 3).tolist() []
-
trace
()¶ Returns the trace of a square matrix i.e. the sum of the diagonal elements.
Examples
>>> from sympy import Matrix >>> A = Matrix(2, 2, [1, 2, 3, 4]) >>> A.trace() 5
-
transpose
()¶ Returns the transpose of the matrix.
Examples
>>> from sympy import Matrix >>> A = Matrix(2, 2, [1, 2, 3, 4]) >>> A.transpose() Matrix([ [1, 3], [2, 4]])
>>> from sympy import Matrix, I >>> m=Matrix(((1, 2+I), (3, 4))) >>> m Matrix([ [1, 2 + I], [3, 4]]) >>> m.transpose() Matrix([ [ 1, 3], [2 + I, 4]]) >>> m.T == m.transpose() True
See also
conjugate
By-element conjugation
-
values
()¶ Return non-zero values of self.
-
vec
()¶ Return the Matrix converted into a one column matrix by stacking columns
Examples
>>> from sympy import Matrix >>> m=Matrix([[1, 3], [2, 4]]) >>> m Matrix([ [1, 3], [2, 4]]) >>> m.vec() Matrix([ [1], [2], [3], [4]])
See also
vech
-
classmethod
vstack
(*args)¶ Return a matrix formed by joining args vertically (i.e. by repeated application of col_join).
Examples
>>> from sympy.matrices import Matrix, eye >>> Matrix.vstack(eye(2), 2*eye(2)) Matrix([ [1, 0], [0, 1], [2, 0], [0, 2]])
-
xreplace
(rule)¶ Return a new matrix with xreplace applied to each entry.
Examples
>>> from sympy.abc import x, y >>> from sympy.matrices import SparseMatrix, Matrix >>> SparseMatrix(1, 1, [x]) Matrix([[x]]) >>> _.xreplace({x: y}) Matrix([[y]]) >>> Matrix(_).xreplace({y: x}) Matrix([[x]])
-
classmethod
zeros
(rows, cols=None, **kwargs)¶ Returns a matrix of zeros.
Args
rows : rows of the matrix cols : cols of the matrix (if None, cols=rows)
Kwargs
cls : class of the returned matrix
-