Spaces:
Sleeping
Sleeping
| from sympy.utilities.iterables import \ | |
| flatten, connected_components, strongly_connected_components | |
| from .exceptions import NonSquareMatrixError | |
| def _connected_components(M): | |
| """Returns the list of connected vertices of the graph when | |
| a square matrix is viewed as a weighted graph. | |
| Examples | |
| ======== | |
| >>> from sympy import Matrix | |
| >>> A = Matrix([ | |
| ... [66, 0, 0, 68, 0, 0, 0, 0, 67], | |
| ... [0, 55, 0, 0, 0, 0, 54, 53, 0], | |
| ... [0, 0, 0, 0, 1, 2, 0, 0, 0], | |
| ... [86, 0, 0, 88, 0, 0, 0, 0, 87], | |
| ... [0, 0, 10, 0, 11, 12, 0, 0, 0], | |
| ... [0, 0, 20, 0, 21, 22, 0, 0, 0], | |
| ... [0, 45, 0, 0, 0, 0, 44, 43, 0], | |
| ... [0, 35, 0, 0, 0, 0, 34, 33, 0], | |
| ... [76, 0, 0, 78, 0, 0, 0, 0, 77]]) | |
| >>> A.connected_components() | |
| [[0, 3, 8], [1, 6, 7], [2, 4, 5]] | |
| Notes | |
| ===== | |
| Even if any symbolic elements of the matrix can be indeterminate | |
| to be zero mathematically, this only takes the account of the | |
| structural aspect of the matrix, so they will considered to be | |
| nonzero. | |
| """ | |
| if not M.is_square: | |
| raise NonSquareMatrixError | |
| V = range(M.rows) | |
| E = sorted(M.todok().keys()) | |
| return connected_components((V, E)) | |
| def _strongly_connected_components(M): | |
| """Returns the list of strongly connected vertices of the graph when | |
| a square matrix is viewed as a weighted graph. | |
| Examples | |
| ======== | |
| >>> from sympy import Matrix | |
| >>> A = Matrix([ | |
| ... [44, 0, 0, 0, 43, 0, 45, 0, 0], | |
| ... [0, 66, 62, 61, 0, 68, 0, 60, 67], | |
| ... [0, 0, 22, 21, 0, 0, 0, 20, 0], | |
| ... [0, 0, 12, 11, 0, 0, 0, 10, 0], | |
| ... [34, 0, 0, 0, 33, 0, 35, 0, 0], | |
| ... [0, 86, 82, 81, 0, 88, 0, 80, 87], | |
| ... [54, 0, 0, 0, 53, 0, 55, 0, 0], | |
| ... [0, 0, 2, 1, 0, 0, 0, 0, 0], | |
| ... [0, 76, 72, 71, 0, 78, 0, 70, 77]]) | |
| >>> A.strongly_connected_components() | |
| [[0, 4, 6], [2, 3, 7], [1, 5, 8]] | |
| """ | |
| if not M.is_square: | |
| raise NonSquareMatrixError | |
| # RepMatrix uses the more efficient DomainMatrix.scc() method | |
| rep = getattr(M, '_rep', None) | |
| if rep is not None: | |
| return rep.scc() | |
| V = range(M.rows) | |
| E = sorted(M.todok().keys()) | |
| return strongly_connected_components((V, E)) | |
| def _connected_components_decomposition(M): | |
| """Decomposes a square matrix into block diagonal form only | |
| using the permutations. | |
| Explanation | |
| =========== | |
| The decomposition is in a form of $A = P^{-1} B P$ where $P$ is a | |
| permutation matrix and $B$ is a block diagonal matrix. | |
| Returns | |
| ======= | |
| P, B : PermutationMatrix, BlockDiagMatrix | |
| *P* is a permutation matrix for the similarity transform | |
| as in the explanation. And *B* is the block diagonal matrix of | |
| the result of the permutation. | |
| If you would like to get the diagonal blocks from the | |
| BlockDiagMatrix, see | |
| :meth:`~sympy.matrices.expressions.blockmatrix.BlockDiagMatrix.get_diag_blocks`. | |
| Examples | |
| ======== | |
| >>> from sympy import Matrix, pprint | |
| >>> A = Matrix([ | |
| ... [66, 0, 0, 68, 0, 0, 0, 0, 67], | |
| ... [0, 55, 0, 0, 0, 0, 54, 53, 0], | |
| ... [0, 0, 0, 0, 1, 2, 0, 0, 0], | |
| ... [86, 0, 0, 88, 0, 0, 0, 0, 87], | |
| ... [0, 0, 10, 0, 11, 12, 0, 0, 0], | |
| ... [0, 0, 20, 0, 21, 22, 0, 0, 0], | |
| ... [0, 45, 0, 0, 0, 0, 44, 43, 0], | |
| ... [0, 35, 0, 0, 0, 0, 34, 33, 0], | |
| ... [76, 0, 0, 78, 0, 0, 0, 0, 77]]) | |
| >>> P, B = A.connected_components_decomposition() | |
| >>> pprint(P) | |
| PermutationMatrix((1 3)(2 8 5 7 4 6)) | |
| >>> pprint(B) | |
| [[66 68 67] ] | |
| [[ ] ] | |
| [[86 88 87] 0 0 ] | |
| [[ ] ] | |
| [[76 78 77] ] | |
| [ ] | |
| [ [55 54 53] ] | |
| [ [ ] ] | |
| [ 0 [45 44 43] 0 ] | |
| [ [ ] ] | |
| [ [35 34 33] ] | |
| [ ] | |
| [ [0 1 2 ]] | |
| [ [ ]] | |
| [ 0 0 [10 11 12]] | |
| [ [ ]] | |
| [ [20 21 22]] | |
| >>> P = P.as_explicit() | |
| >>> B = B.as_explicit() | |
| >>> P.T*B*P == A | |
| True | |
| Notes | |
| ===== | |
| This problem corresponds to the finding of the connected components | |
| of a graph, when a matrix is viewed as a weighted graph. | |
| """ | |
| from sympy.combinatorics.permutations import Permutation | |
| from sympy.matrices.expressions.blockmatrix import BlockDiagMatrix | |
| from sympy.matrices.expressions.permutation import PermutationMatrix | |
| iblocks = M.connected_components() | |
| p = Permutation(flatten(iblocks)) | |
| P = PermutationMatrix(p) | |
| blocks = [] | |
| for b in iblocks: | |
| blocks.append(M[b, b]) | |
| B = BlockDiagMatrix(*blocks) | |
| return P, B | |
| def _strongly_connected_components_decomposition(M, lower=True): | |
| """Decomposes a square matrix into block triangular form only | |
| using the permutations. | |
| Explanation | |
| =========== | |
| The decomposition is in a form of $A = P^{-1} B P$ where $P$ is a | |
| permutation matrix and $B$ is a block diagonal matrix. | |
| Parameters | |
| ========== | |
| lower : bool | |
| Makes $B$ lower block triangular when ``True``. | |
| Otherwise, makes $B$ upper block triangular. | |
| Returns | |
| ======= | |
| P, B : PermutationMatrix, BlockMatrix | |
| *P* is a permutation matrix for the similarity transform | |
| as in the explanation. And *B* is the block triangular matrix of | |
| the result of the permutation. | |
| Examples | |
| ======== | |
| >>> from sympy import Matrix, pprint | |
| >>> A = Matrix([ | |
| ... [44, 0, 0, 0, 43, 0, 45, 0, 0], | |
| ... [0, 66, 62, 61, 0, 68, 0, 60, 67], | |
| ... [0, 0, 22, 21, 0, 0, 0, 20, 0], | |
| ... [0, 0, 12, 11, 0, 0, 0, 10, 0], | |
| ... [34, 0, 0, 0, 33, 0, 35, 0, 0], | |
| ... [0, 86, 82, 81, 0, 88, 0, 80, 87], | |
| ... [54, 0, 0, 0, 53, 0, 55, 0, 0], | |
| ... [0, 0, 2, 1, 0, 0, 0, 0, 0], | |
| ... [0, 76, 72, 71, 0, 78, 0, 70, 77]]) | |
| A lower block triangular decomposition: | |
| >>> P, B = A.strongly_connected_components_decomposition() | |
| >>> pprint(P) | |
| PermutationMatrix((8)(1 4 3 2 6)(5 7)) | |
| >>> pprint(B) | |
| [[44 43 45] [0 0 0] [0 0 0] ] | |
| [[ ] [ ] [ ] ] | |
| [[34 33 35] [0 0 0] [0 0 0] ] | |
| [[ ] [ ] [ ] ] | |
| [[54 53 55] [0 0 0] [0 0 0] ] | |
| [ ] | |
| [ [0 0 0] [22 21 20] [0 0 0] ] | |
| [ [ ] [ ] [ ] ] | |
| [ [0 0 0] [12 11 10] [0 0 0] ] | |
| [ [ ] [ ] [ ] ] | |
| [ [0 0 0] [2 1 0 ] [0 0 0] ] | |
| [ ] | |
| [ [0 0 0] [62 61 60] [66 68 67]] | |
| [ [ ] [ ] [ ]] | |
| [ [0 0 0] [82 81 80] [86 88 87]] | |
| [ [ ] [ ] [ ]] | |
| [ [0 0 0] [72 71 70] [76 78 77]] | |
| >>> P = P.as_explicit() | |
| >>> B = B.as_explicit() | |
| >>> P.T * B * P == A | |
| True | |
| An upper block triangular decomposition: | |
| >>> P, B = A.strongly_connected_components_decomposition(lower=False) | |
| >>> pprint(P) | |
| PermutationMatrix((0 1 5 7 4 3 2 8 6)) | |
| >>> pprint(B) | |
| [[66 68 67] [62 61 60] [0 0 0] ] | |
| [[ ] [ ] [ ] ] | |
| [[86 88 87] [82 81 80] [0 0 0] ] | |
| [[ ] [ ] [ ] ] | |
| [[76 78 77] [72 71 70] [0 0 0] ] | |
| [ ] | |
| [ [0 0 0] [22 21 20] [0 0 0] ] | |
| [ [ ] [ ] [ ] ] | |
| [ [0 0 0] [12 11 10] [0 0 0] ] | |
| [ [ ] [ ] [ ] ] | |
| [ [0 0 0] [2 1 0 ] [0 0 0] ] | |
| [ ] | |
| [ [0 0 0] [0 0 0] [44 43 45]] | |
| [ [ ] [ ] [ ]] | |
| [ [0 0 0] [0 0 0] [34 33 35]] | |
| [ [ ] [ ] [ ]] | |
| [ [0 0 0] [0 0 0] [54 53 55]] | |
| >>> P = P.as_explicit() | |
| >>> B = B.as_explicit() | |
| >>> P.T * B * P == A | |
| True | |
| """ | |
| from sympy.combinatorics.permutations import Permutation | |
| from sympy.matrices.expressions.blockmatrix import BlockMatrix | |
| from sympy.matrices.expressions.permutation import PermutationMatrix | |
| iblocks = M.strongly_connected_components() | |
| if not lower: | |
| iblocks = list(reversed(iblocks)) | |
| p = Permutation(flatten(iblocks)) | |
| P = PermutationMatrix(p) | |
| rows = [] | |
| for a in iblocks: | |
| cols = [] | |
| for b in iblocks: | |
| cols.append(M[a, b]) | |
| rows.append(cols) | |
| B = BlockMatrix(rows) | |
| return P, B | |