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\).
- property C¶
By-element conjugation
- property 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
sympy.matrices.matrices.MatrixBase.D
Dirac conjugation
- property T¶
Matrix transposition
- __getitem__(key)[source]¶
Implementations of __getitem__ should accept ints, in which case the matrix is indexed as a flat list, tuples (i,j) in which case the (i,j) entry is returned, slices, or mixed tuples (a,b) where a and b are any combintion of slices and integers.
- __mul__(other)[source]¶
Return self*other where other is either a scalar or a matrix of compatible dimensions.
Examples
>>> from sympy.matrices import Matrix >>> A = Matrix([[1, 2, 3], [4, 5, 6]]) >>> 2*A == A*2 == Matrix([[2, 4, 6], [8, 10, 12]]) True >>> B = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> A*B Matrix([ [30, 36, 42], [66, 81, 96]]) >>> B*A Traceback (most recent call last): ... ShapeError: Matrices size mismatch. >>>
See also
- __weakref__¶
list of weak references to the object (if defined)
- applyfunc(f)[source]¶
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(deep=True, **hints)[source]¶
Returns a tuple containing the (real, imaginary) part of matrix.
- atoms(*types)[source]¶
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} >>> Matrix([[x, y], [y, x]]) Matrix([ [x, y], [y, x]]) >>> _.atoms() {x, y}
- col(j)[source]¶
Elementary column selector.
Examples
>>> from sympy import eye >>> eye(2).col(0) Matrix([ [1], [0]])
See also
- col_insert(pos, other)[source]¶
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)[source]¶
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]])
- classmethod companion(poly)[source]¶
Returns a companion matrix of a polynomial.
Examples
>>> from sympy import Matrix, Poly, Symbol, symbols >>> x = Symbol('x') >>> c0, c1, c2, c3, c4 = symbols('c0:5') >>> p = Poly(c0 + c1*x + c2*x**2 + c3*x**3 + c4*x**4 + x**5, x) >>> Matrix.companion(p) Matrix([ [0, 0, 0, 0, -c0], [1, 0, 0, 0, -c1], [0, 1, 0, 0, -c2], [0, 0, 1, 0, -c3], [0, 0, 0, 1, -c4]])
- conjugate()[source]¶
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]])
See also
transpose
Matrix transposition
H
Hermite conjugation
sympy.matrices.matrices.MatrixBase.D
Dirac conjugation
- classmethod diag(*args, strict=False, unpack=True, rows=None, cols=None, **kwargs)[source]¶
Returns a matrix with the specified diagonal. If matrices are passed, a block-diagonal matrix is created (i.e. the “direct sum” of the matrices).
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
unpack : bool which, when True (default), unpacks a single sequence rather than interpreting it as a Matrix.
strict : bool which, when False (default), allows Matrices to have variable-length rows.
Examples
>>> from sympy.matrices import Matrix >>> Matrix.diag(1, 2, 3) Matrix([ [1, 0, 0], [0, 2, 0], [0, 0, 3]])
The current default is to unpack a single sequence. If this is not desired, set \(unpack=False\) and it will be interpreted as a matrix.
>>> Matrix.diag([1, 2, 3]) == Matrix.diag(1, 2, 3) True
When more than one element is passed, each is interpreted as something to put on the diagonal. Lists are converted to matrices. Filling of the diagonal always continues from the bottom right hand corner of the previous item: this will create a block-diagonal matrix whether the matrices are square or not.
>>> col = [1, 2, 3] >>> row = [[4, 5]] >>> Matrix.diag(col, row) Matrix([ [1, 0, 0], [2, 0, 0], [3, 0, 0], [0, 4, 5]])
When \(unpack\) is False, elements within a list need not all be of the same length. Setting \(strict\) to True would raise a ValueError for the following:
>>> Matrix.diag([[1, 2, 3], [4, 5], [6]], unpack=False) Matrix([ [1, 2, 3], [4, 5, 0], [6, 0, 0]])
The type of the returned matrix can be set with the
cls
keyword.>>> from sympy.matrices import ImmutableMatrix >>> from sympy.utilities.misc import func_name >>> func_name(Matrix.diag(1, cls=ImmutableMatrix)) 'ImmutableDenseMatrix'
A zero dimension matrix can be used to position the start of the filling at the start of an arbitrary row or column:
>>> from sympy import ones >>> r2 = ones(0, 2) >>> Matrix.diag(r2, 1, 2) Matrix([ [0, 0, 1, 0], [0, 0, 0, 2]])
- diagonal(k=0)[source]¶
Returns the kth diagonal of self. The main diagonal corresponds to \(k=0\); diagonals above and below correspond to \(k > 0\) and \(k < 0\), respectively. The values of \(self[i, j]\) for which \(j - i = k\), are returned in order of increasing \(i + j\), starting with \(i + j = |k|\).
Examples
>>> from sympy import Matrix >>> m = Matrix(3, 3, lambda i, j: j - i); m Matrix([ [ 0, 1, 2], [-1, 0, 1], [-2, -1, 0]]) >>> _.diagonal() Matrix([[0, 0, 0]]) >>> m.diagonal(1) Matrix([[1, 1]]) >>> m.diagonal(-2) Matrix([[-2]])
Even though the diagonal is returned as a Matrix, the element retrieval can be done with a single index:
>>> Matrix.diag(1, 2, 3).diagonal()[1] # instead of [0, 1] 2
See also
- evalf(n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)[source]¶
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)[source]¶
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)[source]¶
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)[source]¶
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
- property 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()[source]¶
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)[source]¶
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)[source]¶
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)[source]¶
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()[source]¶
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
- property 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
- property 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
- property 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
- property 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
- property is_strongly_diagonally_dominant¶
Tests if the matrix is row strongly diagonally dominant.
Explanation
A \(n, n\) matrix \(A\) is row strongly diagonally dominant if
\[\left|A_{i, i}\right| > \sum_{j = 0, j \neq i}^{n-1} \left|A_{i, j}\right| \quad {\text{for all }} i \in \{ 0, ..., n-1 \}\]Examples
>>> from sympy.matrices import Matrix >>> A = Matrix([[3, -2, 1], [1, -3, 2], [-1, 2, 4]]) >>> A.is_strongly_diagonally_dominant False
>>> A = Matrix([[-2, 2, 1], [1, 3, 2], [1, -2, 0]]) >>> A.is_strongly_diagonally_dominant False
>>> A = Matrix([[-4, 2, 1], [1, 6, 2], [1, -2, 5]]) >>> A.is_strongly_diagonally_dominant True
Notes
If you want to test whether a matrix is column diagonally dominant, you can apply the test after transposing the matrix.
- is_symbolic()[source]¶
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)[source]¶
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
- property 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
- property 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
- property is_weakly_diagonally_dominant¶
Tests if the matrix is row weakly diagonally dominant.
Explanation
A \(n, n\) matrix \(A\) is row weakly diagonally dominant if
\[\left|A_{i, i}\right| \ge \sum_{j = 0, j \neq i}^{n-1} \left|A_{i, j}\right| \quad {\text{for all }} i \in \{ 0, ..., n-1 \}\]Examples
>>> from sympy.matrices import Matrix >>> A = Matrix([[3, -2, 1], [1, -3, 2], [-1, 2, 4]]) >>> A.is_weakly_diagonally_dominant True
>>> A = Matrix([[-2, 2, 1], [1, 3, 2], [1, -2, 0]]) >>> A.is_weakly_diagonally_dominant False
>>> A = Matrix([[-4, 2, 1], [1, 6, 2], [1, -2, 5]]) >>> A.is_weakly_diagonally_dominant True
Notes
If you want to test whether a matrix is column diagonally dominant, you can apply the test after transposing the matrix.
- property is_zero_matrix¶
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_matrix True >>> b.is_zero_matrix True >>> c.is_zero_matrix False >>> d.is_zero_matrix True >>> e.is_zero_matrix
- classmethod jordan_block(size=None, eigenvalue=None, *, band='upper', **kwargs)[source]¶
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
- lower_triangular(k=0)[source]¶
returns the elements on and below the kth diagonal of a matrix. If k is not specified then simply returns lower-triangular portion of a matrix
Examples
>>> from sympy import ones >>> A = ones(4) >>> A.lower_triangular() Matrix([ [1, 0, 0, 0], [1, 1, 0, 0], [1, 1, 1, 0], [1, 1, 1, 1]])
>>> A.lower_triangular(-2) Matrix([ [0, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 0], [1, 1, 0, 0]])
>>> A.lower_triangular(1) Matrix([ [1, 1, 0, 0], [1, 1, 1, 0], [1, 1, 1, 1], [1, 1, 1, 1]])
- multiply(other, dotprodsimp=None)[source]¶
Same as __mul__() but with optional simplification.
- Parameters
dotprodsimp : bool, optional
Specifies whether intermediate term algebraic simplification is used during matrix multiplications to control expression blowup and thus speed up calculation. Default is off.
- multiply_elementwise(other)[source]¶
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]])
- classmethod ones(rows, cols=None, **kwargs)[source]¶
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')[source]¶
Permute the rows or columns of a matrix by the given list of swaps.
- Parameters
perm : Permutation, list, or list of lists
A representation for the permutation.
If it is
Permutation
, it is used directly with some resizing with respect to the matrix size.If it is specified as list of lists, (e.g.,
[[0, 1], [0, 2]]
), then the permutation is formed from applying the product of cycles. The direction how the cyclic product is applied is described in below.If it is specified as a list, the list should represent an array form of a permutation. (e.g.,
[1, 2, 0]
) which would would form the swapping function \(0 \mapsto 1, 1 \mapsto 2, 2\mapsto 0\).orientation : ‘rows’, ‘cols’
A flag to control whether to permute the rows or the columns
direction : ‘forward’, ‘backward’
A flag to control whether to apply the permutations from the start of the list first, or from the back of the list first.
For example, if the permutation specification is
[[0, 1], [0, 2]]
,If the flag is set to
'forward'
, the cycle would be formed as \(0 \mapsto 2, 2 \mapsto 1, 1 \mapsto 0\).If the flag is set to
'backward'
, the cycle would be formed as \(0 \mapsto 1, 1 \mapsto 2, 2 \mapsto 0\).If the argument
perm
is not in a form of list of lists, this flag takes no effect.
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]])
Notes
If a bijective function \(\sigma : \mathbb{N}_0 \rightarrow \mathbb{N}_0\) denotes the permutation.
If the matrix \(A\) is the matrix to permute, represented as a horizontal or a vertical stack of vectors:
\[\begin{split}A = \begin{bmatrix} a_0 \\ a_1 \\ \vdots \\ a_{n-1} \end{bmatrix} = \begin{bmatrix} \alpha_0 & \alpha_1 & \cdots & \alpha_{n-1} \end{bmatrix}\end{split}\]If the matrix \(B\) is the result, the permutation of matrix rows is defined as:
\[\begin{split}B := \begin{bmatrix} a_{\sigma(0)} \\ a_{\sigma(1)} \\ \vdots \\ a_{\sigma(n-1)} \end{bmatrix}\end{split}\]And the permutation of matrix columns is defined as:
\[B := \begin{bmatrix} \alpha_{\sigma(0)} & \alpha_{\sigma(1)} & \cdots & \alpha_{\sigma(n-1)} \end{bmatrix}\]
- permute_cols(swaps, direction='forward')[source]¶
Alias for
self.permute(swaps, orientation='cols', direction=direction)
See also
- permute_rows(swaps, direction='forward')[source]¶
Alias for
self.permute(swaps, orientation='rows', direction=direction)
See also
- pow(exp, method=None)[source]¶
Return self**exp a scalar or symbol.
- Parameters
method : multiply, mulsimp, jordan, cayley
If multiply then it returns exponentiation using recursion. If jordan then Jordan form exponentiation will be used. If cayley then the exponentiation is done using Cayley-Hamilton theorem. If mulsimp then the exponentiation is done using recursion with dotprodsimp. This specifies whether intermediate term algebraic simplification is used during naive matrix power to control expression blowup and thus speed up calculation. If None, then it heuristically decides which method to use.
- refine(assumptions=True)[source]¶
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, simultaneous=True, exact=None)[source]¶
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)[source]¶
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]])
- rmultiply(other, dotprodsimp=None)[source]¶
Same as __rmul__() but with optional simplification.
- Parameters
dotprodsimp : bool, optional
Specifies whether intermediate term algebraic simplification is used during matrix multiplications to control expression blowup and thus speed up calculation. Default is off.
- rot90(k=1)[source]¶
Rotates Matrix by 90 degrees
- Parameters
k : int
Specifies how many times the matrix is rotated by 90 degrees (clockwise when positive, counter-clockwise when negative).
Examples
>>> from sympy import Matrix, symbols >>> A = Matrix(2, 2, symbols('a:d')) >>> A Matrix([ [a, b], [c, d]])
Rotating the matrix clockwise one time:
>>> A.rot90(1) Matrix([ [c, a], [d, b]])
Rotating the matrix anticlockwise two times:
>>> A.rot90(-2) Matrix([ [d, c], [b, a]])
- row(i)[source]¶
Elementary row selector.
Examples
>>> from sympy import eye >>> eye(2).row(0) Matrix([[1, 0]])
See also
- row_insert(pos, other)[source]¶
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)[source]¶
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]])
- property 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(**kwargs)[source]¶
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)[source]¶
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]])
- todod()[source]¶
Returns matrix as dict of dicts containing non-zero elements of the Matrix
Examples
>>> from sympy import Matrix >>> A = Matrix([[0, 1],[0, 3]]) >>> A Matrix([ [0, 1], [0, 3]]) >>> A.todod() {0: {1: 1}, 1: {1: 3}}
- todok()[source]¶
Return the matrix as dictionary of keys.
Examples
>>> from sympy import Matrix >>> M = Matrix.eye(3) >>> M.todok() {(0, 0): 1, (1, 1): 1, (2, 2): 1}
- tolist()[source]¶
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()[source]¶
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()[source]¶
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
- upper_triangular(k=0)[source]¶
returns the elements on and above the kth diagonal of a matrix. If k is not specified then simply returns upper-triangular portion of a matrix
Examples
>>> from sympy import ones >>> A = ones(4) >>> A.upper_triangular() Matrix([ [1, 1, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1], [0, 0, 0, 1]])
>>> A.upper_triangular(2) Matrix([ [0, 0, 1, 1], [0, 0, 0, 1], [0, 0, 0, 0], [0, 0, 0, 0]])
>>> A.upper_triangular(-1) Matrix([ [1, 1, 1, 1], [1, 1, 1, 1], [0, 1, 1, 1], [0, 0, 1, 1]])
- vec()[source]¶
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(diagonal=True, check_symmetry=True)[source]¶
Reshapes the matrix into a column vector by stacking the elements in the lower triangle.
- Parameters
diagonal : bool, optional
If
True
, it includes the diagonal elements.check_symmetry : bool, optional
If
True
, it checks whether the matrix is symmetric.
Examples
>>> from sympy import Matrix >>> m=Matrix([[1, 2], [2, 3]]) >>> m Matrix([ [1, 2], [2, 3]]) >>> m.vech() Matrix([ [1], [2], [3]]) >>> m.vech(diagonal=False) Matrix([[2]])
Notes
This should work for symmetric matrices and
vech
can represent symmetric matrices in vector form with less size thanvec
.See also
- classmethod vstack(*args)[source]¶
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]])
- classmethod wilkinson(n, **kwargs)[source]¶
Returns two square Wilkinson Matrix of size 2*n + 1 \(W_{2n + 1}^-, W_{2n + 1}^+ =\) Wilkinson(n)
Examples
>>> from sympy.matrices import Matrix >>> wminus, wplus = Matrix.wilkinson(3) >>> wminus Matrix([ [-3, 1, 0, 0, 0, 0, 0], [ 1, -2, 1, 0, 0, 0, 0], [ 0, 1, -1, 1, 0, 0, 0], [ 0, 0, 1, 0, 1, 0, 0], [ 0, 0, 0, 1, 1, 1, 0], [ 0, 0, 0, 0, 1, 2, 1], [ 0, 0, 0, 0, 0, 1, 3]]) >>> wplus Matrix([ [3, 1, 0, 0, 0, 0, 0], [1, 2, 1, 0, 0, 0, 0], [0, 1, 1, 1, 0, 0, 0], [0, 0, 1, 0, 1, 0, 0], [0, 0, 0, 1, 1, 1, 0], [0, 0, 0, 0, 1, 2, 1], [0, 0, 0, 0, 0, 1, 3]])
References
- R522
https://blogs.mathworks.com/cleve/2013/04/15/wilkinsons-matrices-2/
- R523
Wilkinson, The Algebraic Eigenvalue Problem, Claredon Press, Oxford, 1965, 662 pp.