Spaces:
Sleeping
Sleeping
| # Test Matrix/DomainMatrix interaction. | |
| from sympy import GF, ZZ, QQ, EXRAW | |
| from sympy.polys.matrices import DomainMatrix, DM | |
| from sympy import ( | |
| Matrix, | |
| MutableMatrix, | |
| ImmutableMatrix, | |
| SparseMatrix, | |
| MutableDenseMatrix, | |
| ImmutableDenseMatrix, | |
| MutableSparseMatrix, | |
| ImmutableSparseMatrix, | |
| ) | |
| from sympy import symbols, S, sqrt | |
| from sympy.testing.pytest import raises | |
| x, y = symbols('x y') | |
| MATRIX_TYPES = ( | |
| Matrix, | |
| MutableMatrix, | |
| ImmutableMatrix, | |
| SparseMatrix, | |
| MutableDenseMatrix, | |
| ImmutableDenseMatrix, | |
| MutableSparseMatrix, | |
| ImmutableSparseMatrix, | |
| ) | |
| IMMUTABLE = ( | |
| ImmutableMatrix, | |
| ImmutableDenseMatrix, | |
| ImmutableSparseMatrix, | |
| ) | |
| def DMs(items, domain): | |
| return DM(items, domain).to_sparse() | |
| def test_Matrix_rep_domain(): | |
| for Mat in MATRIX_TYPES: | |
| M = Mat([[1, 2], [3, 4]]) | |
| assert M._rep == DMs([[1, 2], [3, 4]], ZZ) | |
| assert (M / 2)._rep == DMs([[(1,2), 1], [(3,2), 2]], QQ) | |
| if not isinstance(M, IMMUTABLE): | |
| M[0, 0] = x | |
| assert M._rep == DMs([[x, 2], [3, 4]], EXRAW) | |
| M = Mat([[S(1)/2, 2], [3, 4]]) | |
| assert M._rep == DMs([[(1,2), 2], [3, 4]], QQ) | |
| if not isinstance(M, IMMUTABLE): | |
| M[0, 0] = x | |
| assert M._rep == DMs([[x, 2], [3, 4]], EXRAW) | |
| dM = DMs([[1, 2], [3, 4]], ZZ) | |
| assert Mat._fromrep(dM)._rep == dM | |
| # XXX: This is not intended. Perhaps it should be coerced to EXRAW? | |
| # The private _fromrep method is never called like this but perhaps it | |
| # should be guarded. | |
| # | |
| # It is not clear how to integrate domains other than ZZ, QQ and EXRAW with | |
| # the rest of Matrix or if the public type for this needs to be something | |
| # different from Matrix somehow. | |
| K = QQ.algebraic_field(sqrt(2)) | |
| dM = DM([[1, 2], [3, 4]], K) | |
| assert Mat._fromrep(dM)._rep.domain == K | |
| def test_Matrix_to_DM(): | |
| M = Matrix([[1, 2], [3, 4]]) | |
| assert M.to_DM() == DMs([[1, 2], [3, 4]], ZZ) | |
| assert M.to_DM() is not M._rep | |
| assert M.to_DM(field=True) == DMs([[1, 2], [3, 4]], QQ) | |
| assert M.to_DM(domain=QQ) == DMs([[1, 2], [3, 4]], QQ) | |
| assert M.to_DM(domain=QQ[x]) == DMs([[1, 2], [3, 4]], QQ[x]) | |
| assert M.to_DM(domain=GF(3)) == DMs([[1, 2], [0, 1]], GF(3)) | |
| M = Matrix([[1, 2], [3, 4]]) | |
| M[0, 0] = x | |
| assert M._rep.domain == EXRAW | |
| M[0, 0] = 1 | |
| assert M.to_DM() == DMs([[1, 2], [3, 4]], ZZ) | |
| M = Matrix([[S(1)/2, 2], [3, 4]]) | |
| assert M.to_DM() == DMs([[QQ(1,2), 2], [3, 4]], QQ) | |
| M = Matrix([[x, 2], [3, 4]]) | |
| assert M.to_DM() == DMs([[x, 2], [3, 4]], ZZ[x]) | |
| assert M.to_DM(field=True) == DMs([[x, 2], [3, 4]], ZZ.frac_field(x)) | |
| M = Matrix([[1/x, 2], [3, 4]]) | |
| assert M.to_DM() == DMs([[1/x, 2], [3, 4]], ZZ.frac_field(x)) | |
| M = Matrix([[1, sqrt(2)], [3, 4]]) | |
| K = QQ.algebraic_field(sqrt(2)) | |
| sqrt2 = K.from_sympy(sqrt(2)) # XXX: Maybe K(sqrt(2)) should work | |
| M_K = DomainMatrix([[K(1), sqrt2], [K(3), K(4)]], (2, 2), K) | |
| assert M.to_DM() == DMs([[1, sqrt(2)], [3, 4]], EXRAW) | |
| assert M.to_DM(extension=True) == M_K.to_sparse() | |
| # Options cannot be used with the domain parameter | |
| M = Matrix([[1, 2], [3, 4]]) | |
| raises(TypeError, lambda: M.to_DM(domain=QQ, field=True)) | |