Add files using upload-large-folder tool

llmeval-env/lib/python3.10/site-packages/sympy/polys/matrices/__init__.py

@@ -0,0 +1,15 @@
+"""
+
+sympy.polys.matrices package.
+
+The main export from this package is the DomainMatrix class which is a
+lower-level implementation of matrices based on the polys Domains. This
+implementation is typically a lot faster than SymPy's standard Matrix class
+but is a work in progress and is still experimental.
+
+"""
+from .domainmatrix import DomainMatrix, DM
+
+__all__ = [
+    'DomainMatrix', 'DM',
+]

llmeval-env/lib/python3.10/site-packages/sympy/polys/matrices/_typing.py

@@ -0,0 +1,12 @@
+from typing import TypeVar, Protocol
+
+
+T = TypeVar('T')
+
+
+class RingElement(Protocol):
+    def __add__(self: T, other: T, /) -> T: ...
+    def __sub__(self: T, other: T, /) -> T: ...
+    def __mul__(self: T, other: T, /) -> T: ...
+    def __pow__(self: T, other: int, /) -> T: ...
+    def __neg__(self: T, /) -> T: ...

llmeval-env/lib/python3.10/site-packages/sympy/polys/matrices/ddm.py

@@ -0,0 +1,496 @@
+"""
+
+Module for the DDM class.
+
+The DDM class is an internal representation used by DomainMatrix. The letters
+DDM stand for Dense Domain Matrix. A DDM instance represents a matrix using
+elements from a polynomial Domain (e.g. ZZ, QQ, ...) in a dense-matrix
+representation.
+
+Basic usage:
+
+    >>> from sympy import ZZ, QQ
+    >>> from sympy.polys.matrices.ddm import DDM
+    >>> A = DDM([[ZZ(0), ZZ(1)], [ZZ(-1), ZZ(0)]], (2, 2), ZZ)
+    >>> A.shape
+    (2, 2)
+    >>> A
+    [[0, 1], [-1, 0]]
+    >>> type(A)
+    <class 'sympy.polys.matrices.ddm.DDM'>
+    >>> A @ A
+    [[-1, 0], [0, -1]]
+
+The ddm_* functions are designed to operate on DDM as well as on an ordinary
+list of lists:
+
+    >>> from sympy.polys.matrices.dense import ddm_idet
+    >>> ddm_idet(A, QQ)
+    1
+    >>> ddm_idet([[0, 1], [-1, 0]], QQ)
+    1
+    >>> A
+    [[-1, 0], [0, -1]]
+
+Note that ddm_idet modifies the input matrix in-place. It is recommended to
+use the DDM.det method as a friendlier interface to this instead which takes
+care of copying the matrix:
+
+    >>> B = DDM([[ZZ(0), ZZ(1)], [ZZ(-1), ZZ(0)]], (2, 2), ZZ)
+    >>> B.det()
+    1
+
+Normally DDM would not be used directly and is just part of the internal
+representation of DomainMatrix which adds further functionality including e.g.
+unifying domains.
+
+The dense format used by DDM is a list of lists of elements e.g. the 2x2
+identity matrix is like [[1, 0], [0, 1]]. The DDM class itself is a subclass
+of list and its list items are plain lists. Elements are accessed as e.g.
+ddm[i][j] where ddm[i] gives the ith row and ddm[i][j] gets the element in the
+jth column of that row. Subclassing list makes e.g. iteration and indexing
+very efficient. We do not override __getitem__ because it would lose that
+benefit.
+
+The core routines are implemented by the ddm_* functions defined in dense.py.
+Those functions are intended to be able to operate on a raw list-of-lists
+representation of matrices with most functions operating in-place. The DDM
+class takes care of copying etc and also stores a Domain object associated
+with its elements. This makes it possible to implement things like A + B with
+domain checking and also shape checking so that the list of lists
+representation is friendlier.
+
+"""
+from itertools import chain
+
+from .exceptions import DMBadInputError, DMShapeError, DMDomainError
+
+from .dense import (
+        ddm_transpose,
+        ddm_iadd,
+        ddm_isub,
+        ddm_ineg,
+        ddm_imul,
+        ddm_irmul,
+        ddm_imatmul,
+        ddm_irref,
+        ddm_idet,
+        ddm_iinv,
+        ddm_ilu_split,
+        ddm_ilu_solve,
+        ddm_berk,
+        )
+
+from sympy.polys.domains import QQ
+from .lll import ddm_lll, ddm_lll_transform
+
+
+class DDM(list):
+    """Dense matrix based on polys domain elements
+
+    This is a list subclass and is a wrapper for a list of lists that supports
+    basic matrix arithmetic +, -, *, **.
+    """
+
+    fmt = 'dense'
+
+    def __init__(self, rowslist, shape, domain):
+        super().__init__(rowslist)
+        self.shape = self.rows, self.cols = m, n = shape
+        self.domain = domain
+
+        if not (len(self) == m and all(len(row) == n for row in self)):
+            raise DMBadInputError("Inconsistent row-list/shape")
+
+    def getitem(self, i, j):
+        return self[i][j]
+
+    def setitem(self, i, j, value):
+        self[i][j] = value
+
+    def extract_slice(self, slice1, slice2):
+        ddm = [row[slice2] for row in self[slice1]]
+        rows = len(ddm)
+        cols = len(ddm[0]) if ddm else len(range(self.shape[1])[slice2])
+        return DDM(ddm, (rows, cols), self.domain)
+
+    def extract(self, rows, cols):
+        ddm = []
+        for i in rows:
+            rowi = self[i]
+            ddm.append([rowi[j] for j in cols])
+        return DDM(ddm, (len(rows), len(cols)), self.domain)
+
+    def to_list(self):
+        return list(self)
+
+    def to_list_flat(self):
+        flat = []
+        for row in self:
+            flat.extend(row)
+        return flat
+
+    def flatiter(self):
+        return chain.from_iterable(self)
+
+    def flat(self):
+        items = []
+        for row in self:
+            items.extend(row)
+        return items
+
+    def to_dok(self):
+        return {(i, j): e for i, row in enumerate(self) for j, e in enumerate(row)}
+
+    def to_ddm(self):
+        return self
+
+    def to_sdm(self):
+        return SDM.from_list(self, self.shape, self.domain)
+
+    def convert_to(self, K):
+        Kold = self.domain
+        if K == Kold:
+            return self.copy()
+        rows = ([K.convert_from(e, Kold) for e in row] for row in self)
+        return DDM(rows, self.shape, K)
+
+    def __str__(self):
+        rowsstr = ['[%s]' % ', '.join(map(str, row)) for row in self]
+        return '[%s]' % ', '.join(rowsstr)
+
+    def __repr__(self):
+        cls = type(self).__name__
+        rows = list.__repr__(self)
+        return '%s(%s, %s, %s)' % (cls, rows, self.shape, self.domain)
+
+    def __eq__(self, other):
+        if not isinstance(other, DDM):
+            return False
+        return (super().__eq__(other) and self.domain == other.domain)
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    @classmethod
+    def zeros(cls, shape, domain):
+        z = domain.zero
+        m, n = shape
+        rowslist = ([z] * n for _ in range(m))
+        return DDM(rowslist, shape, domain)
+
+    @classmethod
+    def ones(cls, shape, domain):
+        one = domain.one
+        m, n = shape
+        rowlist = ([one] * n for _ in range(m))
+        return DDM(rowlist, shape, domain)
+
+    @classmethod
+    def eye(cls, size, domain):
+        one = domain.one
+        ddm = cls.zeros((size, size), domain)
+        for i in range(size):
+            ddm[i][i] = one
+        return ddm
+
+    def copy(self):
+        copyrows = (row[:] for row in self)
+        return DDM(copyrows, self.shape, self.domain)
+
+    def transpose(self):
+        rows, cols = self.shape
+        if rows:
+            ddmT = ddm_transpose(self)
+        else:
+            ddmT = [[]] * cols
+        return DDM(ddmT, (cols, rows), self.domain)
+
+    def __add__(a, b):
+        if not isinstance(b, DDM):
+            return NotImplemented
+        return a.add(b)
+
+    def __sub__(a, b):
+        if not isinstance(b, DDM):
+            return NotImplemented
+        return a.sub(b)
+
+    def __neg__(a):
+        return a.neg()
+
+    def __mul__(a, b):
+        if b in a.domain:
+            return a.mul(b)
+        else:
+            return NotImplemented
+
+    def __rmul__(a, b):
+        if b in a.domain:
+            return a.mul(b)
+        else:
+            return NotImplemented
+
+    def __matmul__(a, b):
+        if isinstance(b, DDM):
+            return a.matmul(b)
+        else:
+            return NotImplemented
+
+    @classmethod
+    def _check(cls, a, op, b, ashape, bshape):
+        if a.domain != b.domain:
+            msg = "Domain mismatch: %s %s %s" % (a.domain, op, b.domain)
+            raise DMDomainError(msg)
+        if ashape != bshape:
+            msg = "Shape mismatch: %s %s %s" % (a.shape, op, b.shape)
+            raise DMShapeError(msg)
+
+    def add(a, b):
+        """a + b"""
+        a._check(a, '+', b, a.shape, b.shape)
+        c = a.copy()
+        ddm_iadd(c, b)
+        return c
+
+    def sub(a, b):
+        """a - b"""
+        a._check(a, '-', b, a.shape, b.shape)
+        c = a.copy()
+        ddm_isub(c, b)
+        return c
+
+    def neg(a):
+        """-a"""
+        b = a.copy()
+        ddm_ineg(b)
+        return b
+
+    def mul(a, b):
+        c = a.copy()
+        ddm_imul(c, b)
+        return c
+
+    def rmul(a, b):
+        c = a.copy()
+        ddm_irmul(c, b)
+        return c
+
+    def matmul(a, b):
+        """a @ b (matrix product)"""
+        m, o = a.shape
+        o2, n = b.shape
+        a._check(a, '*', b, o, o2)
+        c = a.zeros((m, n), a.domain)
+        ddm_imatmul(c, a, b)
+        return c
+
+    def mul_elementwise(a, b):
+        assert a.shape == b.shape
+        assert a.domain == b.domain
+        c = [[aij * bij for aij, bij in zip(ai, bi)] for ai, bi in zip(a, b)]
+        return DDM(c, a.shape, a.domain)
+
+    def hstack(A, *B):
+        """Horizontally stacks :py:class:`~.DDM` matrices.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices.sdm import DDM
+
+        >>> A = DDM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DDM([[ZZ(5), ZZ(6)], [ZZ(7), ZZ(8)]], (2, 2), ZZ)
+        >>> A.hstack(B)
+        [[1, 2, 5, 6], [3, 4, 7, 8]]
+
+        >>> C = DDM([[ZZ(9), ZZ(10)], [ZZ(11), ZZ(12)]], (2, 2), ZZ)
+        >>> A.hstack(B, C)
+        [[1, 2, 5, 6, 9, 10], [3, 4, 7, 8, 11, 12]]
+        """
+        Anew = list(A.copy())
+        rows, cols = A.shape
+        domain = A.domain
+
+        for Bk in B:
+            Bkrows, Bkcols = Bk.shape
+            assert Bkrows == rows
+            assert Bk.domain == domain
+
+            cols += Bkcols
+
+            for i, Bki in enumerate(Bk):
+                Anew[i].extend(Bki)
+
+        return DDM(Anew, (rows, cols), A.domain)
+
+    def vstack(A, *B):
+        """Vertically stacks :py:class:`~.DDM` matrices.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices.sdm import DDM
+
+        >>> A = DDM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DDM([[ZZ(5), ZZ(6)], [ZZ(7), ZZ(8)]], (2, 2), ZZ)
+        >>> A.vstack(B)
+        [[1, 2], [3, 4], [5, 6], [7, 8]]
+
+        >>> C = DDM([[ZZ(9), ZZ(10)], [ZZ(11), ZZ(12)]], (2, 2), ZZ)
+        >>> A.vstack(B, C)
+        [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12]]
+        """
+        Anew = list(A.copy())
+        rows, cols = A.shape
+        domain = A.domain
+
+        for Bk in B:
+            Bkrows, Bkcols = Bk.shape
+            assert Bkcols == cols
+            assert Bk.domain == domain
+
+            rows += Bkrows
+
+            Anew.extend(Bk.copy())
+
+        return DDM(Anew, (rows, cols), A.domain)
+
+    def applyfunc(self, func, domain):
+        elements = (list(map(func, row)) for row in self)
+        return DDM(elements, self.shape, domain)
+
+    def scc(a):
+        """Strongly connected components of a square matrix *a*.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices.sdm import DDM
+        >>> A = DDM([[ZZ(1), ZZ(0)], [ZZ(0), ZZ(1)]], (2, 2), ZZ)
+        >>> A.scc()
+        [[0], [1]]
+
+        See also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.scc
+
+        """
+        return a.to_sdm().scc()
+
+    def rref(a):
+        """Reduced-row echelon form of a and list of pivots"""
+        b = a.copy()
+        K = a.domain
+        partial_pivot = K.is_RealField or K.is_ComplexField
+        pivots = ddm_irref(b, _partial_pivot=partial_pivot)
+        return b, pivots
+
+    def nullspace(a):
+        rref, pivots = a.rref()
+        rows, cols = a.shape
+        domain = a.domain
+
+        basis = []
+        nonpivots = []
+        for i in range(cols):
+            if i in pivots:
+                continue
+            nonpivots.append(i)
+            vec = [domain.one if i == j else domain.zero for j in range(cols)]
+            for ii, jj in enumerate(pivots):
+                vec[jj] -= rref[ii][i]
+            basis.append(vec)
+
+        return DDM(basis, (len(basis), cols), domain), nonpivots
+
+    def particular(a):
+        return a.to_sdm().particular().to_ddm()
+
+    def det(a):
+        """Determinant of a"""
+        m, n = a.shape
+        if m != n:
+            raise DMShapeError("Determinant of non-square matrix")
+        b = a.copy()
+        K = b.domain
+        deta = ddm_idet(b, K)
+        return deta
+
+    def inv(a):
+        """Inverse of a"""
+        m, n = a.shape
+        if m != n:
+            raise DMShapeError("Determinant of non-square matrix")
+        ainv = a.copy()
+        K = a.domain
+        ddm_iinv(ainv, a, K)
+        return ainv
+
+    def lu(a):
+        """L, U decomposition of a"""
+        m, n = a.shape
+        K = a.domain
+
+        U = a.copy()
+        L = a.eye(m, K)
+        swaps = ddm_ilu_split(L, U, K)
+
+        return L, U, swaps
+
+    def lu_solve(a, b):
+        """x where a*x = b"""
+        m, n = a.shape
+        m2, o = b.shape
+        a._check(a, 'lu_solve', b, m, m2)
+
+        L, U, swaps = a.lu()
+        x = a.zeros((n, o), a.domain)
+        ddm_ilu_solve(x, L, U, swaps, b)
+        return x
+
+    def charpoly(a):
+        """Coefficients of characteristic polynomial of a"""
+        K = a.domain
+        m, n = a.shape
+        if m != n:
+            raise DMShapeError("Charpoly of non-square matrix")
+        vec = ddm_berk(a, K)
+        coeffs = [vec[i][0] for i in range(n+1)]
+        return coeffs
+
+    def is_zero_matrix(self):
+        """
+        Says whether this matrix has all zero entries.
+        """
+        zero = self.domain.zero
+        return all(Mij == zero for Mij in self.flatiter())
+
+    def is_upper(self):
+        """
+        Says whether this matrix is upper-triangular. True can be returned
+        even if the matrix is not square.
+        """
+        zero = self.domain.zero
+        return all(Mij == zero for i, Mi in enumerate(self) for Mij in Mi[:i])
+
+    def is_lower(self):
+        """
+        Says whether this matrix is lower-triangular. True can be returned
+        even if the matrix is not square.
+        """
+        zero = self.domain.zero
+        return all(Mij == zero for i, Mi in enumerate(self) for Mij in Mi[i+1:])
+
+    def lll(A, delta=QQ(3, 4)):
+        return ddm_lll(A, delta=delta)
+
+    def lll_transform(A, delta=QQ(3, 4)):
+        return ddm_lll_transform(A, delta=delta)
+
+
+from .sdm import SDM

llmeval-env/lib/python3.10/site-packages/sympy/polys/matrices/dense.py

@@ -0,0 +1,348 @@
+"""
+
+Module for the ddm_* routines for operating on a matrix in list of lists
+matrix representation.
+
+These routines are used internally by the DDM class which also provides a
+friendlier interface for them. The idea here is to implement core matrix
+routines in a way that can be applied to any simple list representation
+without the need to use any particular matrix class. For example we can
+compute the RREF of a matrix like:
+
+    >>> from sympy.polys.matrices.dense import ddm_irref
+    >>> M = [[1, 2, 3], [4, 5, 6]]
+    >>> pivots = ddm_irref(M)
+    >>> M
+    [[1.0, 0.0, -1.0], [0, 1.0, 2.0]]
+
+These are lower-level routines that work mostly in place.The routines at this
+level should not need to know what the domain of the elements is but should
+ideally document what operations they will use and what functions they need to
+be provided with.
+
+The next-level up is the DDM class which uses these routines but wraps them up
+with an interface that handles copying etc and keeps track of the Domain of
+the elements of the matrix:
+
+    >>> from sympy.polys.domains import QQ
+    >>> from sympy.polys.matrices.ddm import DDM
+    >>> M = DDM([[QQ(1), QQ(2), QQ(3)], [QQ(4), QQ(5), QQ(6)]], (2, 3), QQ)
+    >>> M
+    [[1, 2, 3], [4, 5, 6]]
+    >>> Mrref, pivots = M.rref()
+    >>> Mrref
+    [[1, 0, -1], [0, 1, 2]]
+
+"""
+from __future__ import annotations
+from operator import mul
+from .exceptions import (
+    DMShapeError,
+    DMNonInvertibleMatrixError,
+    DMNonSquareMatrixError,
+)
+from typing import Sequence, TypeVar
+from sympy.polys.matrices._typing import RingElement
+
+
+T = TypeVar('T')
+R = TypeVar('R', bound=RingElement)
+
+
+def ddm_transpose(matrix: Sequence[Sequence[T]]) -> list[list[T]]:
+    """matrix transpose"""
+    return list(map(list, zip(*matrix)))
+
+
+def ddm_iadd(a: list[list[R]], b: Sequence[Sequence[R]]) -> None:
+    """a += b"""
+    for ai, bi in zip(a, b):
+        for j, bij in enumerate(bi):
+            ai[j] += bij
+
+
+def ddm_isub(a: list[list[R]], b: Sequence[Sequence[R]]) -> None:
+    """a -= b"""
+    for ai, bi in zip(a, b):
+        for j, bij in enumerate(bi):
+            ai[j] -= bij
+
+
+def ddm_ineg(a: list[list[R]]) -> None:
+    """a  <--  -a"""
+    for ai in a:
+        for j, aij in enumerate(ai):
+            ai[j] = -aij
+
+
+def ddm_imul(a: list[list[R]], b: R) -> None:
+    for ai in a:
+        for j, aij in enumerate(ai):
+            ai[j] = aij * b
+
+
+def ddm_irmul(a: list[list[R]], b: R) -> None:
+    for ai in a:
+        for j, aij in enumerate(ai):
+            ai[j] = b * aij
+
+
+def ddm_imatmul(
+    a: list[list[R]], b: Sequence[Sequence[R]], c: Sequence[Sequence[R]]
+) -> None:
+    """a += b @ c"""
+    cT = list(zip(*c))
+
+    for bi, ai in zip(b, a):
+        for j, cTj in enumerate(cT):
+            ai[j] = sum(map(mul, bi, cTj), ai[j])
+
+
+def ddm_irref(a, _partial_pivot=False):
+    """a  <--  rref(a)"""
+    # a is (m x n)
+    m = len(a)
+    if not m:
+        return []
+    n = len(a[0])
+
+    i = 0
+    pivots = []
+
+    for j in range(n):
+        # Proper pivoting should be used for all domains for performance
+        # reasons but it is only strictly needed for RR and CC (and possibly
+        # other domains like RR(x)). This path is used by DDM.rref() if the
+        # domain is RR or CC. It uses partial (row) pivoting based on the
+        # absolute value of the pivot candidates.
+        if _partial_pivot:
+            ip = max(range(i, m), key=lambda ip: abs(a[ip][j]))
+            a[i], a[ip] = a[ip], a[i]
+
+        # pivot
+        aij = a[i][j]
+
+        # zero-pivot
+        if not aij:
+            for ip in range(i+1, m):
+                aij = a[ip][j]
+                # row-swap
+                if aij:
+                    a[i], a[ip] = a[ip], a[i]
+                    break
+            else:
+                # next column
+                continue
+
+        # normalise row
+        ai = a[i]
+        aijinv = aij**-1
+        for l in range(j, n):
+            ai[l] *= aijinv # ai[j] = one
+
+        # eliminate above and below to the right
+        for k, ak in enumerate(a):
+            if k == i or not ak[j]:
+                continue
+            akj = ak[j]
+            ak[j] -= akj # ak[j] = zero
+            for l in range(j+1, n):
+                ak[l] -= akj * ai[l]
+
+        # next row
+        pivots.append(j)
+        i += 1
+
+        # no more rows?
+        if i >= m:
+            break
+
+    return pivots
+
+
+def ddm_idet(a, K):
+    """a  <--  echelon(a); return det"""
+    # Bareiss algorithm
+    # https://www.math.usm.edu/perry/Research/Thesis_DRL.pdf
+
+    # a is (m x n)
+    m = len(a)
+    if not m:
+        return K.one
+    n = len(a[0])
+
+    exquo = K.exquo
+    # uf keeps track of the sign change from row swaps
+    uf = K.one
+
+    for k in range(n-1):
+        if not a[k][k]:
+            for i in range(k+1, n):
+                if a[i][k]:
+                    a[k], a[i] = a[i], a[k]
+                    uf = -uf
+                    break
+            else:
+                return K.zero
+
+        akkm1 = a[k-1][k-1] if k else K.one
+
+        for i in range(k+1, n):
+            for j in range(k+1, n):
+                a[i][j] = exquo(a[i][j]*a[k][k] - a[i][k]*a[k][j], akkm1)
+
+    return uf * a[-1][-1]
+
+
+def ddm_iinv(ainv, a, K):
+    if not K.is_Field:
+        raise ValueError('Not a field')
+
+    # a is (m x n)
+    m = len(a)
+    if not m:
+        return
+    n = len(a[0])
+    if m != n:
+        raise DMNonSquareMatrixError
+
+    eye = [[K.one if i==j else K.zero for j in range(n)] for i in range(n)]
+    Aaug = [row + eyerow for row, eyerow in zip(a, eye)]
+    pivots = ddm_irref(Aaug)
+    if pivots != list(range(n)):
+        raise DMNonInvertibleMatrixError('Matrix det == 0; not invertible.')
+    ainv[:] = [row[n:] for row in Aaug]
+
+
+def ddm_ilu_split(L, U, K):
+    """L, U  <--  LU(U)"""
+    m = len(U)
+    if not m:
+        return []
+    n = len(U[0])
+
+    swaps = ddm_ilu(U)
+
+    zeros = [K.zero] * min(m, n)
+    for i in range(1, m):
+        j = min(i, n)
+        L[i][:j] = U[i][:j]
+        U[i][:j] = zeros[:j]
+
+    return swaps
+
+
+def ddm_ilu(a):
+    """a  <--  LU(a)"""
+    m = len(a)
+    if not m:
+        return []
+    n = len(a[0])
+
+    swaps = []
+
+    for i in range(min(m, n)):
+        if not a[i][i]:
+            for ip in range(i+1, m):
+                if a[ip][i]:
+                    swaps.append((i, ip))
+                    a[i], a[ip] = a[ip], a[i]
+                    break
+            else:
+                # M = Matrix([[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 1, 1], [0, 0, 1, 2]])
+                continue
+        for j in range(i+1, m):
+            l_ji = a[j][i] / a[i][i]
+            a[j][i] = l_ji
+            for k in range(i+1, n):
+                a[j][k] -= l_ji * a[i][k]
+
+    return swaps
+
+
+def ddm_ilu_solve(x, L, U, swaps, b):
+    """x  <--  solve(L*U*x = swaps(b))"""
+    m = len(U)
+    if not m:
+        return
+    n = len(U[0])
+
+    m2 = len(b)
+    if not m2:
+        raise DMShapeError("Shape mismtch")
+    o = len(b[0])
+
+    if m != m2:
+        raise DMShapeError("Shape mismtch")
+    if m < n:
+        raise NotImplementedError("Underdetermined")
+
+    if swaps:
+        b = [row[:] for row in b]
+        for i1, i2 in swaps:
+            b[i1], b[i2] = b[i2], b[i1]
+
+    # solve Ly = b
+    y = [[None] * o for _ in range(m)]
+    for k in range(o):
+        for i in range(m):
+            rhs = b[i][k]
+            for j in range(i):
+                rhs -= L[i][j] * y[j][k]
+            y[i][k] = rhs
+
+    if m > n:
+        for i in range(n, m):
+            for j in range(o):
+                if y[i][j]:
+                    raise DMNonInvertibleMatrixError
+
+    # Solve Ux = y
+    for k in range(o):
+        for i in reversed(range(n)):
+            if not U[i][i]:
+                raise DMNonInvertibleMatrixError
+            rhs = y[i][k]
+            for j in range(i+1, n):
+                rhs -= U[i][j] * x[j][k]
+            x[i][k] = rhs / U[i][i]
+
+
+def ddm_berk(M, K):
+    m = len(M)
+    if not m:
+        return [[K.one]]
+    n = len(M[0])
+
+    if m != n:
+        raise DMShapeError("Not square")
+
+    if n == 1:
+        return [[K.one], [-M[0][0]]]
+
+    a = M[0][0]
+    R = [M[0][1:]]
+    C = [[row[0]] for row in M[1:]]
+    A = [row[1:] for row in M[1:]]
+
+    q = ddm_berk(A, K)
+
+    T = [[K.zero] * n for _ in range(n+1)]
+    for i in range(n):
+        T[i][i] = K.one
+        T[i+1][i] = -a
+    for i in range(2, n+1):
+        if i == 2:
+            AnC = C
+        else:
+            C = AnC
+            AnC = [[K.zero] for row in C]
+            ddm_imatmul(AnC, A, C)
+        RAnC = [[K.zero]]
+        ddm_imatmul(RAnC, R, AnC)
+        for j in range(0, n+1-i):
+            T[i+j][j] = -RAnC[0][0]
+
+    qout = [[K.zero] for _ in range(n+1)]
+    ddm_imatmul(qout, T, q)
+    return qout

llmeval-env/lib/python3.10/site-packages/sympy/polys/matrices/domainmatrix.py

@@ -0,0 +1,1791 @@
+"""
+
+Module for the DomainMatrix class.
+
+A DomainMatrix represents a matrix with elements that are in a particular
+Domain. Each DomainMatrix internally wraps a DDM which is used for the
+lower-level operations. The idea is that the DomainMatrix class provides the
+convenience routines for converting between Expr and the poly domains as well
+as unifying matrices with different domains.
+
+"""
+from functools import reduce
+from typing import Union as tUnion, Tuple as tTuple
+
+from sympy.core.sympify import _sympify
+
+from ..domains import Domain
+
+from ..constructor import construct_domain
+
+from .exceptions import (DMNonSquareMatrixError, DMShapeError,
+                         DMDomainError, DMFormatError, DMBadInputError,
+                         DMNotAField)
+
+from .ddm import DDM
+
+from .sdm import SDM
+
+from .domainscalar import DomainScalar
+
+from sympy.polys.domains import ZZ, EXRAW, QQ
+
+
+def DM(rows, domain):
+    """Convenient alias for DomainMatrix.from_list
+
+    Examples
+    =======
+
+    >>> from sympy import ZZ
+    >>> from sympy.polys.matrices import DM
+    >>> DM([[1, 2], [3, 4]], ZZ)
+    DomainMatrix([[1, 2], [3, 4]], (2, 2), ZZ)
+
+    See also
+    =======
+
+    DomainMatrix.from_list
+    """
+    return DomainMatrix.from_list(rows, domain)
+
+
+class DomainMatrix:
+    r"""
+    Associate Matrix with :py:class:`~.Domain`
+
+    Explanation
+    ===========
+
+    DomainMatrix uses :py:class:`~.Domain` for its internal representation
+    which makes it faster than the SymPy Matrix class (currently) for many
+    common operations, but this advantage makes it not entirely compatible
+    with Matrix. DomainMatrix are analogous to numpy arrays with "dtype".
+    In the DomainMatrix, each element has a domain such as :ref:`ZZ`
+    or  :ref:`QQ(a)`.
+
+
+    Examples
+    ========
+
+    Creating a DomainMatrix from the existing Matrix class:
+
+    >>> from sympy import Matrix
+    >>> from sympy.polys.matrices import DomainMatrix
+    >>> Matrix1 = Matrix([
+    ...    [1, 2],
+    ...    [3, 4]])
+    >>> A = DomainMatrix.from_Matrix(Matrix1)
+    >>> A
+    DomainMatrix({0: {0: 1, 1: 2}, 1: {0: 3, 1: 4}}, (2, 2), ZZ)
+
+    Directly forming a DomainMatrix:
+
+    >>> from sympy import ZZ
+    >>> from sympy.polys.matrices import DomainMatrix
+    >>> A = DomainMatrix([
+    ...    [ZZ(1), ZZ(2)],
+    ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    >>> A
+    DomainMatrix([[1, 2], [3, 4]], (2, 2), ZZ)
+
+    See Also
+    ========
+
+    DDM
+    SDM
+    Domain
+    Poly
+
+    """
+    rep: tUnion[SDM, DDM]
+    shape: tTuple[int, int]
+    domain: Domain
+
+    def __new__(cls, rows, shape, domain, *, fmt=None):
+        """
+        Creates a :py:class:`~.DomainMatrix`.
+
+        Parameters
+        ==========
+
+        rows : Represents elements of DomainMatrix as list of lists
+        shape : Represents dimension of DomainMatrix
+        domain : Represents :py:class:`~.Domain` of DomainMatrix
+
+        Raises
+        ======
+
+        TypeError
+            If any of rows, shape and domain are not provided
+
+        """
+        if isinstance(rows, (DDM, SDM)):
+            raise TypeError("Use from_rep to initialise from SDM/DDM")
+        elif isinstance(rows, list):
+            rep = DDM(rows, shape, domain)
+        elif isinstance(rows, dict):
+            rep = SDM(rows, shape, domain)
+        else:
+            msg = "Input should be list-of-lists or dict-of-dicts"
+            raise TypeError(msg)
+
+        if fmt is not None:
+            if fmt == 'sparse':
+                rep = rep.to_sdm()
+            elif fmt == 'dense':
+                rep = rep.to_ddm()
+            else:
+                raise ValueError("fmt should be 'sparse' or 'dense'")
+
+        return cls.from_rep(rep)
+
+    def __getnewargs__(self):
+        rep = self.rep
+        if isinstance(rep, DDM):
+            arg = list(rep)
+        elif isinstance(rep, SDM):
+            arg = dict(rep)
+        else:
+            raise RuntimeError # pragma: no cover
+        return arg, self.shape, self.domain
+
+    def __getitem__(self, key):
+        i, j = key
+        m, n = self.shape
+        if not (isinstance(i, slice) or isinstance(j, slice)):
+            return DomainScalar(self.rep.getitem(i, j), self.domain)
+
+        if not isinstance(i, slice):
+            if not -m <= i < m:
+                raise IndexError("Row index out of range")
+            i = i % m
+            i = slice(i, i+1)
+        if not isinstance(j, slice):
+            if not -n <= j < n:
+                raise IndexError("Column index out of range")
+            j = j % n
+            j = slice(j, j+1)
+
+        return self.from_rep(self.rep.extract_slice(i, j))
+
+    def getitem_sympy(self, i, j):
+        return self.domain.to_sympy(self.rep.getitem(i, j))
+
+    def extract(self, rowslist, colslist):
+        return self.from_rep(self.rep.extract(rowslist, colslist))
+
+    def __setitem__(self, key, value):
+        i, j = key
+        if not self.domain.of_type(value):
+            raise TypeError
+        if isinstance(i, int) and isinstance(j, int):
+            self.rep.setitem(i, j, value)
+        else:
+            raise NotImplementedError
+
+    @classmethod
+    def from_rep(cls, rep):
+        """Create a new DomainMatrix efficiently from DDM/SDM.
+
+        Examples
+        ========
+
+        Create a :py:class:`~.DomainMatrix` with an dense internal
+        representation as :py:class:`~.DDM`:
+
+        >>> from sympy.polys.domains import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy.polys.matrices.ddm import DDM
+        >>> drep = DDM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> dM = DomainMatrix.from_rep(drep)
+        >>> dM
+        DomainMatrix([[1, 2], [3, 4]], (2, 2), ZZ)
+
+        Create a :py:class:`~.DomainMatrix` with a sparse internal
+        representation as :py:class:`~.SDM`:
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import ZZ
+        >>> drep = SDM({0:{1:ZZ(1)},1:{0:ZZ(2)}}, (2, 2), ZZ)
+        >>> dM = DomainMatrix.from_rep(drep)
+        >>> dM
+        DomainMatrix({0: {1: 1}, 1: {0: 2}}, (2, 2), ZZ)
+
+        Parameters
+        ==========
+
+        rep: SDM or DDM
+            The internal sparse or dense representation of the matrix.
+
+        Returns
+        =======
+
+        DomainMatrix
+            A :py:class:`~.DomainMatrix` wrapping *rep*.
+
+        Notes
+        =====
+
+        This takes ownership of rep as its internal representation. If rep is
+        being mutated elsewhere then a copy should be provided to
+        ``from_rep``. Only minimal verification or checking is done on *rep*
+        as this is supposed to be an efficient internal routine.
+
+        """
+        if not isinstance(rep, (DDM, SDM)):
+            raise TypeError("rep should be of type DDM or SDM")
+        self = super().__new__(cls)
+        self.rep = rep
+        self.shape = rep.shape
+        self.domain = rep.domain
+        return self
+
+
+    @classmethod
+    def from_list(cls, rows, domain):
+        r"""
+        Convert a list of lists into a DomainMatrix
+
+        Parameters
+        ==========
+
+        rows: list of lists
+            Each element of the inner lists should be either the single arg,
+            or tuple of args, that would be passed to the domain constructor
+            in order to form an element of the domain. See examples.
+
+        Returns
+        =======
+
+        DomainMatrix containing elements defined in rows
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import FF, QQ, ZZ
+        >>> A = DomainMatrix.from_list([[1, 0, 1], [0, 0, 1]], ZZ)
+        >>> A
+        DomainMatrix([[1, 0, 1], [0, 0, 1]], (2, 3), ZZ)
+        >>> B = DomainMatrix.from_list([[1, 0, 1], [0, 0, 1]], FF(7))
+        >>> B
+        DomainMatrix([[1 mod 7, 0 mod 7, 1 mod 7], [0 mod 7, 0 mod 7, 1 mod 7]], (2, 3), GF(7))
+        >>> C = DomainMatrix.from_list([[(1, 2), (3, 1)], [(1, 4), (5, 1)]], QQ)
+        >>> C
+        DomainMatrix([[1/2, 3], [1/4, 5]], (2, 2), QQ)
+
+        See Also
+        ========
+
+        from_list_sympy
+
+        """
+        nrows = len(rows)
+        ncols = 0 if not nrows else len(rows[0])
+        conv = lambda e: domain(*e) if isinstance(e, tuple) else domain(e)
+        domain_rows = [[conv(e) for e in row] for row in rows]
+        return DomainMatrix(domain_rows, (nrows, ncols), domain)
+
+
+    @classmethod
+    def from_list_sympy(cls, nrows, ncols, rows, **kwargs):
+        r"""
+        Convert a list of lists of Expr into a DomainMatrix using construct_domain
+
+        Parameters
+        ==========
+
+        nrows: number of rows
+        ncols: number of columns
+        rows: list of lists
+
+        Returns
+        =======
+
+        DomainMatrix containing elements of rows
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy.abc import x, y, z
+        >>> A = DomainMatrix.from_list_sympy(1, 3, [[x, y, z]])
+        >>> A
+        DomainMatrix([[x, y, z]], (1, 3), ZZ[x,y,z])
+
+        See Also
+        ========
+
+        sympy.polys.constructor.construct_domain, from_dict_sympy
+
+        """
+        assert len(rows) == nrows
+        assert all(len(row) == ncols for row in rows)
+
+        items_sympy = [_sympify(item) for row in rows for item in row]
+
+        domain, items_domain = cls.get_domain(items_sympy, **kwargs)
+
+        domain_rows = [[items_domain[ncols*r + c] for c in range(ncols)] for r in range(nrows)]
+
+        return DomainMatrix(domain_rows, (nrows, ncols), domain)
+
+    @classmethod
+    def from_dict_sympy(cls, nrows, ncols, elemsdict, **kwargs):
+        """
+
+        Parameters
+        ==========
+
+        nrows: number of rows
+        ncols: number of cols
+        elemsdict: dict of dicts containing non-zero elements of the DomainMatrix
+
+        Returns
+        =======
+
+        DomainMatrix containing elements of elemsdict
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy.abc import x,y,z
+        >>> elemsdict = {0: {0:x}, 1:{1: y}, 2: {2: z}}
+        >>> A = DomainMatrix.from_dict_sympy(3, 3, elemsdict)
+        >>> A
+        DomainMatrix({0: {0: x}, 1: {1: y}, 2: {2: z}}, (3, 3), ZZ[x,y,z])
+
+        See Also
+        ========
+
+        from_list_sympy
+
+        """
+        if not all(0 <= r < nrows for r in elemsdict):
+            raise DMBadInputError("Row out of range")
+        if not all(0 <= c < ncols for row in elemsdict.values() for c in row):
+            raise DMBadInputError("Column out of range")
+
+        items_sympy = [_sympify(item) for row in elemsdict.values() for item in row.values()]
+        domain, items_domain = cls.get_domain(items_sympy, **kwargs)
+
+        idx = 0
+        items_dict = {}
+        for i, row in elemsdict.items():
+            items_dict[i] = {}
+            for j in row:
+                items_dict[i][j] = items_domain[idx]
+                idx += 1
+
+        return DomainMatrix(items_dict, (nrows, ncols), domain)
+
+    @classmethod
+    def from_Matrix(cls, M, fmt='sparse',**kwargs):
+        r"""
+        Convert Matrix to DomainMatrix
+
+        Parameters
+        ==========
+
+        M: Matrix
+
+        Returns
+        =======
+
+        Returns DomainMatrix with identical elements as M
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> M = Matrix([
+        ...    [1.0, 3.4],
+        ...    [2.4, 1]])
+        >>> A = DomainMatrix.from_Matrix(M)
+        >>> A
+        DomainMatrix({0: {0: 1.0, 1: 3.4}, 1: {0: 2.4, 1: 1.0}}, (2, 2), RR)
+
+        We can keep internal representation as ddm using fmt='dense'
+        >>> from sympy import Matrix, QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix.from_Matrix(Matrix([[QQ(1, 2), QQ(3, 4)], [QQ(0, 1), QQ(0, 1)]]), fmt='dense')
+        >>> A.rep
+        [[1/2, 3/4], [0, 0]]
+
+        See Also
+        ========
+
+        Matrix
+
+        """
+        if fmt == 'dense':
+            return cls.from_list_sympy(*M.shape, M.tolist(), **kwargs)
+
+        return cls.from_dict_sympy(*M.shape, M.todod(), **kwargs)
+
+    @classmethod
+    def get_domain(cls, items_sympy, **kwargs):
+        K, items_K = construct_domain(items_sympy, **kwargs)
+        return K, items_K
+
+    def copy(self):
+        return self.from_rep(self.rep.copy())
+
+    def convert_to(self, K):
+        r"""
+        Change the domain of DomainMatrix to desired domain or field
+
+        Parameters
+        ==========
+
+        K : Represents the desired domain or field.
+            Alternatively, ``None`` may be passed, in which case this method
+            just returns a copy of this DomainMatrix.
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix with the desired domain or field
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ, ZZ_I
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+
+        >>> A.convert_to(ZZ_I)
+        DomainMatrix([[1, 2], [3, 4]], (2, 2), ZZ_I)
+
+        """
+        if K is None:
+            return self.copy()
+        return self.from_rep(self.rep.convert_to(K))
+
+    def to_sympy(self):
+        return self.convert_to(EXRAW)
+
+    def to_field(self):
+        r"""
+        Returns a DomainMatrix with the appropriate field
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix with the appropriate field
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+
+        >>> A.to_field()
+        DomainMatrix([[1, 2], [3, 4]], (2, 2), QQ)
+
+        """
+        K = self.domain.get_field()
+        return self.convert_to(K)
+
+    def to_sparse(self):
+        """
+        Return a sparse DomainMatrix representation of *self*.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import QQ
+        >>> A = DomainMatrix([[1, 0],[0, 2]], (2, 2), QQ)
+        >>> A.rep
+        [[1, 0], [0, 2]]
+        >>> B = A.to_sparse()
+        >>> B.rep
+        {0: {0: 1}, 1: {1: 2}}
+        """
+        if self.rep.fmt == 'sparse':
+            return self
+
+        return self.from_rep(SDM.from_ddm(self.rep))
+
+    def to_dense(self):
+        """
+        Return a dense DomainMatrix representation of *self*.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import QQ
+        >>> A = DomainMatrix({0: {0: 1}, 1: {1: 2}}, (2, 2), QQ)
+        >>> A.rep
+        {0: {0: 1}, 1: {1: 2}}
+        >>> B = A.to_dense()
+        >>> B.rep
+        [[1, 0], [0, 2]]
+
+        """
+        if self.rep.fmt == 'dense':
+            return self
+
+        return self.from_rep(SDM.to_ddm(self.rep))
+
+    @classmethod
+    def _unify_domain(cls, *matrices):
+        """Convert matrices to a common domain"""
+        domains = {matrix.domain for matrix in matrices}
+        if len(domains) == 1:
+            return matrices
+        domain = reduce(lambda x, y: x.unify(y), domains)
+        return tuple(matrix.convert_to(domain) for matrix in matrices)
+
+    @classmethod
+    def _unify_fmt(cls, *matrices, fmt=None):
+        """Convert matrices to the same format.
+
+        If all matrices have the same format, then return unmodified.
+        Otherwise convert both to the preferred format given as *fmt* which
+        should be 'dense' or 'sparse'.
+        """
+        formats = {matrix.rep.fmt for matrix in matrices}
+        if len(formats) == 1:
+            return matrices
+        if fmt == 'sparse':
+            return tuple(matrix.to_sparse() for matrix in matrices)
+        elif fmt == 'dense':
+            return tuple(matrix.to_dense() for matrix in matrices)
+        else:
+            raise ValueError("fmt should be 'sparse' or 'dense'")
+
+    def unify(self, *others, fmt=None):
+        """
+        Unifies the domains and the format of self and other
+        matrices.
+
+        Parameters
+        ==========
+
+        others : DomainMatrix
+
+        fmt: string 'dense', 'sparse' or `None` (default)
+            The preferred format to convert to if self and other are not
+            already in the same format. If `None` or not specified then no
+            conversion if performed.
+
+        Returns
+        =======
+
+        Tuple[DomainMatrix]
+            Matrices with unified domain and format
+
+        Examples
+        ========
+
+        Unify the domain of DomainMatrix that have different domains:
+
+        >>> from sympy import ZZ, QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([[ZZ(1), ZZ(2)]], (1, 2), ZZ)
+        >>> B = DomainMatrix([[QQ(1, 2), QQ(2)]], (1, 2), QQ)
+        >>> Aq, Bq = A.unify(B)
+        >>> Aq
+        DomainMatrix([[1, 2]], (1, 2), QQ)
+        >>> Bq
+        DomainMatrix([[1/2, 2]], (1, 2), QQ)
+
+        Unify the format (dense or sparse):
+
+        >>> A = DomainMatrix([[ZZ(1), ZZ(2)]], (1, 2), ZZ)
+        >>> B = DomainMatrix({0:{0: ZZ(1)}}, (2, 2), ZZ)
+        >>> B.rep
+        {0: {0: 1}}
+
+        >>> A2, B2 = A.unify(B, fmt='dense')
+        >>> B2.rep
+        [[1, 0], [0, 0]]
+
+        See Also
+        ========
+
+        convert_to, to_dense, to_sparse
+
+        """
+        matrices = (self,) + others
+        matrices = DomainMatrix._unify_domain(*matrices)
+        if fmt is not None:
+            matrices = DomainMatrix._unify_fmt(*matrices, fmt=fmt)
+        return matrices
+
+    def to_Matrix(self):
+        r"""
+        Convert DomainMatrix to Matrix
+
+        Returns
+        =======
+
+        Matrix
+            MutableDenseMatrix for the DomainMatrix
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+
+        >>> A.to_Matrix()
+        Matrix([
+            [1, 2],
+            [3, 4]])
+
+        See Also
+        ========
+
+        from_Matrix
+
+        """
+        from sympy.matrices.dense import MutableDenseMatrix
+        elemlist = self.rep.to_list()
+        elements_sympy = [self.domain.to_sympy(e) for row in elemlist for e in row]
+        return MutableDenseMatrix(*self.shape, elements_sympy)
+
+    def to_list(self):
+        return self.rep.to_list()
+
+    def to_list_flat(self):
+        return self.rep.to_list_flat()
+
+    def to_dok(self):
+        return self.rep.to_dok()
+
+    def __repr__(self):
+        return 'DomainMatrix(%s, %r, %r)' % (str(self.rep), self.shape, self.domain)
+
+    def transpose(self):
+        """Matrix transpose of ``self``"""
+        return self.from_rep(self.rep.transpose())
+
+    def flat(self):
+        rows, cols = self.shape
+        return [self[i,j].element for i in range(rows) for j in range(cols)]
+
+    @property
+    def is_zero_matrix(self):
+        return self.rep.is_zero_matrix()
+
+    @property
+    def is_upper(self):
+        """
+        Says whether this matrix is upper-triangular. True can be returned
+        even if the matrix is not square.
+        """
+        return self.rep.is_upper()
+
+    @property
+    def is_lower(self):
+        """
+        Says whether this matrix is lower-triangular. True can be returned
+        even if the matrix is not square.
+        """
+        return self.rep.is_lower()
+
+    @property
+    def is_square(self):
+        return self.shape[0] == self.shape[1]
+
+    def rank(self):
+        rref, pivots = self.rref()
+        return len(pivots)
+
+    def hstack(A, *B):
+        r"""Horizontally stack the given matrices.
+
+        Parameters
+        ==========
+
+        B: DomainMatrix
+            Matrices to stack horizontally.
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix by stacking horizontally.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+
+        >>> A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DomainMatrix([[ZZ(5), ZZ(6)], [ZZ(7), ZZ(8)]], (2, 2), ZZ)
+        >>> A.hstack(B)
+        DomainMatrix([[1, 2, 5, 6], [3, 4, 7, 8]], (2, 4), ZZ)
+
+        >>> C = DomainMatrix([[ZZ(9), ZZ(10)], [ZZ(11), ZZ(12)]], (2, 2), ZZ)
+        >>> A.hstack(B, C)
+        DomainMatrix([[1, 2, 5, 6, 9, 10], [3, 4, 7, 8, 11, 12]], (2, 6), ZZ)
+
+        See Also
+        ========
+
+        unify
+        """
+        A, *B = A.unify(*B, fmt='dense')
+        return DomainMatrix.from_rep(A.rep.hstack(*(Bk.rep for Bk in B)))
+
+    def vstack(A, *B):
+        r"""Vertically stack the given matrices.
+
+        Parameters
+        ==========
+
+        B: DomainMatrix
+            Matrices to stack vertically.
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix by stacking vertically.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+
+        >>> A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DomainMatrix([[ZZ(5), ZZ(6)], [ZZ(7), ZZ(8)]], (2, 2), ZZ)
+        >>> A.vstack(B)
+        DomainMatrix([[1, 2], [3, 4], [5, 6], [7, 8]], (4, 2), ZZ)
+
+        >>> C = DomainMatrix([[ZZ(9), ZZ(10)], [ZZ(11), ZZ(12)]], (2, 2), ZZ)
+        >>> A.vstack(B, C)
+        DomainMatrix([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12]], (6, 2), ZZ)
+
+        See Also
+        ========
+
+        unify
+        """
+        A, *B = A.unify(*B, fmt='dense')
+        return DomainMatrix.from_rep(A.rep.vstack(*(Bk.rep for Bk in B)))
+
+    def applyfunc(self, func, domain=None):
+        if domain is None:
+            domain = self.domain
+        return self.from_rep(self.rep.applyfunc(func, domain))
+
+    def __add__(A, B):
+        if not isinstance(B, DomainMatrix):
+            return NotImplemented
+        A, B = A.unify(B, fmt='dense')
+        return A.add(B)
+
+    def __sub__(A, B):
+        if not isinstance(B, DomainMatrix):
+            return NotImplemented
+        A, B = A.unify(B, fmt='dense')
+        return A.sub(B)
+
+    def __neg__(A):
+        return A.neg()
+
+    def __mul__(A, B):
+        """A * B"""
+        if isinstance(B, DomainMatrix):
+            A, B = A.unify(B, fmt='dense')
+            return A.matmul(B)
+        elif B in A.domain:
+            return A.scalarmul(B)
+        elif isinstance(B, DomainScalar):
+            A, B = A.unify(B)
+            return A.scalarmul(B.element)
+        else:
+            return NotImplemented
+
+    def __rmul__(A, B):
+        if B in A.domain:
+            return A.rscalarmul(B)
+        elif isinstance(B, DomainScalar):
+            A, B = A.unify(B)
+            return A.rscalarmul(B.element)
+        else:
+            return NotImplemented
+
+    def __pow__(A, n):
+        """A ** n"""
+        if not isinstance(n, int):
+            return NotImplemented
+        return A.pow(n)
+
+    def _check(a, op, b, ashape, bshape):
+        if a.domain != b.domain:
+            msg = "Domain mismatch: %s %s %s" % (a.domain, op, b.domain)
+            raise DMDomainError(msg)
+        if ashape != bshape:
+            msg = "Shape mismatch: %s %s %s" % (a.shape, op, b.shape)
+            raise DMShapeError(msg)
+        if a.rep.fmt != b.rep.fmt:
+            msg = "Format mismatch: %s %s %s" % (a.rep.fmt, op, b.rep.fmt)
+            raise DMFormatError(msg)
+
+    def add(A, B):
+        r"""
+        Adds two DomainMatrix matrices of the same Domain
+
+        Parameters
+        ==========
+
+        A, B: DomainMatrix
+            matrices to add
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix after Addition
+
+        Raises
+        ======
+
+        DMShapeError
+            If the dimensions of the two DomainMatrix are not equal
+
+        ValueError
+            If the domain of the two DomainMatrix are not same
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DomainMatrix([
+        ...    [ZZ(4), ZZ(3)],
+        ...    [ZZ(2), ZZ(1)]], (2, 2), ZZ)
+
+        >>> A.add(B)
+        DomainMatrix([[5, 5], [5, 5]], (2, 2), ZZ)
+
+        See Also
+        ========
+
+        sub, matmul
+
+        """
+        A._check('+', B, A.shape, B.shape)
+        return A.from_rep(A.rep.add(B.rep))
+
+
+    def sub(A, B):
+        r"""
+        Subtracts two DomainMatrix matrices of the same Domain
+
+        Parameters
+        ==========
+
+        A, B: DomainMatrix
+            matrices to subtract
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix after Subtraction
+
+        Raises
+        ======
+
+        DMShapeError
+            If the dimensions of the two DomainMatrix are not equal
+
+        ValueError
+            If the domain of the two DomainMatrix are not same
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DomainMatrix([
+        ...    [ZZ(4), ZZ(3)],
+        ...    [ZZ(2), ZZ(1)]], (2, 2), ZZ)
+
+        >>> A.sub(B)
+        DomainMatrix([[-3, -1], [1, 3]], (2, 2), ZZ)
+
+        See Also
+        ========
+
+        add, matmul
+
+        """
+        A._check('-', B, A.shape, B.shape)
+        return A.from_rep(A.rep.sub(B.rep))
+
+    def neg(A):
+        r"""
+        Returns the negative of DomainMatrix
+
+        Parameters
+        ==========
+
+        A : Represents a DomainMatrix
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix after Negation
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+
+        >>> A.neg()
+        DomainMatrix([[-1, -2], [-3, -4]], (2, 2), ZZ)
+
+        """
+        return A.from_rep(A.rep.neg())
+
+    def mul(A, b):
+        r"""
+        Performs term by term multiplication for the second DomainMatrix
+        w.r.t first DomainMatrix. Returns a DomainMatrix whose rows are
+        list of DomainMatrix matrices created after term by term multiplication.
+
+        Parameters
+        ==========
+
+        A, B: DomainMatrix
+            matrices to multiply term-wise
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix after term by term multiplication
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DomainMatrix([
+        ...    [ZZ(1), ZZ(1)],
+        ...    [ZZ(0), ZZ(1)]], (2, 2), ZZ)
+
+        >>> A.mul(B)
+        DomainMatrix([[DomainMatrix([[1, 1], [0, 1]], (2, 2), ZZ),
+        DomainMatrix([[2, 2], [0, 2]], (2, 2), ZZ)],
+        [DomainMatrix([[3, 3], [0, 3]], (2, 2), ZZ),
+        DomainMatrix([[4, 4], [0, 4]], (2, 2), ZZ)]], (2, 2), ZZ)
+
+        See Also
+        ========
+
+        matmul
+
+        """
+        return A.from_rep(A.rep.mul(b))
+
+    def rmul(A, b):
+        return A.from_rep(A.rep.rmul(b))
+
+    def matmul(A, B):
+        r"""
+        Performs matrix multiplication of two DomainMatrix matrices
+
+        Parameters
+        ==========
+
+        A, B: DomainMatrix
+            to multiply
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix after multiplication
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DomainMatrix([
+        ...    [ZZ(1), ZZ(1)],
+        ...    [ZZ(0), ZZ(1)]], (2, 2), ZZ)
+
+        >>> A.matmul(B)
+        DomainMatrix([[1, 3], [3, 7]], (2, 2), ZZ)
+
+        See Also
+        ========
+
+        mul, pow, add, sub
+
+        """
+
+        A._check('*', B, A.shape[1], B.shape[0])
+        return A.from_rep(A.rep.matmul(B.rep))
+
+    def _scalarmul(A, lamda, reverse):
+        if lamda == A.domain.zero:
+            return DomainMatrix.zeros(A.shape, A.domain)
+        elif lamda == A.domain.one:
+            return A.copy()
+        elif reverse:
+            return A.rmul(lamda)
+        else:
+            return A.mul(lamda)
+
+    def scalarmul(A, lamda):
+        return A._scalarmul(lamda, reverse=False)
+
+    def rscalarmul(A, lamda):
+        return A._scalarmul(lamda, reverse=True)
+
+    def mul_elementwise(A, B):
+        assert A.domain == B.domain
+        return A.from_rep(A.rep.mul_elementwise(B.rep))
+
+    def __truediv__(A, lamda):
+        """ Method for Scalar Division"""
+        if isinstance(lamda, int) or ZZ.of_type(lamda):
+            lamda = DomainScalar(ZZ(lamda), ZZ)
+
+        if not isinstance(lamda, DomainScalar):
+            return NotImplemented
+
+        A, lamda = A.to_field().unify(lamda)
+        if lamda.element == lamda.domain.zero:
+            raise ZeroDivisionError
+        if lamda.element == lamda.domain.one:
+            return A.to_field()
+
+        return A.mul(1 / lamda.element)
+
+    def pow(A, n):
+        r"""
+        Computes A**n
+
+        Parameters
+        ==========
+
+        A : DomainMatrix
+
+        n : exponent for A
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix on computing A**n
+
+        Raises
+        ======
+
+        NotImplementedError
+            if n is negative.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(1)],
+        ...    [ZZ(0), ZZ(1)]], (2, 2), ZZ)
+
+        >>> A.pow(2)
+        DomainMatrix([[1, 2], [0, 1]], (2, 2), ZZ)
+
+        See Also
+        ========
+
+        matmul
+
+        """
+        nrows, ncols = A.shape
+        if nrows != ncols:
+            raise DMNonSquareMatrixError('Power of a nonsquare matrix')
+        if n < 0:
+            raise NotImplementedError('Negative powers')
+        elif n == 0:
+            return A.eye(nrows, A.domain)
+        elif n == 1:
+            return A
+        elif n % 2 == 1:
+            return A * A**(n - 1)
+        else:
+            sqrtAn = A ** (n // 2)
+            return sqrtAn * sqrtAn
+
+    def scc(self):
+        """Compute the strongly connected components of a DomainMatrix
+
+        Explanation
+        ===========
+
+        A square matrix can be considered as the adjacency matrix for a
+        directed graph where the row and column indices are the vertices. In
+        this graph if there is an edge from vertex ``i`` to vertex ``j`` if
+        ``M[i, j]`` is nonzero. This routine computes the strongly connected
+        components of that graph which are subsets of the rows and columns that
+        are connected by some nonzero element of the matrix. The strongly
+        connected components are useful because many operations such as the
+        determinant can be computed by working with the submatrices
+        corresponding to each component.
+
+        Examples
+        ========
+
+        Find the strongly connected components of a matrix:
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> M = DomainMatrix([[ZZ(1), ZZ(0), ZZ(2)],
+        ...                   [ZZ(0), ZZ(3), ZZ(0)],
+        ...                   [ZZ(4), ZZ(6), ZZ(5)]], (3, 3), ZZ)
+        >>> M.scc()
+        [[1], [0, 2]]
+
+        Compute the determinant from the components:
+
+        >>> MM = M.to_Matrix()
+        >>> MM
+        Matrix([
+        [1, 0, 2],
+        [0, 3, 0],
+        [4, 6, 5]])
+        >>> MM[[1], [1]]
+        Matrix([[3]])
+        >>> MM[[0, 2], [0, 2]]
+        Matrix([
+        [1, 2],
+        [4, 5]])
+        >>> MM.det()
+        -9
+        >>> MM[[1], [1]].det() * MM[[0, 2], [0, 2]].det()
+        -9
+
+        The components are given in reverse topological order and represent a
+        permutation of the rows and columns that will bring the matrix into
+        block lower-triangular form:
+
+        >>> MM[[1, 0, 2], [1, 0, 2]]
+        Matrix([
+        [3, 0, 0],
+        [0, 1, 2],
+        [6, 4, 5]])
+
+        Returns
+        =======
+
+        List of lists of integers
+            Each list represents a strongly connected component.
+
+        See also
+        ========
+
+        sympy.matrices.matrices.MatrixBase.strongly_connected_components
+        sympy.utilities.iterables.strongly_connected_components
+
+        """
+        rows, cols = self.shape
+        assert rows == cols
+        return self.rep.scc()
+
+    def rref(self):
+        r"""
+        Returns reduced-row echelon form and list of pivots for the DomainMatrix
+
+        Returns
+        =======
+
+        (DomainMatrix, list)
+            reduced-row echelon form and list of pivots for the DomainMatrix
+
+        Raises
+        ======
+
+        ValueError
+            If the domain of DomainMatrix not a Field
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...     [QQ(2), QQ(-1), QQ(0)],
+        ...     [QQ(-1), QQ(2), QQ(-1)],
+        ...     [QQ(0), QQ(0), QQ(2)]], (3, 3), QQ)
+
+        >>> rref_matrix, rref_pivots = A.rref()
+        >>> rref_matrix
+        DomainMatrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]], (3, 3), QQ)
+        >>> rref_pivots
+        (0, 1, 2)
+
+        See Also
+        ========
+
+        convert_to, lu
+
+        """
+        if not self.domain.is_Field:
+            raise DMNotAField('Not a field')
+        rref_ddm, pivots = self.rep.rref()
+        return self.from_rep(rref_ddm), tuple(pivots)
+
+    def columnspace(self):
+        r"""
+        Returns the columnspace for the DomainMatrix
+
+        Returns
+        =======
+
+        DomainMatrix
+            The columns of this matrix form a basis for the columnspace.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [QQ(1), QQ(-1)],
+        ...    [QQ(2), QQ(-2)]], (2, 2), QQ)
+        >>> A.columnspace()
+        DomainMatrix([[1], [2]], (2, 1), QQ)
+
+        """
+        if not self.domain.is_Field:
+            raise DMNotAField('Not a field')
+        rref, pivots = self.rref()
+        rows, cols = self.shape
+        return self.extract(range(rows), pivots)
+
+    def rowspace(self):
+        r"""
+        Returns the rowspace for the DomainMatrix
+
+        Returns
+        =======
+
+        DomainMatrix
+            The rows of this matrix form a basis for the rowspace.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [QQ(1), QQ(-1)],
+        ...    [QQ(2), QQ(-2)]], (2, 2), QQ)
+        >>> A.rowspace()
+        DomainMatrix([[1, -1]], (1, 2), QQ)
+
+        """
+        if not self.domain.is_Field:
+            raise DMNotAField('Not a field')
+        rref, pivots = self.rref()
+        rows, cols = self.shape
+        return self.extract(range(len(pivots)), range(cols))
+
+    def nullspace(self):
+        r"""
+        Returns the nullspace for the DomainMatrix
+
+        Returns
+        =======
+
+        DomainMatrix
+            The rows of this matrix form a basis for the nullspace.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [QQ(1), QQ(-1)],
+        ...    [QQ(2), QQ(-2)]], (2, 2), QQ)
+        >>> A.nullspace()
+        DomainMatrix([[1, 1]], (1, 2), QQ)
+
+        """
+        if not self.domain.is_Field:
+            raise DMNotAField('Not a field')
+        return self.from_rep(self.rep.nullspace()[0])
+
+    def inv(self):
+        r"""
+        Finds the inverse of the DomainMatrix if exists
+
+        Returns
+        =======
+
+        DomainMatrix
+            DomainMatrix after inverse
+
+        Raises
+        ======
+
+        ValueError
+            If the domain of DomainMatrix not a Field
+
+        DMNonSquareMatrixError
+            If the DomainMatrix is not a not Square DomainMatrix
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...     [QQ(2), QQ(-1), QQ(0)],
+        ...     [QQ(-1), QQ(2), QQ(-1)],
+        ...     [QQ(0), QQ(0), QQ(2)]], (3, 3), QQ)
+        >>> A.inv()
+        DomainMatrix([[2/3, 1/3, 1/6], [1/3, 2/3, 1/3], [0, 0, 1/2]], (3, 3), QQ)
+
+        See Also
+        ========
+
+        neg
+
+        """
+        if not self.domain.is_Field:
+            raise DMNotAField('Not a field')
+        m, n = self.shape
+        if m != n:
+            raise DMNonSquareMatrixError
+        inv = self.rep.inv()
+        return self.from_rep(inv)
+
+    def det(self):
+        r"""
+        Returns the determinant of a Square DomainMatrix
+
+        Returns
+        =======
+
+        S.Complexes
+            determinant of Square DomainMatrix
+
+        Raises
+        ======
+
+        ValueError
+            If the domain of DomainMatrix not a Field
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+
+        >>> A.det()
+        -2
+
+        """
+        m, n = self.shape
+        if m != n:
+            raise DMNonSquareMatrixError
+        return self.rep.det()
+
+    def lu(self):
+        r"""
+        Returns Lower and Upper decomposition of the DomainMatrix
+
+        Returns
+        =======
+
+        (L, U, exchange)
+            L, U are Lower and Upper decomposition of the DomainMatrix,
+            exchange is the list of indices of rows exchanged in the decomposition.
+
+        Raises
+        ======
+
+        ValueError
+            If the domain of DomainMatrix not a Field
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [QQ(1), QQ(-1)],
+        ...    [QQ(2), QQ(-2)]], (2, 2), QQ)
+        >>> A.lu()
+        (DomainMatrix([[1, 0], [2, 1]], (2, 2), QQ), DomainMatrix([[1, -1], [0, 0]], (2, 2), QQ), [])
+
+        See Also
+        ========
+
+        lu_solve
+
+        """
+        if not self.domain.is_Field:
+            raise DMNotAField('Not a field')
+        L, U, swaps = self.rep.lu()
+        return self.from_rep(L), self.from_rep(U), swaps
+
+    def lu_solve(self, rhs):
+        r"""
+        Solver for DomainMatrix x in the A*x = B
+
+        Parameters
+        ==========
+
+        rhs : DomainMatrix B
+
+        Returns
+        =======
+
+        DomainMatrix
+            x in A*x = B
+
+        Raises
+        ======
+
+        DMShapeError
+            If the DomainMatrix A and rhs have different number of rows
+
+        ValueError
+            If the domain of DomainMatrix A not a Field
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [QQ(1), QQ(2)],
+        ...    [QQ(3), QQ(4)]], (2, 2), QQ)
+        >>> B = DomainMatrix([
+        ...    [QQ(1), QQ(1)],
+        ...    [QQ(0), QQ(1)]], (2, 2), QQ)
+
+        >>> A.lu_solve(B)
+        DomainMatrix([[-2, -1], [3/2, 1]], (2, 2), QQ)
+
+        See Also
+        ========
+
+        lu
+
+        """
+        if self.shape[0] != rhs.shape[0]:
+            raise DMShapeError("Shape")
+        if not self.domain.is_Field:
+            raise DMNotAField('Not a field')
+        sol = self.rep.lu_solve(rhs.rep)
+        return self.from_rep(sol)
+
+    def _solve(A, b):
+        # XXX: Not sure about this method or its signature. It is just created
+        # because it is needed by the holonomic module.
+        if A.shape[0] != b.shape[0]:
+            raise DMShapeError("Shape")
+        if A.domain != b.domain or not A.domain.is_Field:
+            raise DMNotAField('Not a field')
+        Aaug = A.hstack(b)
+        Arref, pivots = Aaug.rref()
+        particular = Arref.from_rep(Arref.rep.particular())
+        nullspace_rep, nonpivots = Arref[:,:-1].rep.nullspace()
+        nullspace = Arref.from_rep(nullspace_rep)
+        return particular, nullspace
+
+    def charpoly(self):
+        r"""
+        Returns the coefficients of the characteristic polynomial
+        of the DomainMatrix. These elements will be domain elements.
+        The domain of the elements will be same as domain of the DomainMatrix.
+
+        Returns
+        =======
+
+        list
+            coefficients of the characteristic polynomial
+
+        Raises
+        ======
+
+        DMNonSquareMatrixError
+            If the DomainMatrix is not a not Square DomainMatrix
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+
+        >>> A.charpoly()
+        [1, -5, -2]
+
+        """
+        m, n = self.shape
+        if m != n:
+            raise DMNonSquareMatrixError("not square")
+        return self.rep.charpoly()
+
+    @classmethod
+    def eye(cls, shape, domain):
+        r"""
+        Return identity matrix of size n
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import QQ
+        >>> DomainMatrix.eye(3, QQ)
+        DomainMatrix({0: {0: 1}, 1: {1: 1}, 2: {2: 1}}, (3, 3), QQ)
+
+        """
+        if isinstance(shape, int):
+            shape = (shape, shape)
+        return cls.from_rep(SDM.eye(shape, domain))
+
+    @classmethod
+    def diag(cls, diagonal, domain, shape=None):
+        r"""
+        Return diagonal matrix with entries from ``diagonal``.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import ZZ
+        >>> DomainMatrix.diag([ZZ(5), ZZ(6)], ZZ)
+        DomainMatrix({0: {0: 5}, 1: {1: 6}}, (2, 2), ZZ)
+
+        """
+        if shape is None:
+            N = len(diagonal)
+            shape = (N, N)
+        return cls.from_rep(SDM.diag(diagonal, domain, shape))
+
+    @classmethod
+    def zeros(cls, shape, domain, *, fmt='sparse'):
+        """Returns a zero DomainMatrix of size shape, belonging to the specified domain
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import QQ
+        >>> DomainMatrix.zeros((2, 3), QQ)
+        DomainMatrix({}, (2, 3), QQ)
+
+        """
+        return cls.from_rep(SDM.zeros(shape, domain))
+
+    @classmethod
+    def ones(cls, shape, domain):
+        """Returns a DomainMatrix of 1s, of size shape, belonging to the specified domain
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> from sympy import QQ
+        >>> DomainMatrix.ones((2,3), QQ)
+        DomainMatrix([[1, 1, 1], [1, 1, 1]], (2, 3), QQ)
+
+        """
+        return cls.from_rep(DDM.ones(shape, domain))
+
+    def __eq__(A, B):
+        r"""
+        Checks for two DomainMatrix matrices to be equal or not
+
+        Parameters
+        ==========
+
+        A, B: DomainMatrix
+            to check equality
+
+        Returns
+        =======
+
+        Boolean
+            True for equal, else False
+
+        Raises
+        ======
+
+        NotImplementedError
+            If B is not a DomainMatrix
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices import DomainMatrix
+        >>> A = DomainMatrix([
+        ...    [ZZ(1), ZZ(2)],
+        ...    [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+        >>> B = DomainMatrix([
+        ...    [ZZ(1), ZZ(1)],
+        ...    [ZZ(0), ZZ(1)]], (2, 2), ZZ)
+        >>> A.__eq__(A)
+        True
+        >>> A.__eq__(B)
+        False
+
+        """
+        if not isinstance(A, type(B)):
+            return NotImplemented
+        return A.domain == B.domain and A.rep == B.rep
+
+    def unify_eq(A, B):
+        if A.shape != B.shape:
+            return False
+        if A.domain != B.domain:
+            A, B = A.unify(B)
+        return A == B
+
+    def lll(A, delta=QQ(3, 4)):
+        """
+        Performs the Lenstra–Lenstra–Lovász (LLL) basis reduction algorithm.
+        See [1]_ and [2]_.
+
+        Parameters
+        ==========
+
+        delta : QQ, optional
+            The Lovász parameter. Must be in the interval (0.25, 1), with larger
+            values producing a more reduced basis. The default is 0.75 for
+            historical reasons.
+
+        Returns
+        =======
+
+        The reduced basis as a DomainMatrix over ZZ.
+
+        Throws
+        ======
+
+        DMValueError: if delta is not in the range (0.25, 1)
+        DMShapeError: if the matrix is not of shape (m, n) with m <= n
+        DMDomainError: if the matrix domain is not ZZ
+        DMRankError: if the matrix contains linearly dependent rows
+
+        Examples
+        ========
+
+        >>> from sympy.polys.domains import ZZ, QQ
+        >>> from sympy.polys.matrices import DM
+        >>> x = DM([[1, 0, 0, 0, -20160],
+        ...         [0, 1, 0, 0, 33768],
+        ...         [0, 0, 1, 0, 39578],
+        ...         [0, 0, 0, 1, 47757]], ZZ)
+        >>> y = DM([[10, -3, -2, 8, -4],
+        ...         [3, -9, 8, 1, -11],
+        ...         [-3, 13, -9, -3, -9],
+        ...         [-12, -7, -11, 9, -1]], ZZ)
+        >>> assert x.lll(delta=QQ(5, 6)) == y
+
+        Notes
+        =====
+
+        The implementation is derived from the Maple code given in Figures 4.3
+        and 4.4 of [3]_ (pp.68-69). It uses the efficient method of only calculating
+        state updates as they are required.
+
+        See also
+        ========
+
+        lll_transform
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Lenstra–Lenstra–Lovász_lattice_basis_reduction_algorithm
+        .. [2] https://web.archive.org/web/20221029115428/https://web.cs.elte.hu/~lovasz/scans/lll.pdf
+        .. [3] Murray R. Bremner, "Lattice Basis Reduction: An Introduction to the LLL Algorithm and Its Applications"
+
+        """
+        return DomainMatrix.from_rep(A.rep.lll(delta=delta))
+
+    def lll_transform(A, delta=QQ(3, 4)):
+        """
+        Performs the Lenstra–Lenstra–Lovász (LLL) basis reduction algorithm
+        and returns the reduced basis and transformation matrix.
+
+        Explanation
+        ===========
+
+        Parameters, algorithm and basis are the same as for :meth:`lll` except that
+        the return value is a tuple `(B, T)` with `B` the reduced basis and
+        `T` a transformation matrix. The original basis `A` is transformed to
+        `B` with `T*A == B`. If only `B` is needed then :meth:`lll` should be
+        used as it is a little faster.
+
+        Examples
+        ========
+
+        >>> from sympy.polys.domains import ZZ, QQ
+        >>> from sympy.polys.matrices import DM
+        >>> X = DM([[1, 0, 0, 0, -20160],
+        ...         [0, 1, 0, 0, 33768],
+        ...         [0, 0, 1, 0, 39578],
+        ...         [0, 0, 0, 1, 47757]], ZZ)
+        >>> B, T = X.lll_transform(delta=QQ(5, 6))
+        >>> T * X == B
+        True
+
+        See also
+        ========
+
+        lll
+
+        """
+        reduced, transform = A.rep.lll_transform(delta=delta)
+        return DomainMatrix.from_rep(reduced), DomainMatrix.from_rep(transform)

llmeval-env/lib/python3.10/site-packages/sympy/polys/matrices/domainscalar.py

@@ -0,0 +1,116 @@
+"""
+
+Module for the DomainScalar class.
+
+A DomainScalar represents an element which is in a particular
+Domain. The idea is that the DomainScalar class provides the
+convenience routines for unifying elements with different domains.
+
+It assists in Scalar Multiplication and getitem for DomainMatrix.
+
+"""
+from ..constructor import construct_domain
+
+from sympy.polys.domains import Domain, ZZ
+
+
+class DomainScalar:
+    r"""
+    docstring
+    """
+
+    def __new__(cls, element, domain):
+        if not isinstance(domain, Domain):
+            raise TypeError("domain should be of type Domain")
+        if not domain.of_type(element):
+            raise TypeError("element %s should be in domain %s" % (element, domain))
+        return cls.new(element, domain)
+
+    @classmethod
+    def new(cls, element, domain):
+        obj = super().__new__(cls)
+        obj.element = element
+        obj.domain = domain
+        return obj
+
+    def __repr__(self):
+        return repr(self.element)
+
+    @classmethod
+    def from_sympy(cls, expr):
+        [domain, [element]] = construct_domain([expr])
+        return cls.new(element, domain)
+
+    def to_sympy(self):
+        return self.domain.to_sympy(self.element)
+
+    def to_domain(self, domain):
+        element = domain.convert_from(self.element, self.domain)
+        return self.new(element, domain)
+
+    def convert_to(self, domain):
+        return self.to_domain(domain)
+
+    def unify(self, other):
+        domain = self.domain.unify(other.domain)
+        return self.to_domain(domain), other.to_domain(domain)
+
+    def __add__(self, other):
+        if not isinstance(other, DomainScalar):
+            return NotImplemented
+        self, other = self.unify(other)
+        return self.new(self.element + other.element, self.domain)
+
+    def __sub__(self, other):
+        if not isinstance(other, DomainScalar):
+            return NotImplemented
+        self, other = self.unify(other)
+        return self.new(self.element - other.element, self.domain)
+
+    def __mul__(self, other):
+        if not isinstance(other, DomainScalar):
+            if isinstance(other, int):
+                other = DomainScalar(ZZ(other), ZZ)
+            else:
+                return NotImplemented
+
+        self, other = self.unify(other)
+        return self.new(self.element * other.element, self.domain)
+
+    def __floordiv__(self, other):
+        if not isinstance(other, DomainScalar):
+            return NotImplemented
+        self, other = self.unify(other)
+        return self.new(self.domain.quo(self.element, other.element), self.domain)
+
+    def __mod__(self, other):
+        if not isinstance(other, DomainScalar):
+            return NotImplemented
+        self, other = self.unify(other)
+        return self.new(self.domain.rem(self.element, other.element), self.domain)
+
+    def __divmod__(self, other):
+        if not isinstance(other, DomainScalar):
+            return NotImplemented
+        self, other = self.unify(other)
+        q, r = self.domain.div(self.element, other.element)
+        return (self.new(q, self.domain), self.new(r, self.domain))
+
+    def __pow__(self, n):
+        if not isinstance(n, int):
+            return NotImplemented
+        return self.new(self.element**n, self.domain)
+
+    def __pos__(self):
+        return self.new(+self.element, self.domain)
+
+    def __eq__(self, other):
+        if not isinstance(other, DomainScalar):
+            return NotImplemented
+        return self.element == other.element and self.domain == other.domain
+
+    def is_zero(self):
+        return self.element == self.domain.zero
+
+    def is_one(self):
+        return self.element == self.domain.one

llmeval-env/lib/python3.10/site-packages/sympy/polys/matrices/eigen.py

@@ -0,0 +1,90 @@
+"""
+
+Routines for computing eigenvectors with DomainMatrix.
+
+"""
+from sympy.core.symbol import Dummy
+
+from ..agca.extensions import FiniteExtension
+from ..factortools import dup_factor_list
+from ..polyroots import roots
+from ..polytools import Poly
+from ..rootoftools import CRootOf
+
+from .domainmatrix import DomainMatrix
+
+
+def dom_eigenvects(A, l=Dummy('lambda')):
+    charpoly = A.charpoly()
+    rows, cols = A.shape
+    domain = A.domain
+    _, factors = dup_factor_list(charpoly, domain)
+
+    rational_eigenvects = []
+    algebraic_eigenvects = []
+    for base, exp in factors:
+        if len(base) == 2:
+            field = domain
+            eigenval = -base[1] / base[0]
+
+            EE_items = [
+                [eigenval if i == j else field.zero for j in range(cols)]
+                for i in range(rows)]
+            EE = DomainMatrix(EE_items, (rows, cols), field)
+
+            basis = (A - EE).nullspace()
+            rational_eigenvects.append((field, eigenval, exp, basis))
+        else:
+            minpoly = Poly.from_list(base, l, domain=domain)
+            field = FiniteExtension(minpoly)
+            eigenval = field(l)
+
+            AA_items = [
+                [Poly.from_list([item], l, domain=domain).rep for item in row]
+                for row in A.rep.to_ddm()]
+            AA_items = [[field(item) for item in row] for row in AA_items]
+            AA = DomainMatrix(AA_items, (rows, cols), field)
+            EE_items = [
+                [eigenval if i == j else field.zero for j in range(cols)]
+                for i in range(rows)]
+            EE = DomainMatrix(EE_items, (rows, cols), field)
+
+            basis = (AA - EE).nullspace()
+            algebraic_eigenvects.append((field, minpoly, exp, basis))
+
+    return rational_eigenvects, algebraic_eigenvects
+
+
+def dom_eigenvects_to_sympy(
+    rational_eigenvects, algebraic_eigenvects,
+    Matrix, **kwargs
+):
+    result = []
+
+    for field, eigenvalue, multiplicity, eigenvects in rational_eigenvects:
+        eigenvects = eigenvects.rep.to_ddm()
+        eigenvalue = field.to_sympy(eigenvalue)
+        new_eigenvects = [
+            Matrix([field.to_sympy(x) for x in vect])
+            for vect in eigenvects]
+        result.append((eigenvalue, multiplicity, new_eigenvects))
+
+    for field, minpoly, multiplicity, eigenvects in algebraic_eigenvects:
+        eigenvects = eigenvects.rep.to_ddm()
+        l = minpoly.gens[0]
+
+        eigenvects = [[field.to_sympy(x) for x in vect] for vect in eigenvects]
+
+        degree = minpoly.degree()
+        minpoly = minpoly.as_expr()
+        eigenvals = roots(minpoly, l, **kwargs)
+        if len(eigenvals) != degree:
+            eigenvals = [CRootOf(minpoly, l, idx) for idx in range(degree)]
+
+        for eigenvalue in eigenvals:
+            new_eigenvects = [
+                Matrix([x.subs(l, eigenvalue) for x in vect])
+                for vect in eigenvects]
+            result.append((eigenvalue, multiplicity, new_eigenvects))
+
+    return result

llmeval-env/lib/python3.10/site-packages/sympy/polys/matrices/exceptions.py

@@ -0,0 +1,67 @@
+"""
+
+Module to define exceptions to be used in sympy.polys.matrices modules and
+classes.
+
+Ideally all exceptions raised in these modules would be defined and documented
+here and not e.g. imported from matrices. Also ideally generic exceptions like
+ValueError/TypeError would not be raised anywhere.
+
+"""
+
+
+class DMError(Exception):
+    """Base class for errors raised by DomainMatrix"""
+    pass
+
+
+class DMBadInputError(DMError):
+    """list of lists is inconsistent with shape"""
+    pass
+
+
+class DMDomainError(DMError):
+    """domains do not match"""
+    pass
+
+
+class DMNotAField(DMDomainError):
+    """domain is not a field"""
+    pass
+
+
+class DMFormatError(DMError):
+    """mixed dense/sparse not supported"""
+    pass
+
+
+class DMNonInvertibleMatrixError(DMError):
+    """The matrix in not invertible"""
+    pass
+
+
+class DMRankError(DMError):
+    """matrix does not have expected rank"""
+    pass
+
+
+class DMShapeError(DMError):
+    """shapes are inconsistent"""
+    pass
+
+
+class DMNonSquareMatrixError(DMShapeError):
+    """The matrix is not square"""
+    pass
+
+
+class DMValueError(DMError):
+    """The value passed is invalid"""
+    pass
+
+
+__all__ = [
+    'DMError', 'DMBadInputError', 'DMDomainError', 'DMFormatError',
+    'DMRankError', 'DMShapeError', 'DMNotAField',
+    'DMNonInvertibleMatrixError', 'DMNonSquareMatrixError', 'DMValueError'
+]

llmeval-env/lib/python3.10/site-packages/sympy/polys/matrices/linsolve.py

@@ -0,0 +1,230 @@
+#
+# sympy.polys.matrices.linsolve module
+#
+# This module defines the _linsolve function which is the internal workhorse
+# used by linsolve. This computes the solution of a system of linear equations
+# using the SDM sparse matrix implementation in sympy.polys.matrices.sdm. This
+# is a replacement for solve_lin_sys in sympy.polys.solvers which is
+# inefficient for large sparse systems due to the use of a PolyRing with many
+# generators:
+#
+#     https://github.com/sympy/sympy/issues/20857
+#
+# The implementation of _linsolve here handles:
+#
+# - Extracting the coefficients from the Expr/Eq input equations.
+# - Constructing a domain and converting the coefficients to
+#   that domain.
+# - Using the SDM.rref, SDM.nullspace etc methods to generate the full
+#   solution working with arithmetic only in the domain of the coefficients.
+#
+# The routines here are particularly designed to be efficient for large sparse
+# systems of linear equations although as well as dense systems. It is
+# possible that for some small dense systems solve_lin_sys which uses the
+# dense matrix implementation DDM will be more efficient. With smaller systems
+# though the bulk of the time is spent just preprocessing the inputs and the
+# relative time spent in rref is too small to be noticeable.
+#
+
+from collections import defaultdict
+
+from sympy.core.add import Add
+from sympy.core.mul import Mul
+from sympy.core.singleton import S
+
+from sympy.polys.constructor import construct_domain
+from sympy.polys.solvers import PolyNonlinearError
+
+from .sdm import (
+    SDM,
+    sdm_irref,
+    sdm_particular_from_rref,
+    sdm_nullspace_from_rref
+)
+
+from sympy.utilities.misc import filldedent
+
+
+def _linsolve(eqs, syms):
+
+    """Solve a linear system of equations.
+
+    Examples
+    ========
+
+    Solve a linear system with a unique solution:
+
+    >>> from sympy import symbols, Eq
+    >>> from sympy.polys.matrices.linsolve import _linsolve
+    >>> x, y = symbols('x, y')
+    >>> eqs = [Eq(x + y, 1), Eq(x - y, 2)]
+    >>> _linsolve(eqs, [x, y])
+    {x: 3/2, y: -1/2}
+
+    In the case of underdetermined systems the solution will be expressed in
+    terms of the unknown symbols that are unconstrained:
+
+    >>> _linsolve([Eq(x + y, 0)], [x, y])
+    {x: -y, y: y}
+
+    """
+    # Number of unknowns (columns in the non-augmented matrix)
+    nsyms = len(syms)
+
+    # Convert to sparse augmented matrix (len(eqs) x (nsyms+1))
+    eqsdict, const = _linear_eq_to_dict(eqs, syms)
+    Aaug = sympy_dict_to_dm(eqsdict, const, syms)
+    K = Aaug.domain
+
+    # sdm_irref has issues with float matrices. This uses the ddm_rref()
+    # function. When sdm_rref() can handle float matrices reasonably this
+    # should be removed...
+    if K.is_RealField or K.is_ComplexField:
+        Aaug = Aaug.to_ddm().rref()[0].to_sdm()
+
+    # Compute reduced-row echelon form (RREF)
+    Arref, pivots, nzcols = sdm_irref(Aaug)
+
+    # No solution:
+    if pivots and pivots[-1] == nsyms:
+        return None
+
+    # Particular solution for non-homogeneous system:
+    P = sdm_particular_from_rref(Arref, nsyms+1, pivots)
+
+    # Nullspace - general solution to homogeneous system
+    # Note: using nsyms not nsyms+1 to ignore last column
+    V, nonpivots = sdm_nullspace_from_rref(Arref, K.one, nsyms, pivots, nzcols)
+
+    # Collect together terms from particular and nullspace:
+    sol = defaultdict(list)
+    for i, v in P.items():
+        sol[syms[i]].append(K.to_sympy(v))
+    for npi, Vi in zip(nonpivots, V):
+        sym = syms[npi]
+        for i, v in Vi.items():
+            sol[syms[i]].append(sym * K.to_sympy(v))
+
+    # Use a single call to Add for each term:
+    sol = {s: Add(*terms) for s, terms in sol.items()}
+
+    # Fill in the zeros:
+    zero = S.Zero
+    for s in set(syms) - set(sol):
+        sol[s] = zero
+
+    # All done!
+    return sol
+
+
+def sympy_dict_to_dm(eqs_coeffs, eqs_rhs, syms):
+    """Convert a system of dict equations to a sparse augmented matrix"""
+    elems = set(eqs_rhs).union(*(e.values() for e in eqs_coeffs))
+    K, elems_K = construct_domain(elems, field=True, extension=True)
+    elem_map = dict(zip(elems, elems_K))
+    neqs = len(eqs_coeffs)
+    nsyms = len(syms)
+    sym2index = dict(zip(syms, range(nsyms)))
+    eqsdict = []
+    for eq, rhs in zip(eqs_coeffs, eqs_rhs):
+        eqdict = {sym2index[s]: elem_map[c] for s, c in eq.items()}
+        if rhs:
+            eqdict[nsyms] = -elem_map[rhs]
+        if eqdict:
+            eqsdict.append(eqdict)
+    sdm_aug = SDM(enumerate(eqsdict), (neqs, nsyms + 1), K)
+    return sdm_aug
+
+
+def _linear_eq_to_dict(eqs, syms):
+    """Convert a system Expr/Eq equations into dict form, returning
+    the coefficient dictionaries and a list of syms-independent terms
+    from each expression in ``eqs```.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.matrices.linsolve import _linear_eq_to_dict
+    >>> from sympy.abc import x
+    >>> _linear_eq_to_dict([2*x + 3], {x})
+    ([{x: 2}], [3])
+    """
+    coeffs = []
+    ind = []
+    symset = set(syms)
+    for i, e in enumerate(eqs):
+        if e.is_Equality:
+            coeff, terms = _lin_eq2dict(e.lhs, symset)
+            cR, tR = _lin_eq2dict(e.rhs, symset)
+            # there were no nonlinear errors so now
+            # cancellation is allowed
+            coeff -= cR
+            for k, v in tR.items():
+                if k in terms:
+                    terms[k] -= v
+                else:
+                    terms[k] = -v
+            # don't store coefficients of 0, however
+            terms = {k: v for k, v in terms.items() if v}
+            c, d = coeff, terms
+        else:
+            c, d = _lin_eq2dict(e, symset)
+        coeffs.append(d)
+        ind.append(c)
+    return coeffs, ind
+
+
+def _lin_eq2dict(a, symset):
+    """return (c, d) where c is the sym-independent part of ``a`` and
+    ``d`` is an efficiently calculated dictionary mapping symbols to
+    their coefficients. A PolyNonlinearError is raised if non-linearity
+    is detected.
+
+    The values in the dictionary will be non-zero.
+
+    Examples
+    ========
+
+    >>> from sympy.polys.matrices.linsolve import _lin_eq2dict
+    >>> from sympy.abc import x, y
+    >>> _lin_eq2dict(x + 2*y + 3, {x, y})
+    (3, {x: 1, y: 2})
+    """
+    if a in symset:
+        return S.Zero, {a: S.One}
+    elif a.is_Add:
+        terms_list = defaultdict(list)
+        coeff_list = []
+        for ai in a.args:
+            ci, ti = _lin_eq2dict(ai, symset)
+            coeff_list.append(ci)
+            for mij, cij in ti.items():
+                terms_list[mij].append(cij)
+        coeff = Add(*coeff_list)
+        terms = {sym: Add(*coeffs) for sym, coeffs in terms_list.items()}
+        return coeff, terms
+    elif a.is_Mul:
+        terms = terms_coeff = None
+        coeff_list = []
+        for ai in a.args:
+            ci, ti = _lin_eq2dict(ai, symset)
+            if not ti:
+                coeff_list.append(ci)
+            elif terms is None:
+                terms = ti
+                terms_coeff = ci
+            else:
+                # since ti is not null and we already have
+                # a term, this is a cross term
+                raise PolyNonlinearError(filldedent('''
+                    nonlinear cross-term: %s''' % a))
+        coeff = Mul._from_args(coeff_list)
+        if terms is None:
+            return coeff, {}
+        else:
+            terms = {sym: coeff * c for sym, c in terms.items()}
+            return  coeff * terms_coeff, terms
+    elif not a.has_xfree(symset):
+        return a, {}
+    else:
+        raise PolyNonlinearError('nonlinear term: %s' % a)

llmeval-env/lib/python3.10/site-packages/sympy/polys/matrices/lll.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from math import floor as mfloor
+
+from sympy.polys.domains import ZZ, QQ
+from sympy.polys.matrices.exceptions import DMRankError, DMShapeError, DMValueError, DMDomainError
+
+
+def _ddm_lll(x, delta=QQ(3, 4), return_transform=False):
+    if QQ(1, 4) >= delta or delta >= QQ(1, 1):
+        raise DMValueError("delta must lie in range (0.25, 1)")
+    if x.shape[0] > x.shape[1]:
+        raise DMShapeError("input matrix must have shape (m, n) with m <= n")
+    if x.domain != ZZ:
+        raise DMDomainError("input matrix domain must be ZZ")
+    m = x.shape[0]
+    n = x.shape[1]
+    k = 1
+    y = x.copy()
+    y_star = x.zeros((m, n), QQ)
+    mu = x.zeros((m, m), QQ)
+    g_star = [QQ(0, 1) for _ in range(m)]
+    half = QQ(1, 2)
+    T = x.eye(m, ZZ) if return_transform else None
+    linear_dependent_error = "input matrix contains linearly dependent rows"
+
+    def closest_integer(x):
+        return ZZ(mfloor(x + half))
+
+    def lovasz_condition(k: int) -> bool:
+        return g_star[k] >= ((delta - mu[k][k - 1] ** 2) * g_star[k - 1])
+
+    def mu_small(k: int, j: int) -> bool:
+        return abs(mu[k][j]) <= half
+
+    def dot_rows(x, y, rows: tuple[int, int]):
+        return sum([x[rows[0]][z] * y[rows[1]][z] for z in range(x.shape[1])])
+
+    def reduce_row(T, mu, y, rows: tuple[int, int]):
+        r = closest_integer(mu[rows[0]][rows[1]])
+        y[rows[0]] = [y[rows[0]][z] - r * y[rows[1]][z] for z in range(n)]
+        mu[rows[0]][:rows[1]] = [mu[rows[0]][z] - r * mu[rows[1]][z] for z in range(rows[1])]
+        mu[rows[0]][rows[1]] -= r
+        if return_transform:
+            T[rows[0]] = [T[rows[0]][z] - r * T[rows[1]][z] for z in range(m)]
+
+    for i in range(m):
+        y_star[i] = [QQ.convert_from(z, ZZ) for z in y[i]]
+        for j in range(i):
+            row_dot = dot_rows(y, y_star, (i, j))
+            try:
+                mu[i][j] = row_dot / g_star[j]
+            except ZeroDivisionError:
+                raise DMRankError(linear_dependent_error)
+            y_star[i] = [y_star[i][z] - mu[i][j] * y_star[j][z] for z in range(n)]
+        g_star[i] = dot_rows(y_star, y_star, (i, i))
+    while k < m:
+        if not mu_small(k, k - 1):
+            reduce_row(T, mu, y, (k, k - 1))
+        if lovasz_condition(k):
+            for l in range(k - 2, -1, -1):
+                if not mu_small(k, l):
+                    reduce_row(T, mu, y, (k, l))
+            k += 1
+        else:
+            nu = mu[k][k - 1]
+            alpha = g_star[k] + nu ** 2 * g_star[k - 1]
+            try:
+                beta = g_star[k - 1] / alpha
+            except ZeroDivisionError:
+                raise DMRankError(linear_dependent_error)
+            mu[k][k - 1] = nu * beta
+            g_star[k] = g_star[k] * beta
+            g_star[k - 1] = alpha
+            y[k], y[k - 1] = y[k - 1], y[k]
+            mu[k][:k - 1], mu[k - 1][:k - 1] = mu[k - 1][:k - 1], mu[k][:k - 1]
+            for i in range(k + 1, m):
+                xi = mu[i][k]
+                mu[i][k] = mu[i][k - 1] - nu * xi
+                mu[i][k - 1] = mu[k][k - 1] * mu[i][k] + xi
+            if return_transform:
+                T[k], T[k - 1] = T[k - 1], T[k]
+            k = max(k - 1, 1)
+    assert all([lovasz_condition(i) for i in range(1, m)])
+    assert all([mu_small(i, j) for i in range(m) for j in range(i)])
+    return y, T
+
+
+def ddm_lll(x, delta=QQ(3, 4)):
+    return _ddm_lll(x, delta=delta, return_transform=False)[0]
+
+
+def ddm_lll_transform(x, delta=QQ(3, 4)):
+    return _ddm_lll(x, delta=delta, return_transform=True)

llmeval-env/lib/python3.10/site-packages/sympy/polys/matrices/normalforms.py

@@ -0,0 +1,406 @@
+'''Functions returning normal forms of matrices'''
+
+from collections import defaultdict
+
+from .domainmatrix import DomainMatrix
+from .exceptions import DMDomainError, DMShapeError
+from sympy.ntheory.modular import symmetric_residue
+from sympy.polys.domains import QQ, ZZ
+
+
+# TODO (future work):
+#  There are faster algorithms for Smith and Hermite normal forms, which
+#  we should implement. See e.g. the Kannan-Bachem algorithm:
+#  <https://www.researchgate.net/publication/220617516_Polynomial_Algorithms_for_Computing_the_Smith_and_Hermite_Normal_Forms_of_an_Integer_Matrix>
+
+
+def smith_normal_form(m):
+    '''
+    Return the Smith Normal Form of a matrix `m` over the ring `domain`.
+    This will only work if the ring is a principal ideal domain.
+
+    Examples
+    ========
+
+    >>> from sympy import ZZ
+    >>> from sympy.polys.matrices import DomainMatrix
+    >>> from sympy.polys.matrices.normalforms import smith_normal_form
+    >>> m = DomainMatrix([[ZZ(12), ZZ(6), ZZ(4)],
+    ...                   [ZZ(3), ZZ(9), ZZ(6)],
+    ...                   [ZZ(2), ZZ(16), ZZ(14)]], (3, 3), ZZ)
+    >>> print(smith_normal_form(m).to_Matrix())
+    Matrix([[1, 0, 0], [0, 10, 0], [0, 0, -30]])
+
+    '''
+    invs = invariant_factors(m)
+    smf = DomainMatrix.diag(invs, m.domain, m.shape)
+    return smf
+
+
+def add_columns(m, i, j, a, b, c, d):
+    # replace m[:, i] by a*m[:, i] + b*m[:, j]
+    # and m[:, j] by c*m[:, i] + d*m[:, j]
+    for k in range(len(m)):
+        e = m[k][i]
+        m[k][i] = a*e + b*m[k][j]
+        m[k][j] = c*e + d*m[k][j]
+
+
+def invariant_factors(m):
+    '''
+    Return the tuple of abelian invariants for a matrix `m`
+    (as in the Smith-Normal form)
+
+    References
+    ==========
+
+    [1] https://en.wikipedia.org/wiki/Smith_normal_form#Algorithm
+    [2] https://web.archive.org/web/20200331143852/https://sierra.nmsu.edu/morandi/notes/SmithNormalForm.pdf
+
+    '''
+    domain = m.domain
+    if not domain.is_PID:
+        msg = "The matrix entries must be over a principal ideal domain"
+        raise ValueError(msg)
+
+    if 0 in m.shape:
+        return ()
+
+    rows, cols = shape = m.shape
+    m = list(m.to_dense().rep)
+
+    def add_rows(m, i, j, a, b, c, d):
+        # replace m[i, :] by a*m[i, :] + b*m[j, :]
+        # and m[j, :] by c*m[i, :] + d*m[j, :]
+        for k in range(cols):
+            e = m[i][k]
+            m[i][k] = a*e + b*m[j][k]
+            m[j][k] = c*e + d*m[j][k]
+
+    def clear_column(m):
+        # make m[1:, 0] zero by row and column operations
+        if m[0][0] == 0:
+            return m  # pragma: nocover
+        pivot = m[0][0]
+        for j in range(1, rows):
+            if m[j][0] == 0:
+                continue
+            d, r = domain.div(m[j][0], pivot)
+            if r == 0:
+                add_rows(m, 0, j, 1, 0, -d, 1)
+            else:
+                a, b, g = domain.gcdex(pivot, m[j][0])
+                d_0 = domain.div(m[j][0], g)[0]
+                d_j = domain.div(pivot, g)[0]
+                add_rows(m, 0, j, a, b, d_0, -d_j)
+                pivot = g
+        return m
+
+    def clear_row(m):
+        # make m[0, 1:] zero by row and column operations
+        if m[0][0] == 0:
+            return m  # pragma: nocover
+        pivot = m[0][0]
+        for j in range(1, cols):
+            if m[0][j] == 0:
+                continue
+            d, r = domain.div(m[0][j], pivot)
+            if r == 0:
+                add_columns(m, 0, j, 1, 0, -d, 1)
+            else:
+                a, b, g = domain.gcdex(pivot, m[0][j])
+                d_0 = domain.div(m[0][j], g)[0]
+                d_j = domain.div(pivot, g)[0]
+                add_columns(m, 0, j, a, b, d_0, -d_j)
+                pivot = g
+        return m
+
+    # permute the rows and columns until m[0,0] is non-zero if possible
+    ind = [i for i in range(rows) if m[i][0] != 0]
+    if ind and ind[0] != 0:
+        m[0], m[ind[0]] = m[ind[0]], m[0]
+    else:
+        ind = [j for j in range(cols) if m[0][j] != 0]
+        if ind and ind[0] != 0:
+            for row in m:
+                row[0], row[ind[0]] = row[ind[0]], row[0]
+
+    # make the first row and column except m[0,0] zero
+    while (any(m[0][i] != 0 for i in range(1,cols)) or
+           any(m[i][0] != 0 for i in range(1,rows))):
+        m = clear_column(m)
+        m = clear_row(m)
+
+    if 1 in shape:
+        invs = ()
+    else:
+        lower_right = DomainMatrix([r[1:] for r in m[1:]], (rows-1, cols-1), domain)
+        invs = invariant_factors(lower_right)
+
+    if m[0][0]:
+        result = [m[0][0]]
+        result.extend(invs)
+        # in case m[0] doesn't divide the invariants of the rest of the matrix
+        for i in range(len(result)-1):
+            if result[i] and domain.div(result[i+1], result[i])[1] != 0:
+                g = domain.gcd(result[i+1], result[i])
+                result[i+1] = domain.div(result[i], g)[0]*result[i+1]
+                result[i] = g
+            else:
+                break
+    else:
+        result = invs + (m[0][0],)
+    return tuple(result)
+
+
+def _gcdex(a, b):
+    r"""
+    This supports the functions that compute Hermite Normal Form.
+
+    Explanation
+    ===========
+
+    Let x, y be the coefficients returned by the extended Euclidean
+    Algorithm, so that x*a + y*b = g. In the algorithms for computing HNF,
+    it is critical that x, y not only satisfy the condition of being small
+    in magnitude -- namely that |x| <= |b|/g, |y| <- |a|/g -- but also that
+    y == 0 when a | b.
+
+    """
+    x, y, g = ZZ.gcdex(a, b)
+    if a != 0 and b % a == 0:
+        y = 0
+        x = -1 if a < 0 else 1
+    return x, y, g
+
+
+def _hermite_normal_form(A):
+    r"""
+    Compute the Hermite Normal Form of DomainMatrix *A* over :ref:`ZZ`.
+
+    Parameters
+    ==========
+
+    A : :py:class:`~.DomainMatrix` over domain :ref:`ZZ`.
+
+    Returns
+    =======
+
+    :py:class:`~.DomainMatrix`
+        The HNF of matrix *A*.
+
+    Raises
+    ======
+
+    DMDomainError
+        If the domain of the matrix is not :ref:`ZZ`.
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+       (See Algorithm 2.4.5.)
+
+    """
+    if not A.domain.is_ZZ:
+        raise DMDomainError('Matrix must be over domain ZZ.')
+    # We work one row at a time, starting from the bottom row, and working our
+    # way up.
+    m, n = A.shape
+    A = A.to_dense().rep.copy()
+    # Our goal is to put pivot entries in the rightmost columns.
+    # Invariant: Before processing each row, k should be the index of the
+    # leftmost column in which we have so far put a pivot.
+    k = n
+    for i in range(m - 1, -1, -1):
+        if k == 0:
+            # This case can arise when n < m and we've already found n pivots.
+            # We don't need to consider any more rows, because this is already
+            # the maximum possible number of pivots.
+            break
+        k -= 1
+        # k now points to the column in which we want to put a pivot.
+        # We want zeros in all entries to the left of the pivot column.
+        for j in range(k - 1, -1, -1):
+            if A[i][j] != 0:
+                # Replace cols j, k by lin combs of these cols such that, in row i,
+                # col j has 0, while col k has the gcd of their row i entries. Note
+                # that this ensures a nonzero entry in col k.
+                u, v, d = _gcdex(A[i][k], A[i][j])
+                r, s = A[i][k] // d, A[i][j] // d
+                add_columns(A, k, j, u, v, -s, r)
+        b = A[i][k]
+        # Do not want the pivot entry to be negative.
+        if b < 0:
+            add_columns(A, k, k, -1, 0, -1, 0)
+            b = -b
+        # The pivot entry will be 0 iff the row was 0 from the pivot col all the
+        # way to the left. In this case, we are still working on the same pivot
+        # col for the next row. Therefore:
+        if b == 0:
+            k += 1
+        # If the pivot entry is nonzero, then we want to reduce all entries to its
+        # right in the sense of the division algorithm, i.e. make them all remainders
+        # w.r.t. the pivot as divisor.
+        else:
+            for j in range(k + 1, n):
+                q = A[i][j] // b
+                add_columns(A, j, k, 1, -q, 0, 1)
+    # Finally, the HNF consists of those columns of A in which we succeeded in making
+    # a nonzero pivot.
+    return DomainMatrix.from_rep(A)[:, k:]
+
+
+def _hermite_normal_form_modulo_D(A, D):
+    r"""
+    Perform the mod *D* Hermite Normal Form reduction algorithm on
+    :py:class:`~.DomainMatrix` *A*.
+
+    Explanation
+    ===========
+
+    If *A* is an $m \times n$ matrix of rank $m$, having Hermite Normal Form
+    $W$, and if *D* is any positive integer known in advance to be a multiple
+    of $\det(W)$, then the HNF of *A* can be computed by an algorithm that
+    works mod *D* in order to prevent coefficient explosion.
+
+    Parameters
+    ==========
+
+    A : :py:class:`~.DomainMatrix` over :ref:`ZZ`
+        $m \times n$ matrix, having rank $m$.
+    D : :ref:`ZZ`
+        Positive integer, known to be a multiple of the determinant of the
+        HNF of *A*.
+
+    Returns
+    =======
+
+    :py:class:`~.DomainMatrix`
+        The HNF of matrix *A*.
+
+    Raises
+    ======
+
+    DMDomainError
+        If the domain of the matrix is not :ref:`ZZ`, or
+        if *D* is given but is not in :ref:`ZZ`.
+
+    DMShapeError
+        If the matrix has more rows than columns.
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+       (See Algorithm 2.4.8.)
+
+    """
+    if not A.domain.is_ZZ:
+        raise DMDomainError('Matrix must be over domain ZZ.')
+    if not ZZ.of_type(D) or D < 1:
+        raise DMDomainError('Modulus D must be positive element of domain ZZ.')
+
+    def add_columns_mod_R(m, R, i, j, a, b, c, d):
+        # replace m[:, i] by (a*m[:, i] + b*m[:, j]) % R
+        # and m[:, j] by (c*m[:, i] + d*m[:, j]) % R
+        for k in range(len(m)):
+            e = m[k][i]
+            m[k][i] = symmetric_residue((a * e + b * m[k][j]) % R, R)
+            m[k][j] = symmetric_residue((c * e + d * m[k][j]) % R, R)
+
+    W = defaultdict(dict)
+
+    m, n = A.shape
+    if n < m:
+        raise DMShapeError('Matrix must have at least as many columns as rows.')
+    A = A.to_dense().rep.copy()
+    k = n
+    R = D
+    for i in range(m - 1, -1, -1):
+        k -= 1
+        for j in range(k - 1, -1, -1):
+            if A[i][j] != 0:
+                u, v, d = _gcdex(A[i][k], A[i][j])
+                r, s = A[i][k] // d, A[i][j] // d
+                add_columns_mod_R(A, R, k, j, u, v, -s, r)
+        b = A[i][k]
+        if b == 0:
+            A[i][k] = b = R
+        u, v, d = _gcdex(b, R)
+        for ii in range(m):
+            W[ii][i] = u*A[ii][k] % R
+        if W[i][i] == 0:
+            W[i][i] = R
+        for j in range(i + 1, m):
+            q = W[i][j] // W[i][i]
+            add_columns(W, j, i, 1, -q, 0, 1)
+        R //= d
+    return DomainMatrix(W, (m, m), ZZ).to_dense()
+
+
+def hermite_normal_form(A, *, D=None, check_rank=False):
+    r"""
+    Compute the Hermite Normal Form of :py:class:`~.DomainMatrix` *A* over
+    :ref:`ZZ`.
+
+    Examples
+    ========
+
+    >>> from sympy import ZZ
+    >>> from sympy.polys.matrices import DomainMatrix
+    >>> from sympy.polys.matrices.normalforms import hermite_normal_form
+    >>> m = DomainMatrix([[ZZ(12), ZZ(6), ZZ(4)],
+    ...                   [ZZ(3), ZZ(9), ZZ(6)],
+    ...                   [ZZ(2), ZZ(16), ZZ(14)]], (3, 3), ZZ)
+    >>> print(hermite_normal_form(m).to_Matrix())
+    Matrix([[10, 0, 2], [0, 15, 3], [0, 0, 2]])
+
+    Parameters
+    ==========
+
+    A : $m \times n$ ``DomainMatrix`` over :ref:`ZZ`.
+
+    D : :ref:`ZZ`, optional
+        Let $W$ be the HNF of *A*. If known in advance, a positive integer *D*
+        being any multiple of $\det(W)$ may be provided. In this case, if *A*
+        also has rank $m$, then we may use an alternative algorithm that works
+        mod *D* in order to prevent coefficient explosion.
+
+    check_rank : boolean, optional (default=False)
+        The basic assumption is that, if you pass a value for *D*, then
+        you already believe that *A* has rank $m$, so we do not waste time
+        checking it for you. If you do want this to be checked (and the
+        ordinary, non-modulo *D* algorithm to be used if the check fails), then
+        set *check_rank* to ``True``.
+
+    Returns
+    =======
+
+    :py:class:`~.DomainMatrix`
+        The HNF of matrix *A*.
+
+    Raises
+    ======
+
+    DMDomainError
+        If the domain of the matrix is not :ref:`ZZ`, or
+        if *D* is given but is not in :ref:`ZZ`.
+
+    DMShapeError
+        If the mod *D* algorithm is used but the matrix has more rows than
+        columns.
+
+    References
+    ==========
+
+    .. [1] Cohen, H. *A Course in Computational Algebraic Number Theory.*
+       (See Algorithms 2.4.5 and 2.4.8.)
+
+    """
+    if not A.domain.is_ZZ:
+        raise DMDomainError('Matrix must be over domain ZZ.')
+    if D is not None and (not check_rank or A.convert_to(QQ).rank() == A.shape[0]):
+        return _hermite_normal_form_modulo_D(A, D)
+    else:
+        return _hermite_normal_form(A)

llmeval-env/lib/python3.10/site-packages/sympy/polys/matrices/sdm.py

@@ -0,0 +1,1241 @@
+"""
+
+Module for the SDM class.
+
+"""
+
+from operator import add, neg, pos, sub, mul
+from collections import defaultdict
+
+from sympy.utilities.iterables import _strongly_connected_components
+
+from .exceptions import DMBadInputError, DMDomainError, DMShapeError
+
+from .ddm import DDM
+from .lll import ddm_lll, ddm_lll_transform
+from sympy.polys.domains import QQ
+
+
+class SDM(dict):
+    r"""Sparse matrix based on polys domain elements
+
+    This is a dict subclass and is a wrapper for a dict of dicts that supports
+    basic matrix arithmetic +, -, *, **.
+
+
+    In order to create a new :py:class:`~.SDM`, a dict
+    of dicts mapping non-zero elements to their
+    corresponding row and column in the matrix is needed.
+
+    We also need to specify the shape and :py:class:`~.Domain`
+    of our :py:class:`~.SDM` object.
+
+    We declare a 2x2 :py:class:`~.SDM` matrix belonging
+    to QQ domain as shown below.
+    The 2x2 Matrix in the example is
+
+    .. math::
+           A = \left[\begin{array}{ccc}
+                0 & \frac{1}{2} \\
+                0 & 0 \end{array} \right]
+
+
+    >>> from sympy.polys.matrices.sdm import SDM
+    >>> from sympy import QQ
+    >>> elemsdict = {0:{1:QQ(1, 2)}}
+    >>> A = SDM(elemsdict, (2, 2), QQ)
+    >>> A
+    {0: {1: 1/2}}
+
+    We can manipulate :py:class:`~.SDM` the same way
+    as a Matrix class
+
+    >>> from sympy import ZZ
+    >>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
+    >>> B  = SDM({0:{0: ZZ(3)}, 1:{1:ZZ(4)}}, (2, 2), ZZ)
+    >>> A + B
+    {0: {0: 3, 1: 2}, 1: {0: 1, 1: 4}}
+
+    Multiplication
+
+    >>> A*B
+    {0: {1: 8}, 1: {0: 3}}
+    >>> A*ZZ(2)
+    {0: {1: 4}, 1: {0: 2}}
+
+    """
+
+    fmt = 'sparse'
+
+    def __init__(self, elemsdict, shape, domain):
+        super().__init__(elemsdict)
+        self.shape = self.rows, self.cols = m, n = shape
+        self.domain = domain
+
+        if not all(0 <= r < m for r in self):
+            raise DMBadInputError("Row out of range")
+        if not all(0 <= c < n for row in self.values() for c in row):
+            raise DMBadInputError("Column out of range")
+
+    def getitem(self, i, j):
+        try:
+            return self[i][j]
+        except KeyError:
+            m, n = self.shape
+            if -m <= i < m and -n <= j < n:
+                try:
+                    return self[i % m][j % n]
+                except KeyError:
+                    return self.domain.zero
+            else:
+                raise IndexError("index out of range")
+
+    def setitem(self, i, j, value):
+        m, n = self.shape
+        if not (-m <= i < m and -n <= j < n):
+            raise IndexError("index out of range")
+        i, j = i % m, j % n
+        if value:
+            try:
+                self[i][j] = value
+            except KeyError:
+                self[i] = {j: value}
+        else:
+            rowi = self.get(i, None)
+            if rowi is not None:
+                try:
+                    del rowi[j]
+                except KeyError:
+                    pass
+                else:
+                    if not rowi:
+                        del self[i]
+
+    def extract_slice(self, slice1, slice2):
+        m, n = self.shape
+        ri = range(m)[slice1]
+        ci = range(n)[slice2]
+
+        sdm = {}
+        for i, row in self.items():
+            if i in ri:
+                row = {ci.index(j): e for j, e in row.items() if j in ci}
+                if row:
+                    sdm[ri.index(i)] = row
+
+        return self.new(sdm, (len(ri), len(ci)), self.domain)
+
+    def extract(self, rows, cols):
+        if not (self and rows and cols):
+            return self.zeros((len(rows), len(cols)), self.domain)
+
+        m, n = self.shape
+        if not (-m <= min(rows) <= max(rows) < m):
+            raise IndexError('Row index out of range')
+        if not (-n <= min(cols) <= max(cols) < n):
+            raise IndexError('Column index out of range')
+
+        # rows and cols can contain duplicates e.g. M[[1, 2, 2], [0, 1]]
+        # Build a map from row/col in self to list of rows/cols in output
+        rowmap = defaultdict(list)
+        colmap = defaultdict(list)
+        for i2, i1 in enumerate(rows):
+            rowmap[i1 % m].append(i2)
+        for j2, j1 in enumerate(cols):
+            colmap[j1 % n].append(j2)
+
+        # Used to efficiently skip zero rows/cols
+        rowset = set(rowmap)
+        colset = set(colmap)
+
+        sdm1 = self
+        sdm2 = {}
+        for i1 in rowset & set(sdm1):
+            row1 = sdm1[i1]
+            row2 = {}
+            for j1 in colset & set(row1):
+                row1_j1 = row1[j1]
+                for j2 in colmap[j1]:
+                    row2[j2] = row1_j1
+            if row2:
+                for i2 in rowmap[i1]:
+                    sdm2[i2] = row2.copy()
+
+        return self.new(sdm2, (len(rows), len(cols)), self.domain)
+
+    def __str__(self):
+        rowsstr = []
+        for i, row in self.items():
+            elemsstr = ', '.join('%s: %s' % (j, elem) for j, elem in row.items())
+            rowsstr.append('%s: {%s}' % (i, elemsstr))
+        return '{%s}' % ', '.join(rowsstr)
+
+    def __repr__(self):
+        cls = type(self).__name__
+        rows = dict.__repr__(self)
+        return '%s(%s, %s, %s)' % (cls, rows, self.shape, self.domain)
+
+    @classmethod
+    def new(cls, sdm, shape, domain):
+        """
+
+        Parameters
+        ==========
+
+        sdm: A dict of dicts for non-zero elements in SDM
+        shape: tuple representing dimension of SDM
+        domain: Represents :py:class:`~.Domain` of SDM
+
+        Returns
+        =======
+
+        An :py:class:`~.SDM` object
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> elemsdict = {0:{1: QQ(2)}}
+        >>> A = SDM.new(elemsdict, (2, 2), QQ)
+        >>> A
+        {0: {1: 2}}
+
+        """
+        return cls(sdm, shape, domain)
+
+    def copy(A):
+        """
+        Returns the copy of a :py:class:`~.SDM` object
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> elemsdict = {0:{1:QQ(2)}, 1:{}}
+        >>> A = SDM(elemsdict, (2, 2), QQ)
+        >>> B = A.copy()
+        >>> B
+        {0: {1: 2}, 1: {}}
+
+        """
+        Ac = {i: Ai.copy() for i, Ai in A.items()}
+        return A.new(Ac, A.shape, A.domain)
+
+    @classmethod
+    def from_list(cls, ddm, shape, domain):
+        """
+
+        Parameters
+        ==========
+
+        ddm:
+            list of lists containing domain elements
+        shape:
+            Dimensions of :py:class:`~.SDM` matrix
+        domain:
+            Represents :py:class:`~.Domain` of :py:class:`~.SDM` object
+
+        Returns
+        =======
+
+        :py:class:`~.SDM` containing elements of ddm
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> ddm = [[QQ(1, 2), QQ(0)], [QQ(0), QQ(3, 4)]]
+        >>> A = SDM.from_list(ddm, (2, 2), QQ)
+        >>> A
+        {0: {0: 1/2}, 1: {1: 3/4}}
+
+        """
+
+        m, n = shape
+        if not (len(ddm) == m and all(len(row) == n for row in ddm)):
+            raise DMBadInputError("Inconsistent row-list/shape")
+        getrow = lambda i: {j:ddm[i][j] for j in range(n) if ddm[i][j]}
+        irows = ((i, getrow(i)) for i in range(m))
+        sdm = {i: row for i, row in irows if row}
+        return cls(sdm, shape, domain)
+
+    @classmethod
+    def from_ddm(cls, ddm):
+        """
+        converts object of :py:class:`~.DDM` to
+        :py:class:`~.SDM`
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.ddm import DDM
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> ddm = DDM( [[QQ(1, 2), 0], [0, QQ(3, 4)]], (2, 2), QQ)
+        >>> A = SDM.from_ddm(ddm)
+        >>> A
+        {0: {0: 1/2}, 1: {1: 3/4}}
+
+        """
+        return cls.from_list(ddm, ddm.shape, ddm.domain)
+
+    def to_list(M):
+        """
+
+        Converts a :py:class:`~.SDM` object to a list
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> elemsdict = {0:{1:QQ(2)}, 1:{}}
+        >>> A = SDM(elemsdict, (2, 2), QQ)
+        >>> A.to_list()
+        [[0, 2], [0, 0]]
+
+        """
+        m, n = M.shape
+        zero = M.domain.zero
+        ddm = [[zero] * n for _ in range(m)]
+        for i, row in M.items():
+            for j, e in row.items():
+                ddm[i][j] = e
+        return ddm
+
+    def to_list_flat(M):
+        m, n = M.shape
+        zero = M.domain.zero
+        flat = [zero] * (m * n)
+        for i, row in M.items():
+            for j, e in row.items():
+                flat[i*n + j] = e
+        return flat
+
+    def to_dok(M):
+        return {(i, j): e for i, row in M.items() for j, e in row.items()}
+
+    def to_ddm(M):
+        """
+        Convert a :py:class:`~.SDM` object to a :py:class:`~.DDM` object
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> A = SDM({0:{1:QQ(2)}, 1:{}}, (2, 2), QQ)
+        >>> A.to_ddm()
+        [[0, 2], [0, 0]]
+
+        """
+        return DDM(M.to_list(), M.shape, M.domain)
+
+    def to_sdm(M):
+        return M
+
+    @classmethod
+    def zeros(cls, shape, domain):
+        r"""
+
+        Returns a :py:class:`~.SDM` of size shape,
+        belonging to the specified domain
+
+        In the example below we declare a matrix A where,
+
+        .. math::
+            A := \left[\begin{array}{ccc}
+            0 & 0 & 0 \\
+            0 & 0 & 0 \end{array} \right]
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> A = SDM.zeros((2, 3), QQ)
+        >>> A
+        {}
+
+        """
+        return cls({}, shape, domain)
+
+    @classmethod
+    def ones(cls, shape, domain):
+        one = domain.one
+        m, n = shape
+        row = dict(zip(range(n), [one]*n))
+        sdm = {i: row.copy() for i in range(m)}
+        return cls(sdm, shape, domain)
+
+    @classmethod
+    def eye(cls, shape, domain):
+        """
+
+        Returns a identity :py:class:`~.SDM` matrix of dimensions
+        size x size, belonging to the specified domain
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> I = SDM.eye((2, 2), QQ)
+        >>> I
+        {0: {0: 1}, 1: {1: 1}}
+
+        """
+        rows, cols = shape
+        one = domain.one
+        sdm = {i: {i: one} for i in range(min(rows, cols))}
+        return cls(sdm, shape, domain)
+
+    @classmethod
+    def diag(cls, diagonal, domain, shape):
+        sdm = {i: {i: v} for i, v in enumerate(diagonal) if v}
+        return cls(sdm, shape, domain)
+
+    def transpose(M):
+        """
+
+        Returns the transpose of a :py:class:`~.SDM` matrix
+
+        Examples
+        ========
+
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy import QQ
+        >>> A = SDM({0:{1:QQ(2)}, 1:{}}, (2, 2), QQ)
+        >>> A.transpose()
+        {1: {0: 2}}
+
+        """
+        MT = sdm_transpose(M)
+        return M.new(MT, M.shape[::-1], M.domain)
+
+    def __add__(A, B):
+        if not isinstance(B, SDM):
+            return NotImplemented
+        return A.add(B)
+
+    def __sub__(A, B):
+        if not isinstance(B, SDM):
+            return NotImplemented
+        return A.sub(B)
+
+    def __neg__(A):
+        return A.neg()
+
+    def __mul__(A, B):
+        """A * B"""
+        if isinstance(B, SDM):
+            return A.matmul(B)
+        elif B in A.domain:
+            return A.mul(B)
+        else:
+            return NotImplemented
+
+    def __rmul__(a, b):
+        if b in a.domain:
+            return a.rmul(b)
+        else:
+            return NotImplemented
+
+    def matmul(A, B):
+        """
+        Performs matrix multiplication of two SDM matrices
+
+        Parameters
+        ==========
+
+        A, B: SDM to multiply
+
+        Returns
+        =======
+
+        SDM
+            SDM after multiplication
+
+        Raises
+        ======
+
+        DomainError
+            If domain of A does not match
+            with that of B
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
+        >>> B = SDM({0:{0:ZZ(2), 1:ZZ(3)}, 1:{0:ZZ(4)}}, (2, 2), ZZ)
+        >>> A.matmul(B)
+        {0: {0: 8}, 1: {0: 2, 1: 3}}
+
+        """
+        if A.domain != B.domain:
+            raise DMDomainError
+        m, n = A.shape
+        n2, o = B.shape
+        if n != n2:
+            raise DMShapeError
+        C = sdm_matmul(A, B, A.domain, m, o)
+        return A.new(C, (m, o), A.domain)
+
+    def mul(A, b):
+        """
+        Multiplies each element of A with a scalar b
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
+        >>> A.mul(ZZ(3))
+        {0: {1: 6}, 1: {0: 3}}
+
+        """
+        Csdm = unop_dict(A, lambda aij: aij*b)
+        return A.new(Csdm, A.shape, A.domain)
+
+    def rmul(A, b):
+        Csdm = unop_dict(A, lambda aij: b*aij)
+        return A.new(Csdm, A.shape, A.domain)
+
+    def mul_elementwise(A, B):
+        if A.domain != B.domain:
+            raise DMDomainError
+        if A.shape != B.shape:
+            raise DMShapeError
+        zero = A.domain.zero
+        fzero = lambda e: zero
+        Csdm = binop_dict(A, B, mul, fzero, fzero)
+        return A.new(Csdm, A.shape, A.domain)
+
+    def add(A, B):
+        """
+
+        Adds two :py:class:`~.SDM` matrices
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
+        >>> B = SDM({0:{0: ZZ(3)}, 1:{1:ZZ(4)}}, (2, 2), ZZ)
+        >>> A.add(B)
+        {0: {0: 3, 1: 2}, 1: {0: 1, 1: 4}}
+
+        """
+
+        Csdm = binop_dict(A, B, add, pos, pos)
+        return A.new(Csdm, A.shape, A.domain)
+
+    def sub(A, B):
+        """
+
+        Subtracts two :py:class:`~.SDM` matrices
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
+        >>> B  = SDM({0:{0: ZZ(3)}, 1:{1:ZZ(4)}}, (2, 2), ZZ)
+        >>> A.sub(B)
+        {0: {0: -3, 1: 2}, 1: {0: 1, 1: -4}}
+
+        """
+        Csdm = binop_dict(A, B, sub, pos, neg)
+        return A.new(Csdm, A.shape, A.domain)
+
+    def neg(A):
+        """
+
+        Returns the negative of a :py:class:`~.SDM` matrix
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
+        >>> A.neg()
+        {0: {1: -2}, 1: {0: -1}}
+
+        """
+        Csdm = unop_dict(A, neg)
+        return A.new(Csdm, A.shape, A.domain)
+
+    def convert_to(A, K):
+        """
+
+        Converts the :py:class:`~.Domain` of a :py:class:`~.SDM` matrix to K
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ, QQ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{1: ZZ(2)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
+        >>> A.convert_to(QQ)
+        {0: {1: 2}, 1: {0: 1}}
+
+        """
+        Kold = A.domain
+        if K == Kold:
+            return A.copy()
+        Ak = unop_dict(A, lambda e: K.convert_from(e, Kold))
+        return A.new(Ak, A.shape, K)
+
+    def scc(A):
+        """Strongly connected components of a square matrix *A*.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{0: ZZ(2)}, 1:{1:ZZ(1)}}, (2, 2), ZZ)
+        >>> A.scc()
+        [[0], [1]]
+
+        See also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.scc
+        """
+        rows, cols = A.shape
+        assert rows == cols
+        V = range(rows)
+        Emap = {v: list(A.get(v, [])) for v in V}
+        return _strongly_connected_components(V, Emap)
+
+    def rref(A):
+        """
+
+        Returns reduced-row echelon form and list of pivots for the :py:class:`~.SDM`
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(2), 1:QQ(4)}}, (2, 2), QQ)
+        >>> A.rref()
+        ({0: {0: 1, 1: 2}}, [0])
+
+        """
+        B, pivots, _ = sdm_irref(A)
+        return A.new(B, A.shape, A.domain), pivots
+
+    def inv(A):
+        """
+
+        Returns inverse of a matrix A
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+        >>> A.inv()
+        {0: {0: -2, 1: 1}, 1: {0: 3/2, 1: -1/2}}
+
+        """
+        return A.from_ddm(A.to_ddm().inv())
+
+    def det(A):
+        """
+        Returns determinant of A
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+        >>> A.det()
+        -2
+
+        """
+        return A.to_ddm().det()
+
+    def lu(A):
+        """
+
+        Returns LU decomposition for a matrix A
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+        >>> A.lu()
+        ({0: {0: 1}, 1: {0: 3, 1: 1}}, {0: {0: 1, 1: 2}, 1: {1: -2}}, [])
+
+        """
+        L, U, swaps = A.to_ddm().lu()
+        return A.from_ddm(L), A.from_ddm(U), swaps
+
+    def lu_solve(A, b):
+        """
+
+        Uses LU decomposition to solve Ax = b,
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+        >>> b = SDM({0:{0:QQ(1)}, 1:{0:QQ(2)}}, (2, 1), QQ)
+        >>> A.lu_solve(b)
+        {1: {0: 1/2}}
+
+        """
+        return A.from_ddm(A.to_ddm().lu_solve(b.to_ddm()))
+
+    def nullspace(A):
+        """
+
+        Returns nullspace for a :py:class:`~.SDM` matrix A
+
+        Examples
+        ========
+
+        >>> from sympy import QQ
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0: QQ(2), 1: QQ(4)}}, (2, 2), QQ)
+        >>> A.nullspace()
+        ({0: {0: -2, 1: 1}}, [1])
+
+        """
+        ncols = A.shape[1]
+        one = A.domain.one
+        B, pivots, nzcols = sdm_irref(A)
+        K, nonpivots = sdm_nullspace_from_rref(B, one, ncols, pivots, nzcols)
+        K = dict(enumerate(K))
+        shape = (len(K), ncols)
+        return A.new(K, shape, A.domain), nonpivots
+
+    def particular(A):
+        ncols = A.shape[1]
+        B, pivots, nzcols = sdm_irref(A)
+        P = sdm_particular_from_rref(B, ncols, pivots)
+        rep = {0:P} if P else {}
+        return A.new(rep, (1, ncols-1), A.domain)
+
+    def hstack(A, *B):
+        """Horizontally stacks :py:class:`~.SDM` matrices.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices.sdm import SDM
+
+        >>> A = SDM({0: {0: ZZ(1), 1: ZZ(2)}, 1: {0: ZZ(3), 1: ZZ(4)}}, (2, 2), ZZ)
+        >>> B = SDM({0: {0: ZZ(5), 1: ZZ(6)}, 1: {0: ZZ(7), 1: ZZ(8)}}, (2, 2), ZZ)
+        >>> A.hstack(B)
+        {0: {0: 1, 1: 2, 2: 5, 3: 6}, 1: {0: 3, 1: 4, 2: 7, 3: 8}}
+
+        >>> C = SDM({0: {0: ZZ(9), 1: ZZ(10)}, 1: {0: ZZ(11), 1: ZZ(12)}}, (2, 2), ZZ)
+        >>> A.hstack(B, C)
+        {0: {0: 1, 1: 2, 2: 5, 3: 6, 4: 9, 5: 10}, 1: {0: 3, 1: 4, 2: 7, 3: 8, 4: 11, 5: 12}}
+        """
+        Anew = dict(A.copy())
+        rows, cols = A.shape
+        domain = A.domain
+
+        for Bk in B:
+            Bkrows, Bkcols = Bk.shape
+            assert Bkrows == rows
+            assert Bk.domain == domain
+
+            for i, Bki in Bk.items():
+                Ai = Anew.get(i, None)
+                if Ai is None:
+                    Anew[i] = Ai = {}
+                for j, Bkij in Bki.items():
+                    Ai[j + cols] = Bkij
+            cols += Bkcols
+
+        return A.new(Anew, (rows, cols), A.domain)
+
+    def vstack(A, *B):
+        """Vertically stacks :py:class:`~.SDM` matrices.
+
+        Examples
+        ========
+
+        >>> from sympy import ZZ
+        >>> from sympy.polys.matrices.sdm import SDM
+
+        >>> A = SDM({0: {0: ZZ(1), 1: ZZ(2)}, 1: {0: ZZ(3), 1: ZZ(4)}}, (2, 2), ZZ)
+        >>> B = SDM({0: {0: ZZ(5), 1: ZZ(6)}, 1: {0: ZZ(7), 1: ZZ(8)}}, (2, 2), ZZ)
+        >>> A.vstack(B)
+        {0: {0: 1, 1: 2}, 1: {0: 3, 1: 4}, 2: {0: 5, 1: 6}, 3: {0: 7, 1: 8}}
+
+        >>> C = SDM({0: {0: ZZ(9), 1: ZZ(10)}, 1: {0: ZZ(11), 1: ZZ(12)}}, (2, 2), ZZ)
+        >>> A.vstack(B, C)
+        {0: {0: 1, 1: 2}, 1: {0: 3, 1: 4}, 2: {0: 5, 1: 6}, 3: {0: 7, 1: 8}, 4: {0: 9, 1: 10}, 5: {0: 11, 1: 12}}
+        """
+        Anew = dict(A.copy())
+        rows, cols = A.shape
+        domain = A.domain
+
+        for Bk in B:
+            Bkrows, Bkcols = Bk.shape
+            assert Bkcols == cols
+            assert Bk.domain == domain
+
+            for i, Bki in Bk.items():
+                Anew[i + rows] = Bki
+            rows += Bkrows
+
+        return A.new(Anew, (rows, cols), A.domain)
+
+    def applyfunc(self, func, domain):
+        sdm = {i: {j: func(e) for j, e in row.items()} for i, row in self.items()}
+        return self.new(sdm, self.shape, domain)
+
+    def charpoly(A):
+        """
+        Returns the coefficients of the characteristic polynomial
+        of the :py:class:`~.SDM` matrix. These elements will be domain elements.
+        The domain of the elements will be same as domain of the :py:class:`~.SDM`.
+
+        Examples
+        ========
+
+        >>> from sympy import QQ, Symbol
+        >>> from sympy.polys.matrices.sdm import SDM
+        >>> from sympy.polys import Poly
+        >>> A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+        >>> A.charpoly()
+        [1, -5, -2]
+
+        We can create a polynomial using the
+        coefficients using :py:class:`~.Poly`
+
+        >>> x = Symbol('x')
+        >>> p = Poly(A.charpoly(), x, domain=A.domain)
+        >>> p
+        Poly(x**2 - 5*x - 2, x, domain='QQ')
+
+        """
+        return A.to_ddm().charpoly()
+
+    def is_zero_matrix(self):
+        """
+        Says whether this matrix has all zero entries.
+        """
+        return not self
+
+    def is_upper(self):
+        """
+        Says whether this matrix is upper-triangular. True can be returned
+        even if the matrix is not square.
+        """
+        return all(i <= j for i, row in self.items() for j in row)
+
+    def is_lower(self):
+        """
+        Says whether this matrix is lower-triangular. True can be returned
+        even if the matrix is not square.
+        """
+        return all(i >= j for i, row in self.items() for j in row)
+
+    def lll(A, delta=QQ(3, 4)):
+        return A.from_ddm(ddm_lll(A.to_ddm(), delta=delta))
+
+    def lll_transform(A, delta=QQ(3, 4)):
+        reduced, transform = ddm_lll_transform(A.to_ddm(), delta=delta)
+        return A.from_ddm(reduced), A.from_ddm(transform)
+
+
+def binop_dict(A, B, fab, fa, fb):
+    Anz, Bnz = set(A), set(B)
+    C = {}
+
+    for i in Anz & Bnz:
+        Ai, Bi = A[i], B[i]
+        Ci = {}
+        Anzi, Bnzi = set(Ai), set(Bi)
+        for j in Anzi & Bnzi:
+            Cij = fab(Ai[j], Bi[j])
+            if Cij:
+                Ci[j] = Cij
+        for j in Anzi - Bnzi:
+            Cij = fa(Ai[j])
+            if Cij:
+                Ci[j] = Cij
+        for j in Bnzi - Anzi:
+            Cij = fb(Bi[j])
+            if Cij:
+                Ci[j] = Cij
+        if Ci:
+            C[i] = Ci
+
+    for i in Anz - Bnz:
+        Ai = A[i]
+        Ci = {}
+        for j, Aij in Ai.items():
+            Cij = fa(Aij)
+            if Cij:
+                Ci[j] = Cij
+        if Ci:
+            C[i] = Ci
+
+    for i in Bnz - Anz:
+        Bi = B[i]
+        Ci = {}
+        for j, Bij in Bi.items():
+            Cij = fb(Bij)
+            if Cij:
+                Ci[j] = Cij
+        if Ci:
+            C[i] = Ci
+
+    return C
+
+
+def unop_dict(A, f):
+    B = {}
+    for i, Ai in A.items():
+        Bi = {}
+        for j, Aij in Ai.items():
+            Bij = f(Aij)
+            if Bij:
+                Bi[j] = Bij
+        if Bi:
+            B[i] = Bi
+    return B
+
+
+def sdm_transpose(M):
+    MT = {}
+    for i, Mi in M.items():
+        for j, Mij in Mi.items():
+            try:
+                MT[j][i] = Mij
+            except KeyError:
+                MT[j] = {i: Mij}
+    return MT
+
+
+def sdm_matmul(A, B, K, m, o):
+    #
+    # Should be fast if A and B are very sparse.
+    # Consider e.g. A = B = eye(1000).
+    #
+    # The idea here is that we compute C = A*B in terms of the rows of C and
+    # B since the dict of dicts representation naturally stores the matrix as
+    # rows. The ith row of C (Ci) is equal to the sum of Aik * Bk where Bk is
+    # the kth row of B. The algorithm below loops over each nonzero element
+    # Aik of A and if the corresponding row Bj is nonzero then we do
+    #    Ci += Aik * Bk.
+    # To make this more efficient we don't need to loop over all elements Aik.
+    # Instead for each row Ai we compute the intersection of the nonzero
+    # columns in Ai with the nonzero rows in B. That gives the k such that
+    # Aik and Bk are both nonzero. In Python the intersection of two sets
+    # of int can be computed very efficiently.
+    #
+    if K.is_EXRAW:
+        return sdm_matmul_exraw(A, B, K, m, o)
+
+    C = {}
+    B_knz = set(B)
+    for i, Ai in A.items():
+        Ci = {}
+        Ai_knz = set(Ai)
+        for k in Ai_knz & B_knz:
+            Aik = Ai[k]
+            for j, Bkj in B[k].items():
+                Cij = Ci.get(j, None)
+                if Cij is not None:
+                    Cij = Cij + Aik * Bkj
+                    if Cij:
+                        Ci[j] = Cij
+                    else:
+                        Ci.pop(j)
+                else:
+                    Cij = Aik * Bkj
+                    if Cij:
+                        Ci[j] = Cij
+        if Ci:
+            C[i] = Ci
+    return C
+
+
+def sdm_matmul_exraw(A, B, K, m, o):
+    #
+    # Like sdm_matmul above except that:
+    #
+    # - Handles cases like 0*oo -> nan (sdm_matmul skips multipication by zero)
+    # - Uses K.sum (Add(*items)) for efficient addition of Expr
+    #
+    zero = K.zero
+    C = {}
+    B_knz = set(B)
+    for i, Ai in A.items():
+        Ci_list = defaultdict(list)
+        Ai_knz = set(Ai)
+
+        # Nonzero row/column pair
+        for k in Ai_knz & B_knz:
+            Aik = Ai[k]
+            if zero * Aik == zero:
+                # This is the main inner loop:
+                for j, Bkj in B[k].items():
+                    Ci_list[j].append(Aik * Bkj)
+            else:
+                for j in range(o):
+                    Ci_list[j].append(Aik * B[k].get(j, zero))
+
+        # Zero row in B, check for infinities in A
+        for k in Ai_knz - B_knz:
+            zAik = zero * Ai[k]
+            if zAik != zero:
+                for j in range(o):
+                    Ci_list[j].append(zAik)
+
+        # Add terms using K.sum (Add(*terms)) for efficiency
+        Ci = {}
+        for j, Cij_list in Ci_list.items():
+            Cij = K.sum(Cij_list)
+            if Cij:
+                Ci[j] = Cij
+        if Ci:
+            C[i] = Ci
+
+    # Find all infinities in B
+    for k, Bk in B.items():
+        for j, Bkj in Bk.items():
+            if zero * Bkj != zero:
+                for i in range(m):
+                    Aik = A.get(i, {}).get(k, zero)
+                    # If Aik is not zero then this was handled above
+                    if Aik == zero:
+                        Ci = C.get(i, {})
+                        Cij = Ci.get(j, zero) + Aik * Bkj
+                        if Cij != zero:
+                            Ci[j] = Cij
+                        else:  # pragma: no cover
+                            # Not sure how we could get here but let's raise an
+                            # exception just in case.
+                            raise RuntimeError
+                        C[i] = Ci
+
+    return C
+
+
+def sdm_irref(A):
+    """RREF and pivots of a sparse matrix *A*.
+
+    Compute the reduced row echelon form (RREF) of the matrix *A* and return a
+    list of the pivot columns. This routine does not work in place and leaves
+    the original matrix *A* unmodified.
+
+    Examples
+    ========
+
+    This routine works with a dict of dicts sparse representation of a matrix:
+
+    >>> from sympy import QQ
+    >>> from sympy.polys.matrices.sdm import sdm_irref
+    >>> A = {0: {0: QQ(1), 1: QQ(2)}, 1: {0: QQ(3), 1: QQ(4)}}
+    >>> Arref, pivots, _ = sdm_irref(A)
+    >>> Arref
+    {0: {0: 1}, 1: {1: 1}}
+    >>> pivots
+    [0, 1]
+
+   The analogous calculation with :py:class:`~.Matrix` would be
+
+    >>> from sympy import Matrix
+    >>> M = Matrix([[1, 2], [3, 4]])
+    >>> Mrref, pivots = M.rref()
+    >>> Mrref
+    Matrix([
+    [1, 0],
+    [0, 1]])
+    >>> pivots
+    (0, 1)
+
+    Notes
+    =====
+
+    The cost of this algorithm is determined purely by the nonzero elements of
+    the matrix. No part of the cost of any step in this algorithm depends on
+    the number of rows or columns in the matrix. No step depends even on the
+    number of nonzero rows apart from the primary loop over those rows. The
+    implementation is much faster than ddm_rref for sparse matrices. In fact
+    at the time of writing it is also (slightly) faster than the dense
+    implementation even if the input is a fully dense matrix so it seems to be
+    faster in all cases.
+
+    The elements of the matrix should support exact division with ``/``. For
+    example elements of any domain that is a field (e.g. ``QQ``) should be
+    fine. No attempt is made to handle inexact arithmetic.
+
+    """
+    #
+    # Any zeros in the matrix are not stored at all so an element is zero if
+    # its row dict has no index at that key. A row is entirely zero if its
+    # row index is not in the outer dict. Since rref reorders the rows and
+    # removes zero rows we can completely discard the row indices. The first
+    # step then copies the row dicts into a list sorted by the index of the
+    # first nonzero column in each row.
+    #
+    # The algorithm then processes each row Ai one at a time. Previously seen
+    # rows are used to cancel their pivot columns from Ai. Then a pivot from
+    # Ai is chosen and is cancelled from all previously seen rows. At this
+    # point Ai joins the previously seen rows. Once all rows are seen all
+    # elimination has occurred and the rows are sorted by pivot column index.
+    #
+    # The previously seen rows are stored in two separate groups. The reduced
+    # group consists of all rows that have been reduced to a single nonzero
+    # element (the pivot). There is no need to attempt any further reduction
+    # with these. Rows that still have other nonzeros need to be considered
+    # when Ai is cancelled from the previously seen rows.
+    #
+    # A dict nonzerocolumns is used to map from a column index to a set of
+    # previously seen rows that still have a nonzero element in that column.
+    # This means that we can cancel the pivot from Ai into the previously seen
+    # rows without needing to loop over each row that might have a zero in
+    # that column.
+    #
+
+    # Row dicts sorted by index of first nonzero column
+    # (Maybe sorting is not needed/useful.)
+    Arows = sorted((Ai.copy() for Ai in A.values()), key=min)
+
+    # Each processed row has an associated pivot column.
+    # pivot_row_map maps from the pivot column index to the row dict.
+    # This means that we can represent a set of rows purely as a set of their
+    # pivot indices.
+    pivot_row_map = {}
+
+    # Set of pivot indices for rows that are fully reduced to a single nonzero.
+    reduced_pivots = set()
+
+    # Set of pivot indices for rows not fully reduced
+    nonreduced_pivots = set()
+
+    # Map from column index to a set of pivot indices representing the rows
+    # that have a nonzero at that column.
+    nonzero_columns = defaultdict(set)
+
+    while Arows:
+        # Select pivot element and row
+        Ai = Arows.pop()
+
+        # Nonzero columns from fully reduced pivot rows can be removed
+        Ai = {j: Aij for j, Aij in Ai.items() if j not in reduced_pivots}
+
+        # Others require full row cancellation
+        for j in nonreduced_pivots & set(Ai):
+            Aj = pivot_row_map[j]
+            Aij = Ai[j]
+            Ainz = set(Ai)
+            Ajnz = set(Aj)
+            for k in Ajnz - Ainz:
+                Ai[k] = - Aij * Aj[k]
+            Ai.pop(j)
+            Ainz.remove(j)
+            for k in Ajnz & Ainz:
+                Aik = Ai[k] - Aij * Aj[k]
+                if Aik:
+                    Ai[k] = Aik
+                else:
+                    Ai.pop(k)
+
+        # We have now cancelled previously seen pivots from Ai.
+        # If it is zero then discard it.
+        if not Ai:
+            continue
+
+        # Choose a pivot from Ai:
+        j = min(Ai)
+        Aij = Ai[j]
+        pivot_row_map[j] = Ai
+        Ainz = set(Ai)
+
+        # Normalise the pivot row to make the pivot 1.
+        #
+        # This approach is slow for some domains. Cross cancellation might be
+        # better for e.g. QQ(x) with division delayed to the final steps.
+        Aijinv = Aij**-1
+        for l in Ai:
+            Ai[l] *= Aijinv
+
+        # Use Aij to cancel column j from all previously seen rows
+        for k in nonzero_columns.pop(j, ()):
+            Ak = pivot_row_map[k]
+            Akj = Ak[j]
+            Aknz = set(Ak)
+            for l in Ainz - Aknz:
+                Ak[l] = - Akj * Ai[l]
+                nonzero_columns[l].add(k)
+            Ak.pop(j)
+            Aknz.remove(j)
+            for l in Ainz & Aknz:
+                Akl = Ak[l] - Akj * Ai[l]
+                if Akl:
+                    Ak[l] = Akl
+                else:
+                    # Drop nonzero elements
+                    Ak.pop(l)
+                    if l != j:
+                        nonzero_columns[l].remove(k)
+            if len(Ak) == 1:
+                reduced_pivots.add(k)
+                nonreduced_pivots.remove(k)
+
+        if len(Ai) == 1:
+            reduced_pivots.add(j)
+        else:
+            nonreduced_pivots.add(j)
+            for l in Ai:
+                if l != j:
+                    nonzero_columns[l].add(j)
+
+    # All done!
+    pivots = sorted(reduced_pivots | nonreduced_pivots)
+    pivot2row = {p: n for n, p in enumerate(pivots)}
+    nonzero_columns = {c: {pivot2row[p] for p in s} for c, s in nonzero_columns.items()}
+    rows = [pivot_row_map[i] for i in pivots]
+    rref = dict(enumerate(rows))
+    return rref, pivots, nonzero_columns
+
+
+def sdm_nullspace_from_rref(A, one, ncols, pivots, nonzero_cols):
+    """Get nullspace from A which is in RREF"""
+    nonpivots = sorted(set(range(ncols)) - set(pivots))
+
+    K = []
+    for j in nonpivots:
+        Kj = {j:one}
+        for i in nonzero_cols.get(j, ()):
+            Kj[pivots[i]] = -A[i][j]
+        K.append(Kj)
+
+    return K, nonpivots
+
+
+def sdm_particular_from_rref(A, ncols, pivots):
+    """Get a particular solution from A which is in RREF"""
+    P = {}
+    for i, j in enumerate(pivots):
+        Ain = A[i].get(ncols-1, None)
+        if Ain is not None:
+            P[j] = Ain / A[i][j]
+    return P

llmeval-env/lib/python3.10/site-packages/sympy/polys/matrices/tests/test_ddm.py

@@ -0,0 +1,557 @@
+from sympy.testing.pytest import raises
+from sympy.external.gmpy import HAS_GMPY
+
+from sympy.polys import ZZ, QQ
+
+from sympy.polys.matrices.ddm import DDM
+from sympy.polys.matrices.exceptions import (
+    DMShapeError, DMNonInvertibleMatrixError, DMDomainError,
+    DMBadInputError)
+
+
+def test_DDM_init():
+    items = [[ZZ(0), ZZ(1), ZZ(2)], [ZZ(3), ZZ(4), ZZ(5)]]
+    shape = (2, 3)
+    ddm = DDM(items, shape, ZZ)
+    assert ddm.shape == shape
+    assert ddm.rows == 2
+    assert ddm.cols == 3
+    assert ddm.domain == ZZ
+
+    raises(DMBadInputError, lambda: DDM([[ZZ(2), ZZ(3)]], (2, 2), ZZ))
+    raises(DMBadInputError, lambda: DDM([[ZZ(1)], [ZZ(2), ZZ(3)]], (2, 2), ZZ))
+
+
+def test_DDM_getsetitem():
+    ddm = DDM([[ZZ(2), ZZ(3)], [ZZ(4), ZZ(5)]], (2, 2), ZZ)
+
+    assert ddm[0][0] == ZZ(2)
+    assert ddm[0][1] == ZZ(3)
+    assert ddm[1][0] == ZZ(4)
+    assert ddm[1][1] == ZZ(5)
+
+    raises(IndexError, lambda: ddm[2][0])
+    raises(IndexError, lambda: ddm[0][2])
+
+    ddm[0][0] = ZZ(-1)
+    assert ddm[0][0] == ZZ(-1)
+
+
+def test_DDM_str():
+    ddm = DDM([[ZZ(0), ZZ(1)], [ZZ(2), ZZ(3)]], (2, 2), ZZ)
+    if HAS_GMPY: # pragma: no cover
+        assert str(ddm) == '[[0, 1], [2, 3]]'
+        assert repr(ddm) == 'DDM([[mpz(0), mpz(1)], [mpz(2), mpz(3)]], (2, 2), ZZ)'
+    else:        # pragma: no cover
+        assert repr(ddm) == 'DDM([[0, 1], [2, 3]], (2, 2), ZZ)'
+        assert str(ddm) == '[[0, 1], [2, 3]]'
+
+
+def test_DDM_eq():
+    items = [[ZZ(0), ZZ(1)], [ZZ(2), ZZ(3)]]
+    ddm1 = DDM(items, (2, 2), ZZ)
+    ddm2 = DDM(items, (2, 2), ZZ)
+
+    assert (ddm1 == ddm1) is True
+    assert (ddm1 == items) is False
+    assert (items == ddm1) is False
+    assert (ddm1 == ddm2) is True
+    assert (ddm2 == ddm1) is True
+
+    assert (ddm1 != ddm1) is False
+    assert (ddm1 != items) is True
+    assert (items != ddm1) is True
+    assert (ddm1 != ddm2) is False
+    assert (ddm2 != ddm1) is False
+
+    ddm3 = DDM([[ZZ(0), ZZ(1)], [ZZ(3), ZZ(3)]], (2, 2), ZZ)
+    ddm3 = DDM(items, (2, 2), QQ)
+
+    assert (ddm1 == ddm3) is False
+    assert (ddm3 == ddm1) is False
+    assert (ddm1 != ddm3) is True
+    assert (ddm3 != ddm1) is True
+
+
+def test_DDM_convert_to():
+    ddm = DDM([[ZZ(1), ZZ(2)]], (1, 2), ZZ)
+    assert ddm.convert_to(ZZ) == ddm
+    ddmq = ddm.convert_to(QQ)
+    assert ddmq.domain == QQ
+
+
+def test_DDM_zeros():
+    ddmz = DDM.zeros((3, 4), QQ)
+    assert list(ddmz) == [[QQ(0)] * 4] * 3
+    assert ddmz.shape == (3, 4)
+    assert ddmz.domain == QQ
+
+def test_DDM_ones():
+    ddmone = DDM.ones((2, 3), QQ)
+    assert list(ddmone) == [[QQ(1)] * 3] * 2
+    assert ddmone.shape == (2, 3)
+    assert ddmone.domain == QQ
+
+def test_DDM_eye():
+    ddmz = DDM.eye(3, QQ)
+    f = lambda i, j: QQ(1) if i == j else QQ(0)
+    assert list(ddmz) == [[f(i, j) for i in range(3)] for j in range(3)]
+    assert ddmz.shape == (3, 3)
+    assert ddmz.domain == QQ
+
+
+def test_DDM_copy():
+    ddm1 = DDM([[QQ(1)], [QQ(2)]], (2, 1), QQ)
+    ddm2 = ddm1.copy()
+    assert (ddm1 == ddm2) is True
+    ddm1[0][0] = QQ(-1)
+    assert (ddm1 == ddm2) is False
+    ddm2[0][0] = QQ(-1)
+    assert (ddm1 == ddm2) is True
+
+
+def test_DDM_transpose():
+    ddm = DDM([[QQ(1)], [QQ(2)]], (2, 1), QQ)
+    ddmT = DDM([[QQ(1), QQ(2)]], (1, 2), QQ)
+    assert ddm.transpose() == ddmT
+    ddm02 = DDM([], (0, 2), QQ)
+    ddm02T = DDM([[], []], (2, 0), QQ)
+    assert ddm02.transpose() == ddm02T
+    assert ddm02T.transpose() == ddm02
+    ddm0 = DDM([], (0, 0), QQ)
+    assert ddm0.transpose() == ddm0
+
+
+def test_DDM_add():
+    A = DDM([[ZZ(1)], [ZZ(2)]], (2, 1), ZZ)
+    B = DDM([[ZZ(3)], [ZZ(4)]], (2, 1), ZZ)
+    C = DDM([[ZZ(4)], [ZZ(6)]], (2, 1), ZZ)
+    AQ = DDM([[QQ(1)], [QQ(2)]], (2, 1), QQ)
+    assert A + B == A.add(B) == C
+
+    raises(DMShapeError, lambda: A + DDM([[ZZ(5)]], (1, 1), ZZ))
+    raises(TypeError, lambda: A + ZZ(1))
+    raises(TypeError, lambda: ZZ(1) + A)
+    raises(DMDomainError, lambda: A + AQ)
+    raises(DMDomainError, lambda: AQ + A)
+
+
+def test_DDM_sub():
+    A = DDM([[ZZ(1)], [ZZ(2)]], (2, 1), ZZ)
+    B = DDM([[ZZ(3)], [ZZ(4)]], (2, 1), ZZ)
+    C = DDM([[ZZ(-2)], [ZZ(-2)]], (2, 1), ZZ)
+    AQ = DDM([[QQ(1)], [QQ(2)]], (2, 1), QQ)
+    D = DDM([[ZZ(5)]], (1, 1), ZZ)
+    assert A - B == A.sub(B) == C
+
+    raises(TypeError, lambda: A - ZZ(1))
+    raises(TypeError, lambda: ZZ(1) - A)
+    raises(DMShapeError, lambda: A - D)
+    raises(DMShapeError, lambda: D - A)
+    raises(DMShapeError, lambda: A.sub(D))
+    raises(DMShapeError, lambda: D.sub(A))
+    raises(DMDomainError, lambda: A - AQ)
+    raises(DMDomainError, lambda: AQ - A)
+    raises(DMDomainError, lambda: A.sub(AQ))
+    raises(DMDomainError, lambda: AQ.sub(A))
+
+
+def test_DDM_neg():
+    A = DDM([[ZZ(1)], [ZZ(2)]], (2, 1), ZZ)
+    An = DDM([[ZZ(-1)], [ZZ(-2)]], (2, 1), ZZ)
+    assert -A == A.neg() == An
+    assert -An == An.neg() == A
+
+
+def test_DDM_mul():
+    A = DDM([[ZZ(1)]], (1, 1), ZZ)
+    A2 = DDM([[ZZ(2)]], (1, 1), ZZ)
+    assert A * ZZ(2) == A2
+    assert ZZ(2) * A == A2
+    raises(TypeError, lambda: [[1]] * A)
+    raises(TypeError, lambda: A * [[1]])
+
+
+def test_DDM_matmul():
+    A = DDM([[ZZ(1)], [ZZ(2)]], (2, 1), ZZ)
+    B = DDM([[ZZ(3), ZZ(4)]], (1, 2), ZZ)
+    AB = DDM([[ZZ(3), ZZ(4)], [ZZ(6), ZZ(8)]], (2, 2), ZZ)
+    BA = DDM([[ZZ(11)]], (1, 1), ZZ)
+
+    assert A @ B == A.matmul(B) == AB
+    assert B @ A == B.matmul(A) == BA
+
+    raises(TypeError, lambda: A @ 1)
+    raises(TypeError, lambda: A @ [[3, 4]])
+
+    Bq = DDM([[QQ(3), QQ(4)]], (1, 2), QQ)
+
+    raises(DMDomainError, lambda: A @ Bq)
+    raises(DMDomainError, lambda: Bq @ A)
+
+    C = DDM([[ZZ(1)]], (1, 1), ZZ)
+
+    assert A @ C == A.matmul(C) == A
+
+    raises(DMShapeError, lambda: C @ A)
+    raises(DMShapeError, lambda: C.matmul(A))
+
+    Z04 = DDM([], (0, 4), ZZ)
+    Z40 = DDM([[]]*4, (4, 0), ZZ)
+    Z50 = DDM([[]]*5, (5, 0), ZZ)
+    Z05 = DDM([], (0, 5), ZZ)
+    Z45 = DDM([[0] * 5] * 4, (4, 5), ZZ)
+    Z54 = DDM([[0] * 4] * 5, (5, 4), ZZ)
+    Z00 = DDM([], (0, 0), ZZ)
+
+    assert Z04 @ Z45 == Z04.matmul(Z45) == Z05
+    assert Z45 @ Z50 == Z45.matmul(Z50) == Z40
+    assert Z00 @ Z04 == Z00.matmul(Z04) == Z04
+    assert Z50 @ Z00 == Z50.matmul(Z00) == Z50
+    assert Z00 @ Z00 == Z00.matmul(Z00) == Z00
+    assert Z50 @ Z04 == Z50.matmul(Z04) == Z54
+
+    raises(DMShapeError, lambda: Z05 @ Z40)
+    raises(DMShapeError, lambda: Z05.matmul(Z40))
+
+
+def test_DDM_hstack():
+    A = DDM([[ZZ(1), ZZ(2), ZZ(3)]], (1, 3), ZZ)
+    B = DDM([[ZZ(4), ZZ(5)]], (1, 2), ZZ)
+    C = DDM([[ZZ(6)]], (1, 1), ZZ)
+
+    Ah = A.hstack(B)
+    assert Ah.shape == (1, 5)
+    assert Ah.domain == ZZ
+    assert Ah == DDM([[ZZ(1), ZZ(2), ZZ(3), ZZ(4), ZZ(5)]], (1, 5), ZZ)
+
+    Ah = A.hstack(B, C)
+    assert Ah.shape == (1, 6)
+    assert Ah.domain == ZZ
+    assert Ah == DDM([[ZZ(1), ZZ(2), ZZ(3), ZZ(4), ZZ(5), ZZ(6)]], (1, 6), ZZ)
+
+
+def test_DDM_vstack():
+    A = DDM([[ZZ(1)], [ZZ(2)], [ZZ(3)]], (3, 1), ZZ)
+    B = DDM([[ZZ(4)], [ZZ(5)]], (2, 1), ZZ)
+    C = DDM([[ZZ(6)]], (1, 1), ZZ)
+
+    Ah = A.vstack(B)
+    assert Ah.shape == (5, 1)
+    assert Ah.domain == ZZ
+    assert Ah == DDM([[ZZ(1)], [ZZ(2)], [ZZ(3)], [ZZ(4)], [ZZ(5)]], (5, 1), ZZ)
+
+    Ah = A.vstack(B, C)
+    assert Ah.shape == (6, 1)
+    assert Ah.domain == ZZ
+    assert Ah == DDM([[ZZ(1)], [ZZ(2)], [ZZ(3)], [ZZ(4)], [ZZ(5)], [ZZ(6)]], (6, 1), ZZ)
+
+
+def test_DDM_applyfunc():
+    A = DDM([[ZZ(1), ZZ(2), ZZ(3)]], (1, 3), ZZ)
+    B = DDM([[ZZ(2), ZZ(4), ZZ(6)]], (1, 3), ZZ)
+    assert A.applyfunc(lambda x: 2*x, ZZ) == B
+
+def test_DDM_rref():
+
+    A = DDM([], (0, 4), QQ)
+    assert A.rref() == (A, [])
+
+    A = DDM([[QQ(0), QQ(1)], [QQ(1), QQ(1)]], (2, 2), QQ)
+    Ar = DDM([[QQ(1), QQ(0)], [QQ(0), QQ(1)]], (2, 2), QQ)
+    pivots = [0, 1]
+    assert A.rref() == (Ar, pivots)
+
+    A = DDM([[QQ(1), QQ(2), QQ(1)], [QQ(3), QQ(4), QQ(1)]], (2, 3), QQ)
+    Ar = DDM([[QQ(1), QQ(0), QQ(-1)], [QQ(0), QQ(1), QQ(1)]], (2, 3), QQ)
+    pivots = [0, 1]
+    assert A.rref() == (Ar, pivots)
+
+    A = DDM([[QQ(3), QQ(4), QQ(1)], [QQ(1), QQ(2), QQ(1)]], (2, 3), QQ)
+    Ar = DDM([[QQ(1), QQ(0), QQ(-1)], [QQ(0), QQ(1), QQ(1)]], (2, 3), QQ)
+    pivots = [0, 1]
+    assert A.rref() == (Ar, pivots)
+
+    A = DDM([[QQ(1), QQ(0)], [QQ(1), QQ(3)], [QQ(0), QQ(1)]], (3, 2), QQ)
+    Ar = DDM([[QQ(1), QQ(0)], [QQ(0), QQ(1)], [QQ(0), QQ(0)]], (3, 2), QQ)
+    pivots = [0, 1]
+    assert A.rref() == (Ar, pivots)
+
+    A = DDM([[QQ(1), QQ(0), QQ(1)], [QQ(3), QQ(0), QQ(1)]], (2, 3), QQ)
+    Ar = DDM([[QQ(1), QQ(0), QQ(0)], [QQ(0), QQ(0), QQ(1)]], (2, 3), QQ)
+    pivots = [0, 2]
+    assert A.rref() == (Ar, pivots)
+
+
+def test_DDM_nullspace():
+     A = DDM([[QQ(1), QQ(1)], [QQ(1), QQ(1)]], (2, 2), QQ)
+     Anull = DDM([[QQ(-1), QQ(1)]], (1, 2), QQ)
+     nonpivots = [1]
+     assert A.nullspace() == (Anull, nonpivots)
+
+
+def test_DDM_particular():
+    A = DDM([[QQ(1), QQ(0)]], (1, 2), QQ)
+    assert A.particular() == DDM.zeros((1, 1), QQ)
+
+
+def test_DDM_det():
+    # 0x0 case
+    A = DDM([], (0, 0), ZZ)
+    assert A.det() == ZZ(1)
+
+    # 1x1 case
+    A = DDM([[ZZ(2)]], (1, 1), ZZ)
+    assert A.det() == ZZ(2)
+
+    # 2x2 case
+    A = DDM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    assert A.det() == ZZ(-2)
+
+    # 3x3 with swap
+    A = DDM([[ZZ(1), ZZ(2), ZZ(3)], [ZZ(1), ZZ(2), ZZ(4)], [ZZ(1), ZZ(2), ZZ(5)]], (3, 3), ZZ)
+    assert A.det() == ZZ(0)
+
+    # 2x2 QQ case
+    A = DDM([[QQ(1, 2), QQ(1, 2)], [QQ(1, 3), QQ(1, 4)]], (2, 2), QQ)
+    assert A.det() == QQ(-1, 24)
+
+    # Nonsquare error
+    A = DDM([[ZZ(1)], [ZZ(2)]], (2, 1), ZZ)
+    raises(DMShapeError, lambda: A.det())
+
+    # Nonsquare error with empty matrix
+    A = DDM([], (0, 1), ZZ)
+    raises(DMShapeError, lambda: A.det())
+
+
+def test_DDM_inv():
+    A = DDM([[QQ(1, 1), QQ(2, 1)], [QQ(3, 1), QQ(4, 1)]], (2, 2), QQ)
+    Ainv = DDM([[QQ(-2, 1), QQ(1, 1)], [QQ(3, 2), QQ(-1, 2)]], (2, 2), QQ)
+    assert A.inv() == Ainv
+
+    A = DDM([[QQ(1), QQ(2)]], (1, 2), QQ)
+    raises(DMShapeError, lambda: A.inv())
+
+    A = DDM([[ZZ(2)]], (1, 1), ZZ)
+    raises(ValueError, lambda: A.inv())
+
+    A = DDM([], (0, 0), QQ)
+    assert A.inv() == A
+
+    A = DDM([[QQ(1), QQ(2)], [QQ(2), QQ(4)]], (2, 2), QQ)
+    raises(DMNonInvertibleMatrixError, lambda: A.inv())
+
+
+def test_DDM_lu():
+    A = DDM([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    L, U, swaps = A.lu()
+    assert L == DDM([[QQ(1), QQ(0)], [QQ(3), QQ(1)]], (2, 2), QQ)
+    assert U == DDM([[QQ(1), QQ(2)], [QQ(0), QQ(-2)]], (2, 2), QQ)
+    assert swaps == []
+
+    A = [[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 1, 1], [0, 0, 1, 2]]
+    Lexp = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 1, 1]]
+    Uexp = [[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 1, 1], [0, 0, 0, 1]]
+    to_dom = lambda rows, dom: [[dom(e) for e in row] for row in rows]
+    A = DDM(to_dom(A, QQ), (4, 4), QQ)
+    Lexp = DDM(to_dom(Lexp, QQ), (4, 4), QQ)
+    Uexp = DDM(to_dom(Uexp, QQ), (4, 4), QQ)
+    L, U, swaps = A.lu()
+    assert L == Lexp
+    assert U == Uexp
+    assert swaps == []
+
+
+def test_DDM_lu_solve():
+    # Basic example
+    A = DDM([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    b = DDM([[QQ(1)], [QQ(2)]], (2, 1), QQ)
+    x = DDM([[QQ(0)], [QQ(1, 2)]], (2, 1), QQ)
+    assert A.lu_solve(b) == x
+
+    # Example with swaps
+    A = DDM([[QQ(0), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    assert A.lu_solve(b) == x
+
+    # Overdetermined, consistent
+    A = DDM([[QQ(1), QQ(2)], [QQ(3), QQ(4)], [QQ(5), QQ(6)]], (3, 2), QQ)
+    b = DDM([[QQ(1)], [QQ(2)], [QQ(3)]], (3, 1), QQ)
+    assert A.lu_solve(b) == x
+
+    # Overdetermined, inconsistent
+    b = DDM([[QQ(1)], [QQ(2)], [QQ(4)]], (3, 1), QQ)
+    raises(DMNonInvertibleMatrixError, lambda: A.lu_solve(b))
+
+    # Square, noninvertible
+    A = DDM([[QQ(1), QQ(2)], [QQ(1), QQ(2)]], (2, 2), QQ)
+    b = DDM([[QQ(1)], [QQ(2)]], (2, 1), QQ)
+    raises(DMNonInvertibleMatrixError, lambda: A.lu_solve(b))
+
+    # Underdetermined
+    A = DDM([[QQ(1), QQ(2)]], (1, 2), QQ)
+    b = DDM([[QQ(3)]], (1, 1), QQ)
+    raises(NotImplementedError, lambda: A.lu_solve(b))
+
+    # Domain mismatch
+    bz = DDM([[ZZ(1)], [ZZ(2)]], (2, 1), ZZ)
+    raises(DMDomainError, lambda: A.lu_solve(bz))
+
+    # Shape mismatch
+    b3 = DDM([[QQ(1)], [QQ(2)], [QQ(3)]], (3, 1), QQ)
+    raises(DMShapeError, lambda: A.lu_solve(b3))
+
+
+def test_DDM_charpoly():
+    A = DDM([], (0, 0), ZZ)
+    assert A.charpoly() == [ZZ(1)]
+
+    A = DDM([
+        [ZZ(1), ZZ(2), ZZ(3)],
+        [ZZ(4), ZZ(5), ZZ(6)],
+        [ZZ(7), ZZ(8), ZZ(9)]], (3, 3), ZZ)
+    Avec = [ZZ(1), ZZ(-15), ZZ(-18), ZZ(0)]
+    assert A.charpoly() == Avec
+
+    A = DDM([[ZZ(1), ZZ(2)]], (1, 2), ZZ)
+    raises(DMShapeError, lambda: A.charpoly())
+
+
+def test_DDM_getitem():
+    dm = DDM([
+        [ZZ(1), ZZ(2), ZZ(3)],
+        [ZZ(4), ZZ(5), ZZ(6)],
+        [ZZ(7), ZZ(8), ZZ(9)]], (3, 3), ZZ)
+
+    assert dm.getitem(1, 1) == ZZ(5)
+    assert dm.getitem(1, -2) == ZZ(5)
+    assert dm.getitem(-1, -3) == ZZ(7)
+
+    raises(IndexError, lambda: dm.getitem(3, 3))
+
+
+def test_DDM_setitem():
+    dm = DDM.zeros((3, 3), ZZ)
+    dm.setitem(0, 0, 1)
+    dm.setitem(1, -2, 1)
+    dm.setitem(-1, -1, 1)
+    assert dm == DDM.eye(3, ZZ)
+
+    raises(IndexError, lambda: dm.setitem(3, 3, 0))
+
+
+def test_DDM_extract_slice():
+    dm = DDM([
+        [ZZ(1), ZZ(2), ZZ(3)],
+        [ZZ(4), ZZ(5), ZZ(6)],
+        [ZZ(7), ZZ(8), ZZ(9)]], (3, 3), ZZ)
+
+    assert dm.extract_slice(slice(0, 3), slice(0, 3)) == dm
+    assert dm.extract_slice(slice(1, 3), slice(-2)) == DDM([[4], [7]], (2, 1), ZZ)
+    assert dm.extract_slice(slice(1, 3), slice(-2)) == DDM([[4], [7]], (2, 1), ZZ)
+    assert dm.extract_slice(slice(2, 3), slice(-2)) == DDM([[ZZ(7)]], (1, 1), ZZ)
+    assert dm.extract_slice(slice(0, 2), slice(-2)) == DDM([[1], [4]], (2, 1), ZZ)
+    assert dm.extract_slice(slice(-1), slice(-1)) == DDM([[1, 2], [4, 5]], (2, 2), ZZ)
+
+    assert dm.extract_slice(slice(2), slice(3, 4)) == DDM([[], []], (2, 0), ZZ)
+    assert dm.extract_slice(slice(3, 4), slice(2)) == DDM([], (0, 2), ZZ)
+    assert dm.extract_slice(slice(3, 4), slice(3, 4)) == DDM([], (0, 0), ZZ)
+
+
+def test_DDM_extract():
+    dm1 = DDM([
+        [ZZ(1), ZZ(2), ZZ(3)],
+        [ZZ(4), ZZ(5), ZZ(6)],
+        [ZZ(7), ZZ(8), ZZ(9)]], (3, 3), ZZ)
+    dm2 = DDM([
+        [ZZ(6), ZZ(4)],
+        [ZZ(3), ZZ(1)]], (2, 2), ZZ)
+    assert dm1.extract([1, 0], [2, 0]) == dm2
+    assert dm1.extract([-2, 0], [-1, 0]) == dm2
+
+    assert dm1.extract([], []) == DDM.zeros((0, 0), ZZ)
+    assert dm1.extract([1], []) == DDM.zeros((1, 0), ZZ)
+    assert dm1.extract([], [1]) == DDM.zeros((0, 1), ZZ)
+
+    raises(IndexError, lambda: dm2.extract([2], [0]))
+    raises(IndexError, lambda: dm2.extract([0], [2]))
+    raises(IndexError, lambda: dm2.extract([-3], [0]))
+    raises(IndexError, lambda: dm2.extract([0], [-3]))
+
+
+def test_DDM_flat():
+    dm = DDM([
+        [ZZ(6), ZZ(4)],
+        [ZZ(3), ZZ(1)]], (2, 2), ZZ)
+    assert dm.flat() == [ZZ(6), ZZ(4), ZZ(3), ZZ(1)]
+
+
+def test_DDM_is_zero_matrix():
+    A = DDM([[QQ(1), QQ(0)], [QQ(0), QQ(0)]], (2, 2), QQ)
+    Azero = DDM.zeros((1, 2), QQ)
+    assert A.is_zero_matrix() is False
+    assert Azero.is_zero_matrix() is True
+
+
+def test_DDM_is_upper():
+    # Wide matrices:
+    A = DDM([
+        [QQ(1), QQ(2), QQ(3), QQ(4)],
+        [QQ(0), QQ(5), QQ(6), QQ(7)],
+        [QQ(0), QQ(0), QQ(8), QQ(9)]
+    ], (3, 4), QQ)
+    B = DDM([
+        [QQ(1), QQ(2), QQ(3), QQ(4)],
+        [QQ(0), QQ(5), QQ(6), QQ(7)],
+        [QQ(0), QQ(7), QQ(8), QQ(9)]
+    ], (3, 4), QQ)
+    assert A.is_upper() is True
+    assert B.is_upper() is False
+
+    # Tall matrices:
+    A = DDM([
+        [QQ(1), QQ(2), QQ(3)],
+        [QQ(0), QQ(5), QQ(6)],
+        [QQ(0), QQ(0), QQ(8)],
+        [QQ(0), QQ(0), QQ(0)]
+    ], (4, 3), QQ)
+    B = DDM([
+        [QQ(1), QQ(2), QQ(3)],
+        [QQ(0), QQ(5), QQ(6)],
+        [QQ(0), QQ(0), QQ(8)],
+        [QQ(0), QQ(0), QQ(10)]
+    ], (4, 3), QQ)
+    assert A.is_upper() is True
+    assert B.is_upper() is False
+
+
+def test_DDM_is_lower():
+    # Tall matrices:
+    A = DDM([
+        [QQ(1), QQ(2), QQ(3), QQ(4)],
+        [QQ(0), QQ(5), QQ(6), QQ(7)],
+        [QQ(0), QQ(0), QQ(8), QQ(9)]
+    ], (3, 4), QQ).transpose()
+    B = DDM([
+        [QQ(1), QQ(2), QQ(3), QQ(4)],
+        [QQ(0), QQ(5), QQ(6), QQ(7)],
+        [QQ(0), QQ(7), QQ(8), QQ(9)]
+    ], (3, 4), QQ).transpose()
+    assert A.is_lower() is True
+    assert B.is_lower() is False
+
+    # Wide matrices:
+    A = DDM([
+        [QQ(1), QQ(2), QQ(3)],
+        [QQ(0), QQ(5), QQ(6)],
+        [QQ(0), QQ(0), QQ(8)],
+        [QQ(0), QQ(0), QQ(0)]
+    ], (4, 3), QQ).transpose()
+    B = DDM([
+        [QQ(1), QQ(2), QQ(3)],
+        [QQ(0), QQ(5), QQ(6)],
+        [QQ(0), QQ(0), QQ(8)],
+        [QQ(0), QQ(0), QQ(10)]
+    ], (4, 3), QQ).transpose()
+    assert A.is_lower() is True
+    assert B.is_lower() is False

llmeval-env/lib/python3.10/site-packages/sympy/polys/matrices/tests/test_dense.py

@@ -0,0 +1,345 @@
+from sympy.testing.pytest import raises
+
+from sympy.polys import ZZ, QQ
+
+from sympy.polys.matrices.ddm import DDM
+from sympy.polys.matrices.dense import (
+        ddm_transpose,
+        ddm_iadd, ddm_isub, ddm_ineg, ddm_imatmul, ddm_imul, ddm_irref,
+        ddm_idet, ddm_iinv, ddm_ilu, ddm_ilu_split, ddm_ilu_solve, ddm_berk)
+from sympy.polys.matrices.exceptions import (
+    DMShapeError, DMNonInvertibleMatrixError, DMNonSquareMatrixError)
+
+
+def test_ddm_transpose():
+    a = [[1, 2], [3, 4]]
+    assert ddm_transpose(a) == [[1, 3], [2, 4]]
+
+
+def test_ddm_iadd():
+    a = [[1, 2], [3, 4]]
+    b = [[5, 6], [7, 8]]
+    ddm_iadd(a, b)
+    assert a == [[6, 8], [10, 12]]
+
+
+def test_ddm_isub():
+    a = [[1, 2], [3, 4]]
+    b = [[5, 6], [7, 8]]
+    ddm_isub(a, b)
+    assert a == [[-4, -4], [-4, -4]]
+
+
+def test_ddm_ineg():
+    a = [[1, 2], [3, 4]]
+    ddm_ineg(a)
+    assert a == [[-1, -2], [-3, -4]]
+
+
+def test_ddm_matmul():
+    a = [[1, 2], [3, 4]]
+    ddm_imul(a, 2)
+    assert a == [[2, 4], [6, 8]]
+
+    a = [[1, 2], [3, 4]]
+    ddm_imul(a, 0)
+    assert a == [[0, 0], [0, 0]]
+
+
+def test_ddm_imatmul():
+    a = [[1, 2, 3], [4, 5, 6]]
+    b = [[1, 2], [3, 4], [5, 6]]
+
+    c1 = [[0, 0], [0, 0]]
+    ddm_imatmul(c1, a, b)
+    assert c1 == [[22, 28], [49, 64]]
+
+    c2 = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
+    ddm_imatmul(c2, b, a)
+    assert c2 == [[9, 12, 15], [19, 26, 33], [29, 40, 51]]
+
+    b3 = [[1], [2], [3]]
+    c3 = [[0], [0]]
+    ddm_imatmul(c3, a, b3)
+    assert c3 == [[14], [32]]
+
+
+def test_ddm_irref():
+    # Empty matrix
+    A = []
+    Ar = []
+    pivots = []
+    assert ddm_irref(A) == pivots
+    assert A == Ar
+
+    # Standard square case
+    A = [[QQ(0), QQ(1)], [QQ(1), QQ(1)]]
+    Ar = [[QQ(1), QQ(0)], [QQ(0), QQ(1)]]
+    pivots = [0, 1]
+    assert ddm_irref(A) == pivots
+    assert A == Ar
+
+    # m < n  case
+    A = [[QQ(1), QQ(2), QQ(1)], [QQ(3), QQ(4), QQ(1)]]
+    Ar = [[QQ(1), QQ(0), QQ(-1)], [QQ(0), QQ(1), QQ(1)]]
+    pivots = [0, 1]
+    assert ddm_irref(A) == pivots
+    assert A == Ar
+
+    # same m < n  but reversed
+    A = [[QQ(3), QQ(4), QQ(1)], [QQ(1), QQ(2), QQ(1)]]
+    Ar = [[QQ(1), QQ(0), QQ(-1)], [QQ(0), QQ(1), QQ(1)]]
+    pivots = [0, 1]
+    assert ddm_irref(A) == pivots
+    assert A == Ar
+
+    # m > n case
+    A = [[QQ(1), QQ(0)], [QQ(1), QQ(3)], [QQ(0), QQ(1)]]
+    Ar = [[QQ(1), QQ(0)], [QQ(0), QQ(1)], [QQ(0), QQ(0)]]
+    pivots = [0, 1]
+    assert ddm_irref(A) == pivots
+    assert A == Ar
+
+    # Example with missing pivot
+    A = [[QQ(1), QQ(0), QQ(1)], [QQ(3), QQ(0), QQ(1)]]
+    Ar = [[QQ(1), QQ(0), QQ(0)], [QQ(0), QQ(0), QQ(1)]]
+    pivots = [0, 2]
+    assert ddm_irref(A) == pivots
+    assert A == Ar
+
+    # Example with missing pivot and no replacement
+    A = [[QQ(0), QQ(1)], [QQ(0), QQ(2)], [QQ(1), QQ(0)]]
+    Ar = [[QQ(1), QQ(0)], [QQ(0), QQ(1)], [QQ(0), QQ(0)]]
+    pivots = [0, 1]
+    assert ddm_irref(A) == pivots
+    assert A == Ar
+
+
+def test_ddm_idet():
+    A = []
+    assert ddm_idet(A, ZZ) == ZZ(1)
+
+    A = [[ZZ(2)]]
+    assert ddm_idet(A, ZZ) == ZZ(2)
+
+    A = [[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]]
+    assert ddm_idet(A, ZZ) == ZZ(-2)
+
+    A = [[ZZ(1), ZZ(2), ZZ(3)], [ZZ(1), ZZ(2), ZZ(4)], [ZZ(1), ZZ(3), ZZ(5)]]
+    assert ddm_idet(A, ZZ) == ZZ(-1)
+
+    A = [[ZZ(1), ZZ(2), ZZ(3)], [ZZ(1), ZZ(2), ZZ(4)], [ZZ(1), ZZ(2), ZZ(5)]]
+    assert ddm_idet(A, ZZ) == ZZ(0)
+
+    A = [[QQ(1, 2), QQ(1, 2)], [QQ(1, 3), QQ(1, 4)]]
+    assert ddm_idet(A, QQ) == QQ(-1, 24)
+
+
+def test_ddm_inv():
+    A = []
+    Ainv = []
+    ddm_iinv(Ainv, A, QQ)
+    assert Ainv == A
+
+    A = []
+    Ainv = []
+    raises(ValueError, lambda: ddm_iinv(Ainv, A, ZZ))
+
+    A = [[QQ(1), QQ(2)]]
+    Ainv = [[QQ(0), QQ(0)]]
+    raises(DMNonSquareMatrixError, lambda: ddm_iinv(Ainv, A, QQ))
+
+    A = [[QQ(1, 1), QQ(2, 1)], [QQ(3, 1), QQ(4, 1)]]
+    Ainv = [[QQ(0), QQ(0)], [QQ(0), QQ(0)]]
+    Ainv_expected = [[QQ(-2, 1), QQ(1, 1)], [QQ(3, 2), QQ(-1, 2)]]
+    ddm_iinv(Ainv, A, QQ)
+    assert Ainv == Ainv_expected
+
+    A = [[QQ(1, 1), QQ(2, 1)], [QQ(2, 1), QQ(4, 1)]]
+    Ainv = [[QQ(0), QQ(0)], [QQ(0), QQ(0)]]
+    raises(DMNonInvertibleMatrixError, lambda: ddm_iinv(Ainv, A, QQ))
+
+
+def test_ddm_ilu():
+    A = []
+    Alu = []
+    swaps = ddm_ilu(A)
+    assert A == Alu
+    assert swaps == []
+
+    A = [[]]
+    Alu = [[]]
+    swaps = ddm_ilu(A)
+    assert A == Alu
+    assert swaps == []
+
+    A = [[QQ(1), QQ(2)], [QQ(3), QQ(4)]]
+    Alu = [[QQ(1), QQ(2)], [QQ(3), QQ(-2)]]
+    swaps = ddm_ilu(A)
+    assert A == Alu
+    assert swaps == []
+
+    A = [[QQ(0), QQ(2)], [QQ(3), QQ(4)]]
+    Alu = [[QQ(3), QQ(4)], [QQ(0), QQ(2)]]
+    swaps = ddm_ilu(A)
+    assert A == Alu
+    assert swaps == [(0, 1)]
+
+    A = [[QQ(1), QQ(2), QQ(3)], [QQ(4), QQ(5), QQ(6)], [QQ(7), QQ(8), QQ(9)]]
+    Alu = [[QQ(1), QQ(2), QQ(3)], [QQ(4), QQ(-3), QQ(-6)], [QQ(7), QQ(2), QQ(0)]]
+    swaps = ddm_ilu(A)
+    assert A == Alu
+    assert swaps == []
+
+    A = [[QQ(0), QQ(1), QQ(2)], [QQ(0), QQ(1), QQ(3)], [QQ(1), QQ(1), QQ(2)]]
+    Alu = [[QQ(1), QQ(1), QQ(2)], [QQ(0), QQ(1), QQ(3)], [QQ(0), QQ(1), QQ(-1)]]
+    swaps = ddm_ilu(A)
+    assert A == Alu
+    assert swaps == [(0, 2)]
+
+    A = [[QQ(1), QQ(2), QQ(3)], [QQ(4), QQ(5), QQ(6)]]
+    Alu = [[QQ(1), QQ(2), QQ(3)], [QQ(4), QQ(-3), QQ(-6)]]
+    swaps = ddm_ilu(A)
+    assert A == Alu
+    assert swaps == []
+
+    A = [[QQ(1), QQ(2)], [QQ(3), QQ(4)], [QQ(5), QQ(6)]]
+    Alu = [[QQ(1), QQ(2)], [QQ(3), QQ(-2)], [QQ(5), QQ(2)]]
+    swaps = ddm_ilu(A)
+    assert A == Alu
+    assert swaps == []
+
+
+def test_ddm_ilu_split():
+    U = []
+    L = []
+    Uexp = []
+    Lexp = []
+    swaps = ddm_ilu_split(L, U, QQ)
+    assert U == Uexp
+    assert L == Lexp
+    assert swaps == []
+
+    U = [[]]
+    L = [[QQ(1)]]
+    Uexp = [[]]
+    Lexp = [[QQ(1)]]
+    swaps = ddm_ilu_split(L, U, QQ)
+    assert U == Uexp
+    assert L == Lexp
+    assert swaps == []
+
+    U = [[QQ(1), QQ(2)], [QQ(3), QQ(4)]]
+    L = [[QQ(1), QQ(0)], [QQ(0), QQ(1)]]
+    Uexp = [[QQ(1), QQ(2)], [QQ(0), QQ(-2)]]
+    Lexp = [[QQ(1), QQ(0)], [QQ(3), QQ(1)]]
+    swaps = ddm_ilu_split(L, U, QQ)
+    assert U == Uexp
+    assert L == Lexp
+    assert swaps == []
+
+    U = [[QQ(1), QQ(2), QQ(3)], [QQ(4), QQ(5), QQ(6)]]
+    L = [[QQ(1), QQ(0)], [QQ(0), QQ(1)]]
+    Uexp = [[QQ(1), QQ(2), QQ(3)], [QQ(0), QQ(-3), QQ(-6)]]
+    Lexp = [[QQ(1), QQ(0)], [QQ(4), QQ(1)]]
+    swaps = ddm_ilu_split(L, U, QQ)
+    assert U == Uexp
+    assert L == Lexp
+    assert swaps == []
+
+    U = [[QQ(1), QQ(2)], [QQ(3), QQ(4)], [QQ(5), QQ(6)]]
+    L = [[QQ(1), QQ(0), QQ(0)], [QQ(0), QQ(1), QQ(0)], [QQ(0), QQ(0), QQ(1)]]
+    Uexp = [[QQ(1), QQ(2)], [QQ(0), QQ(-2)], [QQ(0), QQ(0)]]
+    Lexp = [[QQ(1), QQ(0), QQ(0)], [QQ(3), QQ(1), QQ(0)], [QQ(5), QQ(2), QQ(1)]]
+    swaps = ddm_ilu_split(L, U, QQ)
+    assert U == Uexp
+    assert L == Lexp
+    assert swaps == []
+
+
+def test_ddm_ilu_solve():
+    # Basic example
+    # A = [[QQ(1), QQ(2)], [QQ(3), QQ(4)]]
+    U = [[QQ(1), QQ(2)], [QQ(0), QQ(-2)]]
+    L = [[QQ(1), QQ(0)], [QQ(3), QQ(1)]]
+    swaps = []
+    b = DDM([[QQ(1)], [QQ(2)]], (2, 1), QQ)
+    x = DDM([[QQ(0)], [QQ(0)]], (2, 1), QQ)
+    xexp = DDM([[QQ(0)], [QQ(1, 2)]], (2, 1), QQ)
+    ddm_ilu_solve(x, L, U, swaps, b)
+    assert x == xexp
+
+    # Example with swaps
+    # A = [[QQ(0), QQ(2)], [QQ(3), QQ(4)]]
+    U = [[QQ(3), QQ(4)], [QQ(0), QQ(2)]]
+    L = [[QQ(1), QQ(0)], [QQ(0), QQ(1)]]
+    swaps = [(0, 1)]
+    b = DDM([[QQ(1)], [QQ(2)]], (2, 1), QQ)
+    x = DDM([[QQ(0)], [QQ(0)]], (2, 1), QQ)
+    xexp = DDM([[QQ(0)], [QQ(1, 2)]], (2, 1), QQ)
+    ddm_ilu_solve(x, L, U, swaps, b)
+    assert x == xexp
+
+    # Overdetermined, consistent
+    # A = DDM([[QQ(1), QQ(2)], [QQ(3), QQ(4)], [QQ(5), QQ(6)]], (3, 2), QQ)
+    U = [[QQ(1), QQ(2)], [QQ(0), QQ(-2)], [QQ(0), QQ(0)]]
+    L = [[QQ(1), QQ(0), QQ(0)], [QQ(3), QQ(1), QQ(0)], [QQ(5), QQ(2), QQ(1)]]
+    swaps = []
+    b = DDM([[QQ(1)], [QQ(2)], [QQ(3)]], (3, 1), QQ)
+    x = DDM([[QQ(0)], [QQ(0)]], (2, 1), QQ)
+    xexp = DDM([[QQ(0)], [QQ(1, 2)]], (2, 1), QQ)
+    ddm_ilu_solve(x, L, U, swaps, b)
+    assert x == xexp
+
+    # Overdetermined, inconsistent
+    b = DDM([[QQ(1)], [QQ(2)], [QQ(4)]], (3, 1), QQ)
+    raises(DMNonInvertibleMatrixError, lambda: ddm_ilu_solve(x, L, U, swaps, b))
+
+    # Square, noninvertible
+    # A = DDM([[QQ(1), QQ(2)], [QQ(1), QQ(2)]], (2, 2), QQ)
+    U = [[QQ(1), QQ(2)], [QQ(0), QQ(0)]]
+    L = [[QQ(1), QQ(0)], [QQ(1), QQ(1)]]
+    swaps = []
+    b = DDM([[QQ(1)], [QQ(2)]], (2, 1), QQ)
+    raises(DMNonInvertibleMatrixError, lambda: ddm_ilu_solve(x, L, U, swaps, b))
+
+    # Underdetermined
+    # A = DDM([[QQ(1), QQ(2)]], (1, 2), QQ)
+    U = [[QQ(1), QQ(2)]]
+    L = [[QQ(1)]]
+    swaps = []
+    b = DDM([[QQ(3)]], (1, 1), QQ)
+    raises(NotImplementedError, lambda: ddm_ilu_solve(x, L, U, swaps, b))
+
+    # Shape mismatch
+    b3 = DDM([[QQ(1)], [QQ(2)], [QQ(3)]], (3, 1), QQ)
+    raises(DMShapeError, lambda: ddm_ilu_solve(x, L, U, swaps, b3))
+
+    # Empty shape mismatch
+    U = [[QQ(1)]]
+    L = [[QQ(1)]]
+    swaps = []
+    x = [[QQ(1)]]
+    b = []
+    raises(DMShapeError, lambda: ddm_ilu_solve(x, L, U, swaps, b))
+
+    # Empty system
+    U = []
+    L = []
+    swaps = []
+    b = []
+    x = []
+    ddm_ilu_solve(x, L, U, swaps, b)
+    assert x == []
+
+
+def test_ddm_charpoly():
+    A = []
+    assert ddm_berk(A, ZZ) == [[ZZ(1)]]
+
+    A = [[ZZ(1), ZZ(2), ZZ(3)], [ZZ(4), ZZ(5), ZZ(6)], [ZZ(7), ZZ(8), ZZ(9)]]
+    Avec = [[ZZ(1)], [ZZ(-15)], [ZZ(-18)], [ZZ(0)]]
+    assert ddm_berk(A, ZZ) == Avec
+
+    A = DDM([[ZZ(1), ZZ(2)]], (1, 2), ZZ)
+    raises(DMShapeError, lambda: ddm_berk(A, ZZ))

llmeval-env/lib/python3.10/site-packages/sympy/polys/matrices/tests/test_domainmatrix.py

@@ -0,0 +1,910 @@
+from sympy.testing.pytest import raises
+
+from sympy.core.numbers import Integer, Rational
+from sympy.core.singleton import S
+from sympy.functions import sqrt
+
+from sympy.matrices.dense import Matrix
+from sympy.polys.domains import FF, ZZ, QQ, EXRAW
+
+from sympy.polys.matrices.domainmatrix import DomainMatrix, DomainScalar, DM
+from sympy.polys.matrices.exceptions import (
+    DMBadInputError, DMDomainError, DMShapeError, DMFormatError, DMNotAField,
+    DMNonSquareMatrixError, DMNonInvertibleMatrixError,
+)
+from sympy.polys.matrices.ddm import DDM
+from sympy.polys.matrices.sdm import SDM
+
+
+def test_DM():
+    ddm = DDM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    A = DM([[1, 2], [3, 4]], ZZ)
+    assert A.rep == ddm
+    assert A.shape == (2, 2)
+    assert A.domain == ZZ
+
+
+def test_DomainMatrix_init():
+    lol = [[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]]
+    dod = {0: {0: ZZ(1), 1:ZZ(2)}, 1: {0:ZZ(3), 1:ZZ(4)}}
+    ddm = DDM(lol, (2, 2), ZZ)
+    sdm = SDM(dod, (2, 2), ZZ)
+
+    A = DomainMatrix(lol, (2, 2), ZZ)
+    assert A.rep == ddm
+    assert A.shape == (2, 2)
+    assert A.domain == ZZ
+
+    A = DomainMatrix(dod, (2, 2), ZZ)
+    assert A.rep == sdm
+    assert A.shape == (2, 2)
+    assert A.domain == ZZ
+
+    raises(TypeError, lambda: DomainMatrix(ddm, (2, 2), ZZ))
+    raises(TypeError, lambda: DomainMatrix(sdm, (2, 2), ZZ))
+    raises(TypeError, lambda: DomainMatrix(Matrix([[1]]), (1, 1), ZZ))
+
+    for fmt, rep in [('sparse', sdm), ('dense', ddm)]:
+        A = DomainMatrix(lol, (2, 2), ZZ, fmt=fmt)
+        assert A.rep == rep
+        A = DomainMatrix(dod, (2, 2), ZZ, fmt=fmt)
+        assert A.rep == rep
+
+    raises(ValueError, lambda: DomainMatrix(lol, (2, 2), ZZ, fmt='invalid'))
+
+    raises(DMBadInputError, lambda: DomainMatrix([[ZZ(1), ZZ(2)]], (2, 2), ZZ))
+
+
+def test_DomainMatrix_from_rep():
+    ddm = DDM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    A = DomainMatrix.from_rep(ddm)
+    assert A.rep == ddm
+    assert A.shape == (2, 2)
+    assert A.domain == ZZ
+
+    sdm = SDM({0: {0: ZZ(1), 1:ZZ(2)}, 1: {0:ZZ(3), 1:ZZ(4)}}, (2, 2), ZZ)
+    A = DomainMatrix.from_rep(sdm)
+    assert A.rep == sdm
+    assert A.shape == (2, 2)
+    assert A.domain == ZZ
+
+    A = DomainMatrix([[ZZ(1)]], (1, 1), ZZ)
+    raises(TypeError, lambda: DomainMatrix.from_rep(A))
+
+
+def test_DomainMatrix_from_list():
+    ddm = DDM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    A = DomainMatrix.from_list([[1, 2], [3, 4]], ZZ)
+    assert A.rep == ddm
+    assert A.shape == (2, 2)
+    assert A.domain == ZZ
+
+    dom = FF(7)
+    ddm = DDM([[dom(1), dom(2)], [dom(3), dom(4)]], (2, 2), dom)
+    A = DomainMatrix.from_list([[1, 2], [3, 4]], dom)
+    assert A.rep == ddm
+    assert A.shape == (2, 2)
+    assert A.domain == dom
+
+    ddm = DDM([[QQ(1, 2), QQ(3, 1)], [QQ(1, 4), QQ(5, 1)]], (2, 2), QQ)
+    A = DomainMatrix.from_list([[(1, 2), (3, 1)], [(1, 4), (5, 1)]], QQ)
+    assert A.rep == ddm
+    assert A.shape == (2, 2)
+    assert A.domain == QQ
+
+
+def test_DomainMatrix_from_list_sympy():
+    ddm = DDM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    A = DomainMatrix.from_list_sympy(2, 2, [[1, 2], [3, 4]])
+    assert A.rep == ddm
+    assert A.shape == (2, 2)
+    assert A.domain == ZZ
+
+    K = QQ.algebraic_field(sqrt(2))
+    ddm = DDM(
+        [[K.convert(1 + sqrt(2)), K.convert(2 + sqrt(2))],
+         [K.convert(3 + sqrt(2)), K.convert(4 + sqrt(2))]],
+        (2, 2),
+        K
+    )
+    A = DomainMatrix.from_list_sympy(
+        2, 2, [[1 + sqrt(2), 2 + sqrt(2)], [3 + sqrt(2), 4 + sqrt(2)]],
+        extension=True)
+    assert A.rep == ddm
+    assert A.shape == (2, 2)
+    assert A.domain == K
+
+
+def test_DomainMatrix_from_dict_sympy():
+    sdm = SDM({0: {0: QQ(1, 2)}, 1: {1: QQ(2, 3)}}, (2, 2), QQ)
+    sympy_dict = {0: {0: Rational(1, 2)}, 1: {1: Rational(2, 3)}}
+    A = DomainMatrix.from_dict_sympy(2, 2, sympy_dict)
+    assert A.rep == sdm
+    assert A.shape == (2, 2)
+    assert A.domain == QQ
+
+    fds = DomainMatrix.from_dict_sympy
+    raises(DMBadInputError, lambda: fds(2, 2, {3: {0: Rational(1, 2)}}))
+    raises(DMBadInputError, lambda: fds(2, 2, {0: {3: Rational(1, 2)}}))
+
+
+def test_DomainMatrix_from_Matrix():
+    sdm = SDM({0: {0: ZZ(1), 1: ZZ(2)}, 1: {0: ZZ(3), 1: ZZ(4)}}, (2, 2), ZZ)
+    A = DomainMatrix.from_Matrix(Matrix([[1, 2], [3, 4]]))
+    assert A.rep == sdm
+    assert A.shape == (2, 2)
+    assert A.domain == ZZ
+
+    K = QQ.algebraic_field(sqrt(2))
+    sdm = SDM(
+        {0: {0: K.convert(1 + sqrt(2)), 1: K.convert(2 + sqrt(2))},
+         1: {0: K.convert(3 + sqrt(2)), 1: K.convert(4 + sqrt(2))}},
+        (2, 2),
+        K
+    )
+    A = DomainMatrix.from_Matrix(
+        Matrix([[1 + sqrt(2), 2 + sqrt(2)], [3 + sqrt(2), 4 + sqrt(2)]]),
+        extension=True)
+    assert A.rep == sdm
+    assert A.shape == (2, 2)
+    assert A.domain == K
+
+    A = DomainMatrix.from_Matrix(Matrix([[QQ(1, 2), QQ(3, 4)], [QQ(0, 1), QQ(0, 1)]]), fmt='dense')
+    ddm = DDM([[QQ(1, 2), QQ(3, 4)], [QQ(0, 1), QQ(0, 1)]], (2, 2), QQ)
+
+    assert A.rep == ddm
+    assert A.shape == (2, 2)
+    assert A.domain == QQ
+
+
+def test_DomainMatrix_eq():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    assert A == A
+    B = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(1)]], (2, 2), ZZ)
+    assert A != B
+    C = [[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]]
+    assert A != C
+
+
+def test_DomainMatrix_unify_eq():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    B1 = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    B2 = DomainMatrix([[QQ(1), QQ(3)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    B3 = DomainMatrix([[ZZ(1)]], (1, 1), ZZ)
+    assert A.unify_eq(B1) is True
+    assert A.unify_eq(B2) is False
+    assert A.unify_eq(B3) is False
+
+
+def test_DomainMatrix_get_domain():
+    K, items = DomainMatrix.get_domain([1, 2, 3, 4])
+    assert items == [ZZ(1), ZZ(2), ZZ(3), ZZ(4)]
+    assert K == ZZ
+
+    K, items = DomainMatrix.get_domain([1, 2, 3, Rational(1, 2)])
+    assert items == [QQ(1), QQ(2), QQ(3), QQ(1, 2)]
+    assert K == QQ
+
+
+def test_DomainMatrix_convert_to():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    Aq = A.convert_to(QQ)
+    assert Aq == DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    Acopy = A.convert_to(None)
+    assert Acopy == A and Acopy is not A
+
+
+def test_DomainMatrix_to_sympy():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    assert A.to_sympy() == A.convert_to(EXRAW)
+
+
+def test_DomainMatrix_to_field():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    Aq = A.to_field()
+    assert Aq == DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+
+
+def test_DomainMatrix_to_sparse():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    A_sparse = A.to_sparse()
+    assert A_sparse.rep == {0: {0: 1, 1: 2}, 1: {0: 3, 1: 4}}
+
+
+def test_DomainMatrix_to_dense():
+    A = DomainMatrix({0: {0: 1, 1: 2}, 1: {0: 3, 1: 4}}, (2, 2), ZZ)
+    A_dense = A.to_dense()
+    assert A_dense.rep == DDM([[1, 2], [3, 4]], (2, 2), ZZ)
+
+
+def test_DomainMatrix_unify():
+    Az = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    Aq = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    assert Az.unify(Az) == (Az, Az)
+    assert Az.unify(Aq) == (Aq, Aq)
+    assert Aq.unify(Az) == (Aq, Aq)
+    assert Aq.unify(Aq) == (Aq, Aq)
+
+    As = DomainMatrix({0: {1: ZZ(1)}, 1:{0:ZZ(2)}}, (2, 2), ZZ)
+    Ad = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+
+    assert As.unify(As) == (As, As)
+    assert Ad.unify(Ad) == (Ad, Ad)
+
+    Bs, Bd = As.unify(Ad, fmt='dense')
+    assert Bs.rep == DDM([[0, 1], [2, 0]], (2, 2), ZZ)
+    assert Bd.rep == DDM([[1, 2],[3, 4]], (2, 2), ZZ)
+
+    Bs, Bd = As.unify(Ad, fmt='sparse')
+    assert Bs.rep == SDM({0: {1: 1}, 1: {0: 2}}, (2, 2), ZZ)
+    assert Bd.rep == SDM({0: {0: 1, 1: 2}, 1: {0: 3, 1: 4}}, (2, 2), ZZ)
+
+    raises(ValueError, lambda: As.unify(Ad, fmt='invalid'))
+
+
+def test_DomainMatrix_to_Matrix():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    assert A.to_Matrix() == Matrix([[1, 2], [3, 4]])
+
+
+def test_DomainMatrix_to_list():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    assert A.to_list() == [[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]]
+
+
+def test_DomainMatrix_to_list_flat():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    assert A.to_list_flat() == [ZZ(1), ZZ(2), ZZ(3), ZZ(4)]
+
+
+def test_DomainMatrix_to_dok():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    assert A.to_dok() == {(0, 0):ZZ(1), (0, 1):ZZ(2), (1, 0):ZZ(3), (1, 1):ZZ(4)}
+
+
+def test_DomainMatrix_repr():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    assert repr(A) == 'DomainMatrix([[1, 2], [3, 4]], (2, 2), ZZ)'
+
+
+def test_DomainMatrix_transpose():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    AT = DomainMatrix([[ZZ(1), ZZ(3)], [ZZ(2), ZZ(4)]], (2, 2), ZZ)
+    assert A.transpose() == AT
+
+
+def test_DomainMatrix_flat():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    assert A.flat() == [ZZ(1), ZZ(2), ZZ(3), ZZ(4)]
+
+
+def test_DomainMatrix_is_zero_matrix():
+    A = DomainMatrix([[ZZ(1)]], (1, 1), ZZ)
+    B = DomainMatrix([[ZZ(0)]], (1, 1), ZZ)
+    assert A.is_zero_matrix is False
+    assert B.is_zero_matrix is True
+
+
+def test_DomainMatrix_is_upper():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(0), ZZ(4)]], (2, 2), ZZ)
+    B = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    assert A.is_upper is True
+    assert B.is_upper is False
+
+
+def test_DomainMatrix_is_lower():
+    A = DomainMatrix([[ZZ(1), ZZ(0)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    B = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    assert A.is_lower is True
+    assert B.is_lower is False
+
+
+def test_DomainMatrix_is_square():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    B = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)], [ZZ(5), ZZ(6)]], (3, 2), ZZ)
+    assert A.is_square is True
+    assert B.is_square is False
+
+
+def test_DomainMatrix_rank():
+    A = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)], [QQ(6), QQ(8)]], (3, 2), QQ)
+    assert A.rank() == 2
+
+
+def test_DomainMatrix_add():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    B = DomainMatrix([[ZZ(2), ZZ(4)], [ZZ(6), ZZ(8)]], (2, 2), ZZ)
+    assert A + A == A.add(A) == B
+
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    L = [[2, 3], [3, 4]]
+    raises(TypeError, lambda: A + L)
+    raises(TypeError, lambda: L + A)
+
+    A1 = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    A2 = DomainMatrix([[ZZ(1), ZZ(2)]], (1, 2), ZZ)
+    raises(DMShapeError, lambda: A1 + A2)
+    raises(DMShapeError, lambda: A2 + A1)
+    raises(DMShapeError, lambda: A1.add(A2))
+    raises(DMShapeError, lambda: A2.add(A1))
+
+    Az = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    Aq = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    Asum = DomainMatrix([[QQ(2), QQ(4)], [QQ(6), QQ(8)]], (2, 2), QQ)
+    assert Az + Aq == Asum
+    assert Aq + Az == Asum
+    raises(DMDomainError, lambda: Az.add(Aq))
+    raises(DMDomainError, lambda: Aq.add(Az))
+
+    As = DomainMatrix({0: {1: ZZ(1)}, 1: {0: ZZ(2)}}, (2, 2), ZZ)
+    Ad = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+
+    Asd = As + Ad
+    Ads = Ad + As
+    assert Asd == DomainMatrix([[1, 3], [5, 4]], (2, 2), ZZ)
+    assert Asd.rep == DDM([[1, 3], [5, 4]], (2, 2), ZZ)
+    assert Ads == DomainMatrix([[1, 3], [5, 4]], (2, 2), ZZ)
+    assert Ads.rep == DDM([[1, 3], [5, 4]], (2, 2), ZZ)
+    raises(DMFormatError, lambda: As.add(Ad))
+
+
+def test_DomainMatrix_sub():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    B = DomainMatrix([[ZZ(0), ZZ(0)], [ZZ(0), ZZ(0)]], (2, 2), ZZ)
+    assert A - A == A.sub(A) == B
+
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    L = [[2, 3], [3, 4]]
+    raises(TypeError, lambda: A - L)
+    raises(TypeError, lambda: L - A)
+
+    A1 = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    A2 = DomainMatrix([[ZZ(1), ZZ(2)]], (1, 2), ZZ)
+    raises(DMShapeError, lambda: A1 - A2)
+    raises(DMShapeError, lambda: A2 - A1)
+    raises(DMShapeError, lambda: A1.sub(A2))
+    raises(DMShapeError, lambda: A2.sub(A1))
+
+    Az = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    Aq = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    Adiff = DomainMatrix([[QQ(0), QQ(0)], [QQ(0), QQ(0)]], (2, 2), QQ)
+    assert Az - Aq == Adiff
+    assert Aq - Az == Adiff
+    raises(DMDomainError, lambda: Az.sub(Aq))
+    raises(DMDomainError, lambda: Aq.sub(Az))
+
+    As = DomainMatrix({0: {1: ZZ(1)}, 1: {0: ZZ(2)}}, (2, 2), ZZ)
+    Ad = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+
+    Asd = As - Ad
+    Ads = Ad - As
+    assert Asd == DomainMatrix([[-1, -1], [-1, -4]], (2, 2), ZZ)
+    assert Asd.rep == DDM([[-1, -1], [-1, -4]], (2, 2), ZZ)
+    assert Asd == -Ads
+    assert Asd.rep == -Ads.rep
+
+
+def test_DomainMatrix_neg():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    Aneg = DomainMatrix([[ZZ(-1), ZZ(-2)], [ZZ(-3), ZZ(-4)]], (2, 2), ZZ)
+    assert -A == A.neg() == Aneg
+
+
+def test_DomainMatrix_mul():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    A2 = DomainMatrix([[ZZ(7), ZZ(10)], [ZZ(15), ZZ(22)]], (2, 2), ZZ)
+    assert A*A == A.matmul(A) == A2
+
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    L = [[1, 2], [3, 4]]
+    raises(TypeError, lambda: A * L)
+    raises(TypeError, lambda: L * A)
+
+    Az = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    Aq = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    Aprod = DomainMatrix([[QQ(7), QQ(10)], [QQ(15), QQ(22)]], (2, 2), QQ)
+    assert Az * Aq == Aprod
+    assert Aq * Az == Aprod
+    raises(DMDomainError, lambda: Az.matmul(Aq))
+    raises(DMDomainError, lambda: Aq.matmul(Az))
+
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    AA = DomainMatrix([[ZZ(2), ZZ(4)], [ZZ(6), ZZ(8)]], (2, 2), ZZ)
+    x = ZZ(2)
+    assert A * x == x * A == A.mul(x) == AA
+
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    AA = DomainMatrix.zeros((2, 2), ZZ)
+    x = ZZ(0)
+    assert A * x == x * A == A.mul(x).to_sparse() == AA
+
+    As = DomainMatrix({0: {1: ZZ(1)}, 1: {0: ZZ(2)}}, (2, 2), ZZ)
+    Ad = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+
+    Asd = As * Ad
+    Ads = Ad * As
+    assert Asd == DomainMatrix([[3, 4], [2, 4]], (2, 2), ZZ)
+    assert Asd.rep == DDM([[3, 4], [2, 4]], (2, 2), ZZ)
+    assert Ads == DomainMatrix([[4, 1], [8, 3]], (2, 2), ZZ)
+    assert Ads.rep == DDM([[4, 1], [8, 3]], (2, 2), ZZ)
+
+
+def test_DomainMatrix_mul_elementwise():
+    A = DomainMatrix([[ZZ(2), ZZ(2)], [ZZ(0), ZZ(0)]], (2, 2), ZZ)
+    B = DomainMatrix([[ZZ(4), ZZ(0)], [ZZ(3), ZZ(0)]], (2, 2), ZZ)
+    C = DomainMatrix([[ZZ(8), ZZ(0)], [ZZ(0), ZZ(0)]], (2, 2), ZZ)
+    assert A.mul_elementwise(B) == C
+    assert B.mul_elementwise(A) == C
+
+
+def test_DomainMatrix_pow():
+    eye = DomainMatrix.eye(2, ZZ)
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    A2 = DomainMatrix([[ZZ(7), ZZ(10)], [ZZ(15), ZZ(22)]], (2, 2), ZZ)
+    A3 = DomainMatrix([[ZZ(37), ZZ(54)], [ZZ(81), ZZ(118)]], (2, 2), ZZ)
+    assert A**0 == A.pow(0) == eye
+    assert A**1 == A.pow(1) == A
+    assert A**2 == A.pow(2) == A2
+    assert A**3 == A.pow(3) == A3
+
+    raises(TypeError, lambda: A ** Rational(1, 2))
+    raises(NotImplementedError, lambda: A ** -1)
+    raises(NotImplementedError, lambda: A.pow(-1))
+
+    A = DomainMatrix.zeros((2, 1), ZZ)
+    raises(DMNonSquareMatrixError, lambda: A ** 1)
+
+
+def test_DomainMatrix_scc():
+    Ad = DomainMatrix([[ZZ(1), ZZ(2), ZZ(3)],
+                       [ZZ(0), ZZ(1), ZZ(0)],
+                       [ZZ(2), ZZ(0), ZZ(4)]], (3, 3), ZZ)
+    As = Ad.to_sparse()
+    Addm = Ad.rep
+    Asdm = As.rep
+    for A in [Ad, As, Addm, Asdm]:
+        assert Ad.scc() == [[1], [0, 2]]
+
+
+def test_DomainMatrix_rref():
+    A = DomainMatrix([], (0, 1), QQ)
+    assert A.rref() == (A, ())
+
+    A = DomainMatrix([[QQ(1)]], (1, 1), QQ)
+    assert A.rref() == (A, (0,))
+
+    A = DomainMatrix([[QQ(0)]], (1, 1), QQ)
+    assert A.rref() == (A, ())
+
+    A = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    Ar, pivots = A.rref()
+    assert Ar == DomainMatrix([[QQ(1), QQ(0)], [QQ(0), QQ(1)]], (2, 2), QQ)
+    assert pivots == (0, 1)
+
+    A = DomainMatrix([[QQ(0), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    Ar, pivots = A.rref()
+    assert Ar == DomainMatrix([[QQ(1), QQ(0)], [QQ(0), QQ(1)]], (2, 2), QQ)
+    assert pivots == (0, 1)
+
+    A = DomainMatrix([[QQ(0), QQ(2)], [QQ(0), QQ(4)]], (2, 2), QQ)
+    Ar, pivots = A.rref()
+    assert Ar == DomainMatrix([[QQ(0), QQ(1)], [QQ(0), QQ(0)]], (2, 2), QQ)
+    assert pivots == (1,)
+
+    Az = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    raises(DMNotAField, lambda: Az.rref())
+
+
+def test_DomainMatrix_columnspace():
+    A = DomainMatrix([[QQ(1), QQ(-1), QQ(1)], [QQ(2), QQ(-2), QQ(3)]], (2, 3), QQ)
+    Acol = DomainMatrix([[QQ(1), QQ(1)], [QQ(2), QQ(3)]], (2, 2), QQ)
+    assert A.columnspace() == Acol
+
+    Az = DomainMatrix([[ZZ(1), ZZ(-1), ZZ(1)], [ZZ(2), ZZ(-2), ZZ(3)]], (2, 3), ZZ)
+    raises(DMNotAField, lambda: Az.columnspace())
+
+    A = DomainMatrix([[QQ(1), QQ(-1), QQ(1)], [QQ(2), QQ(-2), QQ(3)]], (2, 3), QQ, fmt='sparse')
+    Acol = DomainMatrix({0: {0: QQ(1), 1: QQ(1)}, 1: {0: QQ(2), 1: QQ(3)}}, (2, 2), QQ)
+    assert A.columnspace() == Acol
+
+
+def test_DomainMatrix_rowspace():
+    A = DomainMatrix([[QQ(1), QQ(-1), QQ(1)], [QQ(2), QQ(-2), QQ(3)]], (2, 3), QQ)
+    assert A.rowspace() == A
+
+    Az = DomainMatrix([[ZZ(1), ZZ(-1), ZZ(1)], [ZZ(2), ZZ(-2), ZZ(3)]], (2, 3), ZZ)
+    raises(DMNotAField, lambda: Az.rowspace())
+
+    A = DomainMatrix([[QQ(1), QQ(-1), QQ(1)], [QQ(2), QQ(-2), QQ(3)]], (2, 3), QQ, fmt='sparse')
+    assert A.rowspace() == A
+
+
+def test_DomainMatrix_nullspace():
+    A = DomainMatrix([[QQ(1), QQ(1)], [QQ(1), QQ(1)]], (2, 2), QQ)
+    Anull = DomainMatrix([[QQ(-1), QQ(1)]], (1, 2), QQ)
+    assert A.nullspace() == Anull
+
+    Az = DomainMatrix([[ZZ(1), ZZ(1)], [ZZ(1), ZZ(1)]], (2, 2), ZZ)
+    raises(DMNotAField, lambda: Az.nullspace())
+
+
+def test_DomainMatrix_solve():
+    # XXX: Maybe the _solve method should be changed...
+    A = DomainMatrix([[QQ(1), QQ(2)], [QQ(2), QQ(4)]], (2, 2), QQ)
+    b = DomainMatrix([[QQ(1)], [QQ(2)]], (2, 1), QQ)
+    particular = DomainMatrix([[1, 0]], (1, 2), QQ)
+    nullspace = DomainMatrix([[-2, 1]], (1, 2), QQ)
+    assert A._solve(b) == (particular, nullspace)
+
+    b3 = DomainMatrix([[QQ(1)], [QQ(1)], [QQ(1)]], (3, 1), QQ)
+    raises(DMShapeError, lambda: A._solve(b3))
+
+    bz = DomainMatrix([[ZZ(1)], [ZZ(1)]], (2, 1), ZZ)
+    raises(DMNotAField, lambda: A._solve(bz))
+
+
+def test_DomainMatrix_inv():
+    A = DomainMatrix([], (0, 0), QQ)
+    assert A.inv() == A
+
+    A = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    Ainv = DomainMatrix([[QQ(-2), QQ(1)], [QQ(3, 2), QQ(-1, 2)]], (2, 2), QQ)
+    assert A.inv() == Ainv
+
+    Az = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    raises(DMNotAField, lambda: Az.inv())
+
+    Ans = DomainMatrix([[QQ(1), QQ(2)]], (1, 2), QQ)
+    raises(DMNonSquareMatrixError, lambda: Ans.inv())
+
+    Aninv = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(6)]], (2, 2), QQ)
+    raises(DMNonInvertibleMatrixError, lambda: Aninv.inv())
+
+
+def test_DomainMatrix_det():
+    A = DomainMatrix([], (0, 0), ZZ)
+    assert A.det() == 1
+
+    A = DomainMatrix([[1]], (1, 1), ZZ)
+    assert A.det() == 1
+
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    assert A.det() == ZZ(-2)
+
+    A = DomainMatrix([[ZZ(1), ZZ(2), ZZ(3)], [ZZ(1), ZZ(2), ZZ(4)], [ZZ(1), ZZ(3), ZZ(5)]], (3, 3), ZZ)
+    assert A.det() == ZZ(-1)
+
+    A = DomainMatrix([[ZZ(1), ZZ(2), ZZ(3)], [ZZ(1), ZZ(2), ZZ(4)], [ZZ(1), ZZ(2), ZZ(5)]], (3, 3), ZZ)
+    assert A.det() == ZZ(0)
+
+    Ans = DomainMatrix([[QQ(1), QQ(2)]], (1, 2), QQ)
+    raises(DMNonSquareMatrixError, lambda: Ans.det())
+
+    A = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    assert A.det() == QQ(-2)
+
+
+def test_DomainMatrix_lu():
+    A = DomainMatrix([], (0, 0), QQ)
+    assert A.lu() == (A, A, [])
+
+    A = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    L = DomainMatrix([[QQ(1), QQ(0)], [QQ(3), QQ(1)]], (2, 2), QQ)
+    U = DomainMatrix([[QQ(1), QQ(2)], [QQ(0), QQ(-2)]], (2, 2), QQ)
+    swaps = []
+    assert A.lu() == (L, U, swaps)
+
+    A = DomainMatrix([[QQ(0), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    L = DomainMatrix([[QQ(1), QQ(0)], [QQ(0), QQ(1)]], (2, 2), QQ)
+    U = DomainMatrix([[QQ(3), QQ(4)], [QQ(0), QQ(2)]], (2, 2), QQ)
+    swaps = [(0, 1)]
+    assert A.lu() == (L, U, swaps)
+
+    A = DomainMatrix([[QQ(1), QQ(2)], [QQ(2), QQ(4)]], (2, 2), QQ)
+    L = DomainMatrix([[QQ(1), QQ(0)], [QQ(2), QQ(1)]], (2, 2), QQ)
+    U = DomainMatrix([[QQ(1), QQ(2)], [QQ(0), QQ(0)]], (2, 2), QQ)
+    swaps = []
+    assert A.lu() == (L, U, swaps)
+
+    A = DomainMatrix([[QQ(0), QQ(2)], [QQ(0), QQ(4)]], (2, 2), QQ)
+    L = DomainMatrix([[QQ(1), QQ(0)], [QQ(0), QQ(1)]], (2, 2), QQ)
+    U = DomainMatrix([[QQ(0), QQ(2)], [QQ(0), QQ(4)]], (2, 2), QQ)
+    swaps = []
+    assert A.lu() == (L, U, swaps)
+
+    A = DomainMatrix([[QQ(1), QQ(2), QQ(3)], [QQ(4), QQ(5), QQ(6)]], (2, 3), QQ)
+    L = DomainMatrix([[QQ(1), QQ(0)], [QQ(4), QQ(1)]], (2, 2), QQ)
+    U = DomainMatrix([[QQ(1), QQ(2), QQ(3)], [QQ(0), QQ(-3), QQ(-6)]], (2, 3), QQ)
+    swaps = []
+    assert A.lu() == (L, U, swaps)
+
+    A = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)], [QQ(5), QQ(6)]], (3, 2), QQ)
+    L = DomainMatrix([
+        [QQ(1), QQ(0), QQ(0)],
+        [QQ(3), QQ(1), QQ(0)],
+        [QQ(5), QQ(2), QQ(1)]], (3, 3), QQ)
+    U = DomainMatrix([[QQ(1), QQ(2)], [QQ(0), QQ(-2)], [QQ(0), QQ(0)]], (3, 2), QQ)
+    swaps = []
+    assert A.lu() == (L, U, swaps)
+
+    A = [[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 1, 1], [0, 0, 1, 2]]
+    L = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 1, 1]]
+    U = [[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 1, 1], [0, 0, 0, 1]]
+    to_dom = lambda rows, dom: [[dom(e) for e in row] for row in rows]
+    A = DomainMatrix(to_dom(A, QQ), (4, 4), QQ)
+    L = DomainMatrix(to_dom(L, QQ), (4, 4), QQ)
+    U = DomainMatrix(to_dom(U, QQ), (4, 4), QQ)
+    assert A.lu() == (L, U, [])
+
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    raises(DMNotAField, lambda: A.lu())
+
+
+def test_DomainMatrix_lu_solve():
+    # Base case
+    A = b = x = DomainMatrix([], (0, 0), QQ)
+    assert A.lu_solve(b) == x
+
+    # Basic example
+    A = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    b = DomainMatrix([[QQ(1)], [QQ(2)]], (2, 1), QQ)
+    x = DomainMatrix([[QQ(0)], [QQ(1, 2)]], (2, 1), QQ)
+    assert A.lu_solve(b) == x
+
+    # Example with swaps
+    A = DomainMatrix([[QQ(0), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    b = DomainMatrix([[QQ(1)], [QQ(2)]], (2, 1), QQ)
+    x = DomainMatrix([[QQ(0)], [QQ(1, 2)]], (2, 1), QQ)
+    assert A.lu_solve(b) == x
+
+    # Non-invertible
+    A = DomainMatrix([[QQ(1), QQ(2)], [QQ(2), QQ(4)]], (2, 2), QQ)
+    b = DomainMatrix([[QQ(1)], [QQ(2)]], (2, 1), QQ)
+    raises(DMNonInvertibleMatrixError, lambda: A.lu_solve(b))
+
+    # Overdetermined, consistent
+    A = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)], [QQ(5), QQ(6)]], (3, 2), QQ)
+    b = DomainMatrix([[QQ(1)], [QQ(2)], [QQ(3)]], (3, 1), QQ)
+    x = DomainMatrix([[QQ(0)], [QQ(1, 2)]], (2, 1), QQ)
+    assert A.lu_solve(b) == x
+
+    # Overdetermined, inconsistent
+    A = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)], [QQ(5), QQ(6)]], (3, 2), QQ)
+    b = DomainMatrix([[QQ(1)], [QQ(2)], [QQ(4)]], (3, 1), QQ)
+    raises(DMNonInvertibleMatrixError, lambda: A.lu_solve(b))
+
+    # Underdetermined
+    A = DomainMatrix([[QQ(1), QQ(2)]], (1, 2), QQ)
+    b = DomainMatrix([[QQ(1)]], (1, 1), QQ)
+    raises(NotImplementedError, lambda: A.lu_solve(b))
+
+    # Non-field
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    b = DomainMatrix([[ZZ(1)], [ZZ(2)]], (2, 1), ZZ)
+    raises(DMNotAField, lambda: A.lu_solve(b))
+
+    # Shape mismatch
+    A = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    b = DomainMatrix([[QQ(1), QQ(2)]], (1, 2), QQ)
+    raises(DMShapeError, lambda: A.lu_solve(b))
+
+
+def test_DomainMatrix_charpoly():
+    A = DomainMatrix([], (0, 0), ZZ)
+    assert A.charpoly() == [ZZ(1)]
+
+    A = DomainMatrix([[1]], (1, 1), ZZ)
+    assert A.charpoly() == [ZZ(1), ZZ(-1)]
+
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    assert A.charpoly() == [ZZ(1), ZZ(-5), ZZ(-2)]
+
+    A = DomainMatrix([[ZZ(1), ZZ(2), ZZ(3)], [ZZ(4), ZZ(5), ZZ(6)], [ZZ(7), ZZ(8), ZZ(9)]], (3, 3), ZZ)
+    assert A.charpoly() == [ZZ(1), ZZ(-15), ZZ(-18), ZZ(0)]
+
+    Ans = DomainMatrix([[QQ(1), QQ(2)]], (1, 2), QQ)
+    raises(DMNonSquareMatrixError, lambda: Ans.charpoly())
+
+
+def test_DomainMatrix_eye():
+    A = DomainMatrix.eye(3, QQ)
+    assert A.rep == SDM.eye((3, 3), QQ)
+    assert A.shape == (3, 3)
+    assert A.domain == QQ
+
+
+def test_DomainMatrix_zeros():
+    A = DomainMatrix.zeros((1, 2), QQ)
+    assert A.rep == SDM.zeros((1, 2), QQ)
+    assert A.shape == (1, 2)
+    assert A.domain == QQ
+
+
+def test_DomainMatrix_ones():
+    A = DomainMatrix.ones((2, 3), QQ)
+    assert A.rep == DDM.ones((2, 3), QQ)
+    assert A.shape == (2, 3)
+    assert A.domain == QQ
+
+
+def test_DomainMatrix_diag():
+    A = DomainMatrix({0:{0:ZZ(2)}, 1:{1:ZZ(3)}}, (2, 2), ZZ)
+    assert DomainMatrix.diag([ZZ(2), ZZ(3)], ZZ) == A
+
+    A = DomainMatrix({0:{0:ZZ(2)}, 1:{1:ZZ(3)}}, (3, 4), ZZ)
+    assert DomainMatrix.diag([ZZ(2), ZZ(3)], ZZ, (3, 4)) == A
+
+
+def test_DomainMatrix_hstack():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    B = DomainMatrix([[ZZ(5), ZZ(6)], [ZZ(7), ZZ(8)]], (2, 2), ZZ)
+    C = DomainMatrix([[ZZ(9), ZZ(10)], [ZZ(11), ZZ(12)]], (2, 2), ZZ)
+
+    AB = DomainMatrix([
+        [ZZ(1), ZZ(2), ZZ(5), ZZ(6)],
+        [ZZ(3), ZZ(4), ZZ(7), ZZ(8)]], (2, 4), ZZ)
+    ABC = DomainMatrix([
+        [ZZ(1), ZZ(2), ZZ(5), ZZ(6), ZZ(9), ZZ(10)],
+        [ZZ(3), ZZ(4), ZZ(7), ZZ(8), ZZ(11), ZZ(12)]], (2, 6), ZZ)
+    assert A.hstack(B) == AB
+    assert A.hstack(B, C) == ABC
+
+
+def test_DomainMatrix_vstack():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    B = DomainMatrix([[ZZ(5), ZZ(6)], [ZZ(7), ZZ(8)]], (2, 2), ZZ)
+    C = DomainMatrix([[ZZ(9), ZZ(10)], [ZZ(11), ZZ(12)]], (2, 2), ZZ)
+
+    AB = DomainMatrix([
+        [ZZ(1), ZZ(2)],
+        [ZZ(3), ZZ(4)],
+        [ZZ(5), ZZ(6)],
+        [ZZ(7), ZZ(8)]], (4, 2), ZZ)
+    ABC = DomainMatrix([
+        [ZZ(1), ZZ(2)],
+        [ZZ(3), ZZ(4)],
+        [ZZ(5), ZZ(6)],
+        [ZZ(7), ZZ(8)],
+        [ZZ(9), ZZ(10)],
+        [ZZ(11), ZZ(12)]], (6, 2), ZZ)
+    assert A.vstack(B) == AB
+    assert A.vstack(B, C) == ABC
+
+
+def test_DomainMatrix_applyfunc():
+    A = DomainMatrix([[ZZ(1), ZZ(2)]], (1, 2), ZZ)
+    B = DomainMatrix([[ZZ(2), ZZ(4)]], (1, 2), ZZ)
+    assert A.applyfunc(lambda x: 2*x) == B
+
+
+def test_DomainMatrix_scalarmul():
+    A = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    lamda = DomainScalar(QQ(3)/QQ(2), QQ)
+    assert A * lamda == DomainMatrix([[QQ(3, 2), QQ(3)], [QQ(9, 2), QQ(6)]], (2, 2), QQ)
+    assert A * 2 == DomainMatrix([[ZZ(2), ZZ(4)], [ZZ(6), ZZ(8)]], (2, 2), ZZ)
+    assert 2 * A == DomainMatrix([[ZZ(2), ZZ(4)], [ZZ(6), ZZ(8)]], (2, 2), ZZ)
+    assert A * DomainScalar(ZZ(0), ZZ) == DomainMatrix({}, (2, 2), ZZ)
+    assert A * DomainScalar(ZZ(1), ZZ) == A
+
+    raises(TypeError, lambda: A * 1.5)
+
+
+def test_DomainMatrix_truediv():
+    A = DomainMatrix.from_Matrix(Matrix([[1, 2], [3, 4]]))
+    lamda = DomainScalar(QQ(3)/QQ(2), QQ)
+    assert A / lamda == DomainMatrix({0: {0: QQ(2, 3), 1: QQ(4, 3)}, 1: {0: QQ(2), 1: QQ(8, 3)}}, (2, 2), QQ)
+    b = DomainScalar(ZZ(1), ZZ)
+    assert A / b == DomainMatrix({0: {0: QQ(1), 1: QQ(2)}, 1: {0: QQ(3), 1: QQ(4)}}, (2, 2), QQ)
+
+    assert A / 1 == DomainMatrix({0: {0: QQ(1), 1: QQ(2)}, 1: {0: QQ(3), 1: QQ(4)}}, (2, 2), QQ)
+    assert A / 2 == DomainMatrix({0: {0: QQ(1, 2), 1: QQ(1)}, 1: {0: QQ(3, 2), 1: QQ(2)}}, (2, 2), QQ)
+
+    raises(ZeroDivisionError, lambda: A / 0)
+    raises(TypeError, lambda: A / 1.5)
+    raises(ZeroDivisionError, lambda: A / DomainScalar(ZZ(0), ZZ))
+
+
+def test_DomainMatrix_getitem():
+    dM = DomainMatrix([
+        [ZZ(1), ZZ(2), ZZ(3)],
+        [ZZ(4), ZZ(5), ZZ(6)],
+        [ZZ(7), ZZ(8), ZZ(9)]], (3, 3), ZZ)
+
+    assert dM[1:,:-2] == DomainMatrix([[ZZ(4)], [ZZ(7)]], (2, 1), ZZ)
+    assert dM[2,:-2] == DomainMatrix([[ZZ(7)]], (1, 1), ZZ)
+    assert dM[:-2,:-2] == DomainMatrix([[ZZ(1)]], (1, 1), ZZ)
+    assert dM[:-1,0:2] == DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(4), ZZ(5)]], (2, 2), ZZ)
+    assert dM[:, -1] == DomainMatrix([[ZZ(3)], [ZZ(6)], [ZZ(9)]], (3, 1), ZZ)
+    assert dM[-1, :] == DomainMatrix([[ZZ(7), ZZ(8), ZZ(9)]], (1, 3), ZZ)
+    assert dM[::-1, :] == DomainMatrix([
+                            [ZZ(7), ZZ(8), ZZ(9)],
+                            [ZZ(4), ZZ(5), ZZ(6)],
+                            [ZZ(1), ZZ(2), ZZ(3)]], (3, 3), ZZ)
+
+    raises(IndexError, lambda: dM[4, :-2])
+    raises(IndexError, lambda: dM[:-2, 4])
+
+    assert dM[1, 2] == DomainScalar(ZZ(6), ZZ)
+    assert dM[-2, 2] == DomainScalar(ZZ(6), ZZ)
+    assert dM[1, -2] == DomainScalar(ZZ(5), ZZ)
+    assert dM[-1, -3] == DomainScalar(ZZ(7), ZZ)
+
+    raises(IndexError, lambda: dM[3, 3])
+    raises(IndexError, lambda: dM[1, 4])
+    raises(IndexError, lambda: dM[-1, -4])
+
+    dM = DomainMatrix({0: {0: ZZ(1)}}, (10, 10), ZZ)
+    assert dM[5, 5] == DomainScalar(ZZ(0), ZZ)
+    assert dM[0, 0] == DomainScalar(ZZ(1), ZZ)
+
+    dM = DomainMatrix({1: {0: 1}}, (2,1), ZZ)
+    assert dM[0:, 0] == DomainMatrix({1: {0: 1}}, (2, 1), ZZ)
+    raises(IndexError, lambda: dM[3, 0])
+
+    dM = DomainMatrix({2: {2: ZZ(1)}, 4: {4: ZZ(1)}}, (5, 5), ZZ)
+    assert dM[:2,:2] == DomainMatrix({}, (2, 2), ZZ)
+    assert dM[2:,2:] == DomainMatrix({0: {0: 1}, 2: {2: 1}}, (3, 3), ZZ)
+    assert dM[3:,3:] == DomainMatrix({1: {1: 1}}, (2, 2), ZZ)
+    assert dM[2:, 6:] == DomainMatrix({}, (3, 0), ZZ)
+
+
+def test_DomainMatrix_getitem_sympy():
+    dM = DomainMatrix({2: {2: ZZ(2)}, 4: {4: ZZ(1)}}, (5, 5), ZZ)
+    val1 = dM.getitem_sympy(0, 0)
+    assert val1 is S.Zero
+    val2 = dM.getitem_sympy(2, 2)
+    assert val2 == 2 and isinstance(val2, Integer)
+
+
+def test_DomainMatrix_extract():
+    dM1 = DomainMatrix([
+        [ZZ(1), ZZ(2), ZZ(3)],
+        [ZZ(4), ZZ(5), ZZ(6)],
+        [ZZ(7), ZZ(8), ZZ(9)]], (3, 3), ZZ)
+    dM2 = DomainMatrix([
+        [ZZ(1), ZZ(3)],
+        [ZZ(7), ZZ(9)]], (2, 2), ZZ)
+    assert dM1.extract([0, 2], [0, 2]) == dM2
+    assert dM1.to_sparse().extract([0, 2], [0, 2]) == dM2.to_sparse()
+    assert dM1.extract([0, -1], [0, -1]) == dM2
+    assert dM1.to_sparse().extract([0, -1], [0, -1]) == dM2.to_sparse()
+
+    dM3 = DomainMatrix([
+        [ZZ(1), ZZ(2), ZZ(2)],
+        [ZZ(4), ZZ(5), ZZ(5)],
+        [ZZ(4), ZZ(5), ZZ(5)]], (3, 3), ZZ)
+    assert dM1.extract([0, 1, 1], [0, 1, 1]) == dM3
+    assert dM1.to_sparse().extract([0, 1, 1], [0, 1, 1]) == dM3.to_sparse()
+
+    empty = [
+        ([], [], (0, 0)),
+        ([1], [], (1, 0)),
+        ([], [1], (0, 1)),
+    ]
+    for rows, cols, size in empty:
+        assert dM1.extract(rows, cols) == DomainMatrix.zeros(size, ZZ).to_dense()
+        assert dM1.to_sparse().extract(rows, cols) == DomainMatrix.zeros(size, ZZ)
+
+    dM = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    bad_indices = [([2], [0]), ([0], [2]), ([-3], [0]), ([0], [-3])]
+    for rows, cols in bad_indices:
+        raises(IndexError, lambda: dM.extract(rows, cols))
+        raises(IndexError, lambda: dM.to_sparse().extract(rows, cols))
+
+
+def test_DomainMatrix_setitem():
+    dM = DomainMatrix({2: {2: ZZ(1)}, 4: {4: ZZ(1)}}, (5, 5), ZZ)
+    dM[2, 2] = ZZ(2)
+    assert dM == DomainMatrix({2: {2: ZZ(2)}, 4: {4: ZZ(1)}}, (5, 5), ZZ)
+    def setitem(i, j, val):
+        dM[i, j] = val
+    raises(TypeError, lambda: setitem(2, 2, QQ(1, 2)))
+    raises(NotImplementedError, lambda: setitem(slice(1, 2), 2, ZZ(1)))
+
+
+def test_DomainMatrix_pickling():
+    import pickle
+    dM = DomainMatrix({2: {2: ZZ(1)}, 4: {4: ZZ(1)}}, (5, 5), ZZ)
+    assert pickle.loads(pickle.dumps(dM)) == dM
+    dM = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    assert pickle.loads(pickle.dumps(dM)) == dM

llmeval-env/lib/python3.10/site-packages/sympy/polys/matrices/tests/test_domainscalar.py

@@ -0,0 +1,147 @@
+from sympy.testing.pytest import raises
+
+from sympy.core.symbol import S
+from sympy.polys import ZZ, QQ
+from sympy.polys.matrices.domainscalar import DomainScalar
+from sympy.polys.matrices.domainmatrix import DomainMatrix
+
+
+def test_DomainScalar___new__():
+    raises(TypeError, lambda: DomainScalar(ZZ(1), QQ))
+    raises(TypeError, lambda: DomainScalar(ZZ(1), 1))
+
+
+def test_DomainScalar_new():
+    A = DomainScalar(ZZ(1), ZZ)
+    B = A.new(ZZ(4), ZZ)
+    assert B == DomainScalar(ZZ(4), ZZ)
+
+
+def test_DomainScalar_repr():
+    A = DomainScalar(ZZ(1), ZZ)
+    assert repr(A) in {'1', 'mpz(1)'}
+
+
+def test_DomainScalar_from_sympy():
+    expr = S(1)
+    B = DomainScalar.from_sympy(expr)
+    assert B == DomainScalar(ZZ(1), ZZ)
+
+
+def test_DomainScalar_to_sympy():
+    B = DomainScalar(ZZ(1), ZZ)
+    expr = B.to_sympy()
+    assert expr.is_Integer and expr == 1
+
+
+def test_DomainScalar_to_domain():
+    A = DomainScalar(ZZ(1), ZZ)
+    B = A.to_domain(QQ)
+    assert B == DomainScalar(QQ(1), QQ)
+
+
+def test_DomainScalar_convert_to():
+    A = DomainScalar(ZZ(1), ZZ)
+    B = A.convert_to(QQ)
+    assert B == DomainScalar(QQ(1), QQ)
+
+
+def test_DomainScalar_unify():
+    A = DomainScalar(ZZ(1), ZZ)
+    B = DomainScalar(QQ(2), QQ)
+    A, B = A.unify(B)
+    assert A.domain == B.domain == QQ
+
+
+def test_DomainScalar_add():
+    A = DomainScalar(ZZ(1), ZZ)
+    B = DomainScalar(QQ(2), QQ)
+    assert A + B == DomainScalar(QQ(3), QQ)
+
+    raises(TypeError, lambda: A + 1.5)
+
+def test_DomainScalar_sub():
+    A = DomainScalar(ZZ(1), ZZ)
+    B = DomainScalar(QQ(2), QQ)
+    assert A - B == DomainScalar(QQ(-1), QQ)
+
+    raises(TypeError, lambda: A - 1.5)
+
+def test_DomainScalar_mul():
+    A = DomainScalar(ZZ(1), ZZ)
+    B = DomainScalar(QQ(2), QQ)
+    dm = DomainMatrix([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    assert A * B == DomainScalar(QQ(2), QQ)
+    assert A * dm == dm
+    assert B * 2 == DomainScalar(QQ(4), QQ)
+
+    raises(TypeError, lambda: A * 1.5)
+
+
+def test_DomainScalar_floordiv():
+    A = DomainScalar(ZZ(-5), ZZ)
+    B = DomainScalar(QQ(2), QQ)
+    assert A // B == DomainScalar(QQ(-5, 2), QQ)
+    C = DomainScalar(ZZ(2), ZZ)
+    assert A // C == DomainScalar(ZZ(-3), ZZ)
+
+    raises(TypeError, lambda: A // 1.5)
+
+
+def test_DomainScalar_mod():
+    A = DomainScalar(ZZ(5), ZZ)
+    B = DomainScalar(QQ(2), QQ)
+    assert A % B == DomainScalar(QQ(0), QQ)
+    C = DomainScalar(ZZ(2), ZZ)
+    assert A % C == DomainScalar(ZZ(1), ZZ)
+
+    raises(TypeError, lambda: A % 1.5)
+
+
+def test_DomainScalar_divmod():
+    A = DomainScalar(ZZ(5), ZZ)
+    B = DomainScalar(QQ(2), QQ)
+    assert divmod(A, B) == (DomainScalar(QQ(5, 2), QQ), DomainScalar(QQ(0), QQ))
+    C = DomainScalar(ZZ(2), ZZ)
+    assert divmod(A, C) == (DomainScalar(ZZ(2), ZZ), DomainScalar(ZZ(1), ZZ))
+
+    raises(TypeError, lambda: divmod(A, 1.5))
+
+
+def test_DomainScalar_pow():
+    A = DomainScalar(ZZ(-5), ZZ)
+    B = A**(2)
+    assert B == DomainScalar(ZZ(25), ZZ)
+
+    raises(TypeError, lambda: A**(1.5))
+
+
+def test_DomainScalar_pos():
+    A = DomainScalar(QQ(2), QQ)
+    B = DomainScalar(QQ(2), QQ)
+    assert  +A == B
+
+
+def test_DomainScalar_eq():
+    A = DomainScalar(QQ(2), QQ)
+    assert A == A
+    B = DomainScalar(ZZ(-5), ZZ)
+    assert A != B
+    C = DomainScalar(ZZ(2), ZZ)
+    assert A != C
+    D = [1]
+    assert A != D
+
+
+def test_DomainScalar_isZero():
+    A = DomainScalar(ZZ(0), ZZ)
+    assert A.is_zero() == True
+    B = DomainScalar(ZZ(1), ZZ)
+    assert B.is_zero() == False
+
+
+def test_DomainScalar_isOne():
+    A = DomainScalar(ZZ(1), ZZ)
+    assert A.is_one() == True
+    B = DomainScalar(ZZ(0), ZZ)
+    assert B.is_one() == False

llmeval-env/lib/python3.10/site-packages/sympy/polys/matrices/tests/test_eigen.py

@@ -0,0 +1,90 @@
+"""
+Tests for the sympy.polys.matrices.eigen module
+"""
+
+from sympy.core.singleton import S
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.matrices.dense import Matrix
+
+from sympy.polys.agca.extensions import FiniteExtension
+from sympy.polys.domains import QQ
+from sympy.polys.polytools import Poly
+from sympy.polys.rootoftools import CRootOf
+from sympy.polys.matrices.domainmatrix import DomainMatrix
+
+from sympy.polys.matrices.eigen import dom_eigenvects, dom_eigenvects_to_sympy
+
+
+def test_dom_eigenvects_rational():
+    # Rational eigenvalues
+    A = DomainMatrix([[QQ(1), QQ(2)], [QQ(1), QQ(2)]], (2, 2), QQ)
+    rational_eigenvects = [
+        (QQ, QQ(3), 1, DomainMatrix([[QQ(1), QQ(1)]], (1, 2), QQ)),
+        (QQ, QQ(0), 1, DomainMatrix([[QQ(-2), QQ(1)]], (1, 2), QQ)),
+    ]
+    assert dom_eigenvects(A) == (rational_eigenvects, [])
+
+    # Test converting to Expr:
+    sympy_eigenvects = [
+        (S(3), 1, [Matrix([1, 1])]),
+        (S(0), 1, [Matrix([-2, 1])]),
+    ]
+    assert dom_eigenvects_to_sympy(rational_eigenvects, [], Matrix) == sympy_eigenvects
+
+
+def test_dom_eigenvects_algebraic():
+    # Algebraic eigenvalues
+    A = DomainMatrix([[QQ(1), QQ(2)], [QQ(3), QQ(4)]], (2, 2), QQ)
+    Avects = dom_eigenvects(A)
+
+    # Extract the dummy to build the expected result:
+    lamda = Avects[1][0][1].gens[0]
+    irreducible = Poly(lamda**2 - 5*lamda - 2, lamda, domain=QQ)
+    K = FiniteExtension(irreducible)
+    KK = K.from_sympy
+    algebraic_eigenvects = [
+        (K, irreducible, 1, DomainMatrix([[KK((lamda-4)/3), KK(1)]], (1, 2), K)),
+    ]
+    assert Avects == ([], algebraic_eigenvects)
+
+    # Test converting to Expr:
+    sympy_eigenvects = [
+        (S(5)/2 - sqrt(33)/2, 1, [Matrix([[-sqrt(33)/6 - S(1)/2], [1]])]),
+        (S(5)/2 + sqrt(33)/2, 1, [Matrix([[-S(1)/2 + sqrt(33)/6], [1]])]),
+    ]
+    assert dom_eigenvects_to_sympy([], algebraic_eigenvects, Matrix) == sympy_eigenvects
+
+
+def test_dom_eigenvects_rootof():
+    # Algebraic eigenvalues
+    A = DomainMatrix([
+        [0, 0, 0, 0, -1],
+        [1, 0, 0, 0, 1],
+        [0, 1, 0, 0, 0],
+        [0, 0, 1, 0, 0],
+        [0, 0, 0, 1, 0]], (5, 5), QQ)
+    Avects = dom_eigenvects(A)
+
+    # Extract the dummy to build the expected result:
+    lamda = Avects[1][0][1].gens[0]
+    irreducible = Poly(lamda**5 - lamda + 1, lamda, domain=QQ)
+    K = FiniteExtension(irreducible)
+    KK = K.from_sympy
+    algebraic_eigenvects = [
+        (K, irreducible, 1,
+            DomainMatrix([
+                [KK(lamda**4-1), KK(lamda**3), KK(lamda**2), KK(lamda), KK(1)]
+            ], (1, 5), K)),
+    ]
+    assert Avects == ([], algebraic_eigenvects)
+
+    # Test converting to Expr (slow):
+    l0, l1, l2, l3, l4 = [CRootOf(lamda**5 - lamda + 1, i) for i in range(5)]
+    sympy_eigenvects = [
+        (l0, 1, [Matrix([-1 + l0**4, l0**3, l0**2, l0, 1])]),
+        (l1, 1, [Matrix([-1 + l1**4, l1**3, l1**2, l1, 1])]),
+        (l2, 1, [Matrix([-1 + l2**4, l2**3, l2**2, l2, 1])]),
+        (l3, 1, [Matrix([-1 + l3**4, l3**3, l3**2, l3, 1])]),
+        (l4, 1, [Matrix([-1 + l4**4, l4**3, l4**2, l4, 1])]),
+    ]
+    assert dom_eigenvects_to_sympy([], algebraic_eigenvects, Matrix) == sympy_eigenvects

llmeval-env/lib/python3.10/site-packages/sympy/polys/matrices/tests/test_linsolve.py

@@ -0,0 +1,111 @@
+#
+# test_linsolve.py
+#
+#    Test the internal implementation of linsolve.
+#
+
+from sympy.testing.pytest import raises
+
+from sympy.core.numbers import I
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.abc import x, y, z
+
+from sympy.polys.matrices.linsolve import _linsolve
+from sympy.polys.solvers import PolyNonlinearError
+
+
+def test__linsolve():
+    assert _linsolve([], [x]) == {x:x}
+    assert _linsolve([S.Zero], [x]) == {x:x}
+    assert _linsolve([x-1,x-2], [x]) is None
+    assert _linsolve([x-1], [x]) == {x:1}
+    assert _linsolve([x-1, y], [x, y]) == {x:1, y:S.Zero}
+    assert _linsolve([2*I], [x]) is None
+    raises(PolyNonlinearError, lambda: _linsolve([x*(1 + x)], [x]))
+
+
+def test__linsolve_float():
+
+    # This should give the exact answer:
+    eqs = [
+        y - x,
+        y - 0.0216 * x
+    ]
+    sol = {x:0.0, y:0.0}
+    assert _linsolve(eqs, (x, y)) == sol
+
+    # Other cases should be close to eps
+
+    def all_close(sol1, sol2, eps=1e-15):
+        close = lambda a, b: abs(a - b) < eps
+        assert sol1.keys() == sol2.keys()
+        return all(close(sol1[s], sol2[s]) for s in sol1)
+
+    eqs = [
+        0.8*x +         0.8*z + 0.2,
+        0.9*x + 0.7*y + 0.2*z + 0.9,
+        0.7*x + 0.2*y + 0.2*z + 0.5
+    ]
+    sol_exact = {x:-29/42, y:-11/21, z:37/84}
+    sol_linsolve = _linsolve(eqs, [x,y,z])
+    assert all_close(sol_exact, sol_linsolve)
+
+    eqs = [
+        0.9*x + 0.3*y + 0.4*z + 0.6,
+        0.6*x + 0.9*y + 0.1*z + 0.7,
+        0.4*x + 0.6*y + 0.9*z + 0.5
+    ]
+    sol_exact = {x:-88/175, y:-46/105, z:-1/25}
+    sol_linsolve = _linsolve(eqs, [x,y,z])
+    assert all_close(sol_exact, sol_linsolve)
+
+    eqs = [
+        0.4*x + 0.3*y + 0.6*z + 0.7,
+        0.4*x + 0.3*y + 0.9*z + 0.9,
+        0.7*x + 0.9*y,
+    ]
+    sol_exact = {x:-9/5, y:7/5, z:-2/3}
+    sol_linsolve = _linsolve(eqs, [x,y,z])
+    assert all_close(sol_exact, sol_linsolve)
+
+    eqs = [
+        x*(0.7 + 0.6*I) + y*(0.4 + 0.7*I) + z*(0.9 + 0.1*I) + 0.5,
+        0.2*I*x + 0.2*I*y + z*(0.9 + 0.2*I) + 0.1,
+        x*(0.9 + 0.7*I) + y*(0.9 + 0.7*I) + z*(0.9 + 0.4*I) + 0.4,
+    ]
+    sol_exact = {
+        x:-6157/7995 - 411/5330*I,
+        y:8519/15990 + 1784/7995*I,
+        z:-34/533 + 107/1599*I,
+    }
+    sol_linsolve = _linsolve(eqs, [x,y,z])
+    assert all_close(sol_exact, sol_linsolve)
+
+    # XXX: This system for x and y over RR(z) is problematic.
+    #
+    # eqs = [
+    #     x*(0.2*z + 0.9) + y*(0.5*z + 0.8) + 0.6,
+    #     0.1*x*z + y*(0.1*z + 0.6) + 0.9,
+    # ]
+    #
+    # linsolve(eqs, [x, y])
+    # The solution for x comes out as
+    #
+    #       -3.9e-5*z**2 - 3.6e-5*z - 8.67361737988404e-20
+    #  x =  ----------------------------------------------
+    #           3.0e-6*z**3 - 1.3e-5*z**2 - 5.4e-5*z
+    #
+    # The 8e-20 in the numerator should be zero which would allow z to cancel
+    # from top and bottom. It should be possible to avoid this somehow because
+    # the inverse of the matrix only has a quadratic factor (the determinant)
+    # in the denominator.
+
+
+def test__linsolve_deprecated():
+    raises(PolyNonlinearError, lambda:
+        _linsolve([Eq(x**2, x**2 + y)], [x, y]))
+    raises(PolyNonlinearError, lambda:
+        _linsolve([(x + y)**2 - x**2], [x]))
+    raises(PolyNonlinearError, lambda:
+        _linsolve([Eq((x + y)**2, x**2)], [x]))

llmeval-env/lib/python3.10/site-packages/sympy/polys/matrices/tests/test_lll.py

@@ -0,0 +1,145 @@
+from sympy.polys.domains import ZZ, QQ
+from sympy.polys.matrices import DM
+from sympy.polys.matrices.domainmatrix import DomainMatrix
+from sympy.polys.matrices.exceptions import DMRankError, DMValueError, DMShapeError, DMDomainError
+from sympy.polys.matrices.lll import _ddm_lll, ddm_lll, ddm_lll_transform
+from sympy.testing.pytest import raises
+
+
+def test_lll():
+    normal_test_data = [
+        (
+            DM([[1, 0, 0, 0, -20160],
+                [0, 1, 0, 0, 33768],
+                [0, 0, 1, 0, 39578],
+                [0, 0, 0, 1, 47757]], ZZ),
+            DM([[10, -3, -2, 8, -4],
+                [3, -9, 8, 1, -11],
+                [-3, 13, -9, -3, -9],
+                [-12, -7, -11, 9, -1]], ZZ)
+        ),
+        (
+            DM([[20, 52, 3456],
+                [14, 31, -1],
+                [34, -442, 0]], ZZ),
+            DM([[14, 31, -1],
+                [188, -101, -11],
+                [236, 13, 3443]], ZZ)
+        ),
+        (
+            DM([[34, -1, -86, 12],
+                [-54, 34, 55, 678],
+                [23, 3498, 234, 6783],
+                [87, 49, 665, 11]], ZZ),
+            DM([[34, -1, -86, 12],
+                [291, 43, 149, 83],
+                [-54, 34, 55, 678],
+                [-189, 3077, -184, -223]], ZZ)
+        )
+    ]
+    delta = QQ(5, 6)
+    for basis_dm, reduced_dm in normal_test_data:
+        reduced = _ddm_lll(basis_dm.rep, delta=delta)[0]
+        assert reduced == reduced_dm.rep
+
+        reduced = ddm_lll(basis_dm.rep, delta=delta)
+        assert reduced == reduced_dm.rep
+
+        reduced, transform = _ddm_lll(basis_dm.rep, delta=delta, return_transform=True)
+        assert reduced == reduced_dm.rep
+        assert transform.matmul(basis_dm.rep) == reduced_dm.rep
+
+        reduced, transform = ddm_lll_transform(basis_dm.rep, delta=delta)
+        assert reduced == reduced_dm.rep
+        assert transform.matmul(basis_dm.rep) == reduced_dm.rep
+
+        reduced = basis_dm.rep.lll(delta=delta)
+        assert reduced == reduced_dm.rep
+
+        reduced, transform = basis_dm.rep.lll_transform(delta=delta)
+        assert reduced == reduced_dm.rep
+        assert transform.matmul(basis_dm.rep) == reduced_dm.rep
+
+        reduced = basis_dm.rep.to_sdm().lll(delta=delta)
+        assert reduced == reduced_dm.rep.to_sdm()
+
+        reduced, transform = basis_dm.rep.to_sdm().lll_transform(delta=delta)
+        assert reduced == reduced_dm.rep.to_sdm()
+        assert transform.matmul(basis_dm.rep.to_sdm()) == reduced_dm.rep.to_sdm()
+
+        reduced = basis_dm.lll(delta=delta)
+        assert reduced == reduced_dm
+
+        reduced, transform = basis_dm.lll_transform(delta=delta)
+        assert reduced == reduced_dm
+        assert transform.matmul(basis_dm) == reduced_dm
+
+
+def test_lll_linear_dependent():
+    linear_dependent_test_data = [
+        DM([[0, -1, -2, -3],
+            [1, 0, -1, -2],
+            [2, 1, 0, -1],
+            [3, 2, 1, 0]], ZZ),
+        DM([[1, 0, 0, 1],
+            [0, 1, 0, 1],
+            [0, 0, 1, 1],
+            [1, 2, 3, 6]], ZZ),
+        DM([[3, -5, 1],
+            [4, 6, 0],
+            [10, -4, 2]], ZZ)
+    ]
+    for not_basis in linear_dependent_test_data:
+        raises(DMRankError, lambda: _ddm_lll(not_basis.rep))
+        raises(DMRankError, lambda: ddm_lll(not_basis.rep))
+        raises(DMRankError, lambda: not_basis.rep.lll())
+        raises(DMRankError, lambda: not_basis.rep.to_sdm().lll())
+        raises(DMRankError, lambda: not_basis.lll())
+        raises(DMRankError, lambda: _ddm_lll(not_basis.rep, return_transform=True))
+        raises(DMRankError, lambda: ddm_lll_transform(not_basis.rep))
+        raises(DMRankError, lambda: not_basis.rep.lll_transform())
+        raises(DMRankError, lambda: not_basis.rep.to_sdm().lll_transform())
+        raises(DMRankError, lambda: not_basis.lll_transform())
+
+
+def test_lll_wrong_delta():
+    dummy_matrix = DomainMatrix.ones((3, 3), ZZ)
+    for wrong_delta in [QQ(-1, 4), QQ(0, 1), QQ(1, 4), QQ(1, 1), QQ(100, 1)]:
+        raises(DMValueError, lambda: _ddm_lll(dummy_matrix.rep, delta=wrong_delta))
+        raises(DMValueError, lambda: ddm_lll(dummy_matrix.rep, delta=wrong_delta))
+        raises(DMValueError, lambda: dummy_matrix.rep.lll(delta=wrong_delta))
+        raises(DMValueError, lambda: dummy_matrix.rep.to_sdm().lll(delta=wrong_delta))
+        raises(DMValueError, lambda: dummy_matrix.lll(delta=wrong_delta))
+        raises(DMValueError, lambda: _ddm_lll(dummy_matrix.rep, delta=wrong_delta, return_transform=True))
+        raises(DMValueError, lambda: ddm_lll_transform(dummy_matrix.rep, delta=wrong_delta))
+        raises(DMValueError, lambda: dummy_matrix.rep.lll_transform(delta=wrong_delta))
+        raises(DMValueError, lambda: dummy_matrix.rep.to_sdm().lll_transform(delta=wrong_delta))
+        raises(DMValueError, lambda: dummy_matrix.lll_transform(delta=wrong_delta))
+
+
+def test_lll_wrong_shape():
+    wrong_shape_matrix = DomainMatrix.ones((4, 3), ZZ)
+    raises(DMShapeError, lambda: _ddm_lll(wrong_shape_matrix.rep))
+    raises(DMShapeError, lambda: ddm_lll(wrong_shape_matrix.rep))
+    raises(DMShapeError, lambda: wrong_shape_matrix.rep.lll())
+    raises(DMShapeError, lambda: wrong_shape_matrix.rep.to_sdm().lll())
+    raises(DMShapeError, lambda: wrong_shape_matrix.lll())
+    raises(DMShapeError, lambda: _ddm_lll(wrong_shape_matrix.rep, return_transform=True))
+    raises(DMShapeError, lambda: ddm_lll_transform(wrong_shape_matrix.rep))
+    raises(DMShapeError, lambda: wrong_shape_matrix.rep.lll_transform())
+    raises(DMShapeError, lambda: wrong_shape_matrix.rep.to_sdm().lll_transform())
+    raises(DMShapeError, lambda: wrong_shape_matrix.lll_transform())
+
+
+def test_lll_wrong_domain():
+    wrong_domain_matrix = DomainMatrix.ones((3, 3), QQ)
+    raises(DMDomainError, lambda: _ddm_lll(wrong_domain_matrix.rep))
+    raises(DMDomainError, lambda: ddm_lll(wrong_domain_matrix.rep))
+    raises(DMDomainError, lambda: wrong_domain_matrix.rep.lll())
+    raises(DMDomainError, lambda: wrong_domain_matrix.rep.to_sdm().lll())
+    raises(DMDomainError, lambda: wrong_domain_matrix.lll())
+    raises(DMDomainError, lambda: _ddm_lll(wrong_domain_matrix.rep, return_transform=True))
+    raises(DMDomainError, lambda: ddm_lll_transform(wrong_domain_matrix.rep))
+    raises(DMDomainError, lambda: wrong_domain_matrix.rep.lll_transform())
+    raises(DMDomainError, lambda: wrong_domain_matrix.rep.to_sdm().lll_transform())
+    raises(DMDomainError, lambda: wrong_domain_matrix.lll_transform())

llmeval-env/lib/python3.10/site-packages/sympy/polys/matrices/tests/test_normalforms.py

@@ -0,0 +1,75 @@
+from sympy.testing.pytest import raises
+
+from sympy.core.symbol import Symbol
+from sympy.polys.matrices.normalforms import (
+    invariant_factors, smith_normal_form,
+    hermite_normal_form, _hermite_normal_form, _hermite_normal_form_modulo_D)
+from sympy.polys.domains import ZZ, QQ
+from sympy.polys.matrices import DomainMatrix, DM
+from sympy.polys.matrices.exceptions import DMDomainError, DMShapeError
+
+
+def test_smith_normal():
+
+    m = DM([[12, 6, 4, 8], [3, 9, 6, 12], [2, 16, 14, 28], [20, 10, 10, 20]], ZZ)
+    smf = DM([[1, 0, 0, 0], [0, 10, 0, 0], [0, 0, -30, 0], [0, 0, 0, 0]], ZZ)
+    assert smith_normal_form(m).to_dense() == smf
+
+    x = Symbol('x')
+    m = DM([[x-1,  1, -1],
+            [  0,  x, -1],
+            [  0, -1,  x]], QQ[x])
+    dx = m.domain.gens[0]
+    assert invariant_factors(m) == (1, dx-1, dx**2-1)
+
+    zr = DomainMatrix([], (0, 2), ZZ)
+    zc = DomainMatrix([[], []], (2, 0), ZZ)
+    assert smith_normal_form(zr).to_dense() == zr
+    assert smith_normal_form(zc).to_dense() == zc
+
+    assert smith_normal_form(DM([[2, 4]], ZZ)).to_dense() == DM([[2, 0]], ZZ)
+    assert smith_normal_form(DM([[0, -2]], ZZ)).to_dense() == DM([[-2, 0]], ZZ)
+    assert smith_normal_form(DM([[0], [-2]], ZZ)).to_dense() == DM([[-2], [0]], ZZ)
+
+    m =   DM([[3, 0, 0, 0], [0, 0, 0, 0], [0, 0, 2, 0]], ZZ)
+    snf = DM([[1, 0, 0, 0], [0, 6, 0, 0], [0, 0, 0, 0]], ZZ)
+    assert smith_normal_form(m).to_dense() == snf
+
+    raises(ValueError, lambda: smith_normal_form(DM([[1]], ZZ[x])))
+
+
+def test_hermite_normal():
+    m = DM([[2, 7, 17, 29, 41], [3, 11, 19, 31, 43], [5, 13, 23, 37, 47]], ZZ)
+    hnf = DM([[1, 0, 0], [0, 2, 1], [0, 0, 1]], ZZ)
+    assert hermite_normal_form(m) == hnf
+    assert hermite_normal_form(m, D=ZZ(2)) == hnf
+    assert hermite_normal_form(m, D=ZZ(2), check_rank=True) == hnf
+
+    m = m.transpose()
+    hnf = DM([[37, 0, 19], [222, -6, 113], [48, 0, 25], [0, 2, 1], [0, 0, 1]], ZZ)
+    assert hermite_normal_form(m) == hnf
+    raises(DMShapeError, lambda: _hermite_normal_form_modulo_D(m, ZZ(96)))
+    raises(DMDomainError, lambda: _hermite_normal_form_modulo_D(m, QQ(96)))
+
+    m = DM([[8, 28, 68, 116, 164], [3, 11, 19, 31, 43], [5, 13, 23, 37, 47]], ZZ)
+    hnf = DM([[4, 0, 0], [0, 2, 1], [0, 0, 1]], ZZ)
+    assert hermite_normal_form(m) == hnf
+    assert hermite_normal_form(m, D=ZZ(8)) == hnf
+    assert hermite_normal_form(m, D=ZZ(8), check_rank=True) == hnf
+
+    m = DM([[10, 8, 6, 30, 2], [45, 36, 27, 18, 9], [5, 4, 3, 2, 1]], ZZ)
+    hnf = DM([[26, 2], [0, 9], [0, 1]], ZZ)
+    assert hermite_normal_form(m) == hnf
+
+    m = DM([[2, 7], [0, 0], [0, 0]], ZZ)
+    hnf = DM([[1], [0], [0]], ZZ)
+    assert hermite_normal_form(m) == hnf
+
+    m = DM([[-2, 1], [0, 1]], ZZ)
+    hnf = DM([[2, 1], [0, 1]], ZZ)
+    assert hermite_normal_form(m) == hnf
+
+    m = DomainMatrix([[QQ(1)]], (1, 1), QQ)
+    raises(DMDomainError, lambda: hermite_normal_form(m))
+    raises(DMDomainError, lambda: _hermite_normal_form(m))
+    raises(DMDomainError, lambda: _hermite_normal_form_modulo_D(m, ZZ(1)))

llmeval-env/lib/python3.10/site-packages/sympy/polys/matrices/tests/test_sdm.py

@@ -0,0 +1,444 @@
+"""
+Tests for the basic functionality of the SDM class.
+"""
+
+from itertools import product
+
+from sympy.core.singleton import S
+from sympy.external.gmpy import HAS_GMPY
+from sympy.testing.pytest import raises
+
+from sympy.polys.domains import QQ, ZZ, EXRAW
+from sympy.polys.matrices.sdm import SDM
+from sympy.polys.matrices.ddm import DDM
+from sympy.polys.matrices.exceptions import (DMBadInputError, DMDomainError,
+                                             DMShapeError)
+
+
+def test_SDM():
+    A = SDM({0:{0:ZZ(1)}}, (2, 2), ZZ)
+    assert A.domain == ZZ
+    assert A.shape == (2, 2)
+    assert dict(A) == {0:{0:ZZ(1)}}
+
+    raises(DMBadInputError, lambda: SDM({5:{1:ZZ(0)}}, (2, 2), ZZ))
+    raises(DMBadInputError, lambda: SDM({0:{5:ZZ(0)}}, (2, 2), ZZ))
+
+
+def test_DDM_str():
+    sdm = SDM({0:{0:ZZ(1)}, 1:{1:ZZ(1)}}, (2, 2), ZZ)
+    assert str(sdm) == '{0: {0: 1}, 1: {1: 1}}'
+    if HAS_GMPY: # pragma: no cover
+        assert repr(sdm) == 'SDM({0: {0: mpz(1)}, 1: {1: mpz(1)}}, (2, 2), ZZ)'
+    else:        # pragma: no cover
+        assert repr(sdm) == 'SDM({0: {0: 1}, 1: {1: 1}}, (2, 2), ZZ)'
+
+
+def test_SDM_new():
+    A = SDM({0:{0:ZZ(1)}}, (2, 2), ZZ)
+    B = A.new({}, (2, 2), ZZ)
+    assert B == SDM({}, (2, 2), ZZ)
+
+
+def test_SDM_copy():
+    A = SDM({0:{0:ZZ(1)}}, (2, 2), ZZ)
+    B = A.copy()
+    assert A == B
+    A[0][0] = ZZ(2)
+    assert A != B
+
+
+def test_SDM_from_list():
+    A = SDM.from_list([[ZZ(0), ZZ(1)], [ZZ(1), ZZ(0)]], (2, 2), ZZ)
+    assert A == SDM({0:{1:ZZ(1)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
+
+    raises(DMBadInputError, lambda: SDM.from_list([[ZZ(0)], [ZZ(0), ZZ(1)]], (2, 2), ZZ))
+    raises(DMBadInputError, lambda: SDM.from_list([[ZZ(0), ZZ(1)]], (2, 2), ZZ))
+
+
+def test_SDM_to_list():
+    A = SDM({0:{1: ZZ(1)}}, (2, 2), ZZ)
+    assert A.to_list() == [[ZZ(0), ZZ(1)], [ZZ(0), ZZ(0)]]
+
+    A = SDM({}, (0, 2), ZZ)
+    assert A.to_list() == []
+
+    A = SDM({}, (2, 0), ZZ)
+    assert A.to_list() == [[], []]
+
+
+def test_SDM_to_list_flat():
+    A = SDM({0:{1: ZZ(1)}}, (2, 2), ZZ)
+    assert A.to_list_flat() == [ZZ(0), ZZ(1), ZZ(0), ZZ(0)]
+
+
+def test_SDM_to_dok():
+    A = SDM({0:{1: ZZ(1)}}, (2, 2), ZZ)
+    assert A.to_dok() == {(0, 1): ZZ(1)}
+
+
+def test_SDM_from_ddm():
+    A = DDM([[ZZ(1), ZZ(0)], [ZZ(1), ZZ(0)]], (2, 2), ZZ)
+    B = SDM.from_ddm(A)
+    assert B.domain == ZZ
+    assert B.shape == (2, 2)
+    assert dict(B) == {0:{0:ZZ(1)}, 1:{0:ZZ(1)}}
+
+
+def test_SDM_to_ddm():
+    A = SDM({0:{1: ZZ(1)}}, (2, 2), ZZ)
+    B = DDM([[ZZ(0), ZZ(1)], [ZZ(0), ZZ(0)]], (2, 2), ZZ)
+    assert A.to_ddm() == B
+
+
+def test_SDM_to_sdm():
+    A = SDM({0:{1: ZZ(1)}}, (2, 2), ZZ)
+    assert A.to_sdm() == A
+
+
+def test_SDM_getitem():
+    A = SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    assert A.getitem(0, 0) == ZZ.zero
+    assert A.getitem(0, 1) == ZZ.one
+    assert A.getitem(1, 0) == ZZ.zero
+    assert A.getitem(-2, -2) == ZZ.zero
+    assert A.getitem(-2, -1) == ZZ.one
+    assert A.getitem(-1, -2) == ZZ.zero
+    raises(IndexError, lambda: A.getitem(2, 0))
+    raises(IndexError, lambda: A.getitem(0, 2))
+
+
+def test_SDM_setitem():
+    A = SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    A.setitem(0, 0, ZZ(1))
+    assert A == SDM({0:{0:ZZ(1), 1:ZZ(1)}}, (2, 2), ZZ)
+    A.setitem(1, 0, ZZ(1))
+    assert A == SDM({0:{0:ZZ(1), 1:ZZ(1)}, 1:{0:ZZ(1)}}, (2, 2), ZZ)
+    A.setitem(1, 0, ZZ(0))
+    assert A == SDM({0:{0:ZZ(1), 1:ZZ(1)}}, (2, 2), ZZ)
+    # Repeat the above test so that this time the row is empty
+    A.setitem(1, 0, ZZ(0))
+    assert A == SDM({0:{0:ZZ(1), 1:ZZ(1)}}, (2, 2), ZZ)
+    A.setitem(0, 0, ZZ(0))
+    assert A == SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    # This time the row is there but column is empty
+    A.setitem(0, 0, ZZ(0))
+    assert A == SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    raises(IndexError, lambda: A.setitem(2, 0, ZZ(1)))
+    raises(IndexError, lambda: A.setitem(0, 2, ZZ(1)))
+
+
+def test_SDM_extract_slice():
+    A = SDM({0:{0:ZZ(1), 1:ZZ(2)}, 1:{0:ZZ(3), 1:ZZ(4)}}, (2, 2), ZZ)
+    B = A.extract_slice(slice(1, 2), slice(1, 2))
+    assert B == SDM({0:{0:ZZ(4)}}, (1, 1), ZZ)
+
+
+def test_SDM_extract():
+    A = SDM({0:{0:ZZ(1), 1:ZZ(2)}, 1:{0:ZZ(3), 1:ZZ(4)}}, (2, 2), ZZ)
+    B = A.extract([1], [1])
+    assert B == SDM({0:{0:ZZ(4)}}, (1, 1), ZZ)
+    B = A.extract([1, 0], [1, 0])
+    assert B == SDM({0:{0:ZZ(4), 1:ZZ(3)}, 1:{0:ZZ(2), 1:ZZ(1)}}, (2, 2), ZZ)
+    B = A.extract([1, 1], [1, 1])
+    assert B == SDM({0:{0:ZZ(4), 1:ZZ(4)}, 1:{0:ZZ(4), 1:ZZ(4)}}, (2, 2), ZZ)
+    B = A.extract([-1], [-1])
+    assert B == SDM({0:{0:ZZ(4)}}, (1, 1), ZZ)
+
+    A = SDM({}, (2, 2), ZZ)
+    B = A.extract([0, 1, 0], [0, 0])
+    assert B == SDM({}, (3, 2), ZZ)
+
+    A = SDM({0:{0:ZZ(1), 1:ZZ(2)}, 1:{0:ZZ(3), 1:ZZ(4)}}, (2, 2), ZZ)
+    assert A.extract([], []) == SDM.zeros((0, 0), ZZ)
+    assert A.extract([1], []) == SDM.zeros((1, 0), ZZ)
+    assert A.extract([], [1]) == SDM.zeros((0, 1), ZZ)
+
+    raises(IndexError, lambda: A.extract([2], [0]))
+    raises(IndexError, lambda: A.extract([0], [2]))
+    raises(IndexError, lambda: A.extract([-3], [0]))
+    raises(IndexError, lambda: A.extract([0], [-3]))
+
+
+def test_SDM_zeros():
+    A = SDM.zeros((2, 2), ZZ)
+    assert A.domain == ZZ
+    assert A.shape == (2, 2)
+    assert dict(A) == {}
+
+def test_SDM_ones():
+    A = SDM.ones((1, 2), QQ)
+    assert A.domain == QQ
+    assert A.shape == (1, 2)
+    assert dict(A) == {0:{0:QQ(1), 1:QQ(1)}}
+
+def test_SDM_eye():
+    A = SDM.eye((2, 2), ZZ)
+    assert A.domain == ZZ
+    assert A.shape == (2, 2)
+    assert dict(A) == {0:{0:ZZ(1)}, 1:{1:ZZ(1)}}
+
+
+def test_SDM_diag():
+    A = SDM.diag([ZZ(1), ZZ(2)], ZZ, (2, 3))
+    assert A == SDM({0:{0:ZZ(1)}, 1:{1:ZZ(2)}}, (2, 3), ZZ)
+
+
+def test_SDM_transpose():
+    A = SDM({0:{0:ZZ(1), 1:ZZ(2)}, 1:{0:ZZ(3), 1:ZZ(4)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(1), 1:ZZ(3)}, 1:{0:ZZ(2), 1:ZZ(4)}}, (2, 2), ZZ)
+    assert A.transpose() == B
+
+    A = SDM({0:{1:ZZ(2)}}, (2, 2), ZZ)
+    B = SDM({1:{0:ZZ(2)}}, (2, 2), ZZ)
+    assert A.transpose() == B
+
+    A = SDM({0:{1:ZZ(2)}}, (1, 2), ZZ)
+    B = SDM({1:{0:ZZ(2)}}, (2, 1), ZZ)
+    assert A.transpose() == B
+
+
+def test_SDM_mul():
+    A = SDM({0:{0:ZZ(2)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(4)}}, (2, 2), ZZ)
+    assert A*ZZ(2) == B
+    assert ZZ(2)*A == B
+
+    raises(TypeError, lambda: A*QQ(1, 2))
+    raises(TypeError, lambda: QQ(1, 2)*A)
+
+
+def test_SDM_mul_elementwise():
+    A = SDM({0:{0:ZZ(2), 1:ZZ(2)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(4)}, 1:{0:ZZ(3)}}, (2, 2), ZZ)
+    C = SDM({0:{0:ZZ(8)}}, (2, 2), ZZ)
+    assert A.mul_elementwise(B) == C
+    assert B.mul_elementwise(A) == C
+
+    Aq = A.convert_to(QQ)
+    A1 = SDM({0:{0:ZZ(1)}}, (1, 1), ZZ)
+
+    raises(DMDomainError, lambda: Aq.mul_elementwise(B))
+    raises(DMShapeError, lambda: A1.mul_elementwise(B))
+
+
+def test_SDM_matmul():
+    A = SDM({0:{0:ZZ(2)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(4)}}, (2, 2), ZZ)
+    assert A.matmul(A) == A*A == B
+
+    C = SDM({0:{0:ZZ(2)}}, (2, 2), QQ)
+    raises(DMDomainError, lambda: A.matmul(C))
+
+    A = SDM({0:{0:ZZ(1), 1:ZZ(2)}, 1:{0:ZZ(3), 1:ZZ(4)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(7), 1:ZZ(10)}, 1:{0:ZZ(15), 1:ZZ(22)}}, (2, 2), ZZ)
+    assert A.matmul(A) == A*A == B
+
+    A22 = SDM({0:{0:ZZ(4)}}, (2, 2), ZZ)
+    A32 = SDM({0:{0:ZZ(2)}}, (3, 2), ZZ)
+    A23 = SDM({0:{0:ZZ(4)}}, (2, 3), ZZ)
+    A33 = SDM({0:{0:ZZ(8)}}, (3, 3), ZZ)
+    A22 = SDM({0:{0:ZZ(8)}}, (2, 2), ZZ)
+    assert A32.matmul(A23) == A33
+    assert A23.matmul(A32) == A22
+    # XXX: @ not supported by SDM...
+    #assert A32.matmul(A23) == A32 @ A23 == A33
+    #assert A23.matmul(A32) == A23 @ A32 == A22
+    #raises(DMShapeError, lambda: A23 @ A22)
+    raises(DMShapeError, lambda: A23.matmul(A22))
+
+    A = SDM({0: {0: ZZ(-1), 1: ZZ(1)}}, (1, 2), ZZ)
+    B = SDM({0: {0: ZZ(-1)}, 1: {0: ZZ(-1)}}, (2, 1), ZZ)
+    assert A.matmul(B) == A*B == SDM({}, (1, 1), ZZ)
+
+
+def test_matmul_exraw():
+
+    def dm(d):
+        result = {}
+        for i, row in d.items():
+            row = {j:val for j, val in row.items() if val}
+            if row:
+                result[i] = row
+        return SDM(result, (2, 2), EXRAW)
+
+    values = [S.NegativeInfinity, S.NegativeOne, S.Zero, S.One, S.Infinity]
+    for a, b, c, d in product(*[values]*4):
+        Ad = dm({0: {0:a, 1:b}, 1: {0:c, 1:d}})
+        Ad2 = dm({0: {0:a*a + b*c, 1:a*b + b*d}, 1:{0:c*a + d*c, 1: c*b + d*d}})
+        assert Ad * Ad == Ad2
+
+
+def test_SDM_add():
+    A = SDM({0:{1:ZZ(1)}, 1:{0:ZZ(2), 1:ZZ(3)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(1)}, 1:{0:ZZ(-2), 1:ZZ(3)}}, (2, 2), ZZ)
+    C = SDM({0:{0:ZZ(1), 1:ZZ(1)}, 1:{1:ZZ(6)}}, (2, 2), ZZ)
+    assert A.add(B) == B.add(A) == A + B == B + A == C
+
+    A = SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(1)}, 1:{0:ZZ(-2), 1:ZZ(3)}}, (2, 2), ZZ)
+    C = SDM({0:{0:ZZ(1), 1:ZZ(1)}, 1:{0:ZZ(-2), 1:ZZ(3)}}, (2, 2), ZZ)
+    assert A.add(B) == B.add(A) == A + B == B + A == C
+
+    raises(TypeError, lambda: A + [])
+
+
+def test_SDM_sub():
+    A = SDM({0:{1:ZZ(1)}, 1:{0:ZZ(2), 1:ZZ(3)}}, (2, 2), ZZ)
+    B = SDM({0:{0:ZZ(1)}, 1:{0:ZZ(-2), 1:ZZ(3)}}, (2, 2), ZZ)
+    C = SDM({0:{0:ZZ(-1), 1:ZZ(1)}, 1:{0:ZZ(4)}}, (2, 2), ZZ)
+    assert A.sub(B) == A - B == C
+
+    raises(TypeError, lambda: A - [])
+
+
+def test_SDM_neg():
+    A = SDM({0:{1:ZZ(1)}, 1:{0:ZZ(2), 1:ZZ(3)}}, (2, 2), ZZ)
+    B = SDM({0:{1:ZZ(-1)}, 1:{0:ZZ(-2), 1:ZZ(-3)}}, (2, 2), ZZ)
+    assert A.neg() == -A == B
+
+
+def test_SDM_convert_to():
+    A = SDM({0:{1:ZZ(1)}, 1:{0:ZZ(2), 1:ZZ(3)}}, (2, 2), ZZ)
+    B = SDM({0:{1:QQ(1)}, 1:{0:QQ(2), 1:QQ(3)}}, (2, 2), QQ)
+    C = A.convert_to(QQ)
+    assert C == B
+    assert C.domain == QQ
+
+    D = A.convert_to(ZZ)
+    assert D == A
+    assert D.domain == ZZ
+
+
+def test_SDM_hstack():
+    A = SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    B = SDM({1:{1:ZZ(1)}}, (2, 2), ZZ)
+    AA = SDM({0:{1:ZZ(1), 3:ZZ(1)}}, (2, 4), ZZ)
+    AB = SDM({0:{1:ZZ(1)}, 1:{3:ZZ(1)}}, (2, 4), ZZ)
+    assert SDM.hstack(A) == A
+    assert SDM.hstack(A, A) == AA
+    assert SDM.hstack(A, B) == AB
+
+
+def test_SDM_vstack():
+    A = SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    B = SDM({1:{1:ZZ(1)}}, (2, 2), ZZ)
+    AA = SDM({0:{1:ZZ(1)}, 2:{1:ZZ(1)}}, (4, 2), ZZ)
+    AB = SDM({0:{1:ZZ(1)}, 3:{1:ZZ(1)}}, (4, 2), ZZ)
+    assert SDM.vstack(A) == A
+    assert SDM.vstack(A, A) == AA
+    assert SDM.vstack(A, B) == AB
+
+
+def test_SDM_applyfunc():
+    A = SDM({0:{1:ZZ(1)}}, (2, 2), ZZ)
+    B = SDM({0:{1:ZZ(2)}}, (2, 2), ZZ)
+    assert A.applyfunc(lambda x: 2*x, ZZ) == B
+
+
+def test_SDM_inv():
+    A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+    B = SDM({0:{0:QQ(-2), 1:QQ(1)}, 1:{0:QQ(3, 2), 1:QQ(-1, 2)}}, (2, 2), QQ)
+    assert A.inv() == B
+
+
+def test_SDM_det():
+    A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+    assert A.det() == QQ(-2)
+
+
+def test_SDM_lu():
+    A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+    L = SDM({0:{0:QQ(1)}, 1:{0:QQ(3), 1:QQ(1)}}, (2, 2), QQ)
+    #U = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(-2)}}, (2, 2), QQ)
+    #swaps = []
+    # This doesn't quite work. U has some nonzero elements in the lower part.
+    #assert A.lu() == (L, U, swaps)
+    assert A.lu()[0] == L
+
+
+def test_SDM_lu_solve():
+    A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+    b = SDM({0:{0:QQ(1)}, 1:{0:QQ(2)}}, (2, 1), QQ)
+    x = SDM({1:{0:QQ(1, 2)}}, (2, 1), QQ)
+    assert A.matmul(x) == b
+    assert A.lu_solve(b) == x
+
+
+def test_SDM_charpoly():
+    A = SDM({0:{0:ZZ(1), 1:ZZ(2)}, 1:{0:ZZ(3), 1:ZZ(4)}}, (2, 2), ZZ)
+    assert A.charpoly() == [ZZ(1), ZZ(-5), ZZ(-2)]
+
+
+def test_SDM_nullspace():
+    A = SDM({0:{0:QQ(1), 1:QQ(1)}}, (2, 2), QQ)
+    assert A.nullspace()[0] == SDM({0:{0:QQ(-1), 1:QQ(1)}}, (1, 2), QQ)
+
+
+def test_SDM_rref():
+    eye2 = SDM({0:{0:QQ(1)}, 1:{1:QQ(1)}}, (2, 2), QQ)
+
+    A = SDM({0:{0:QQ(1), 1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+    assert A.rref() == (eye2, [0, 1])
+
+    A = SDM({0:{0:QQ(1)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+    assert A.rref() == (eye2, [0, 1])
+
+    A = SDM({0:{1:QQ(2)}, 1:{0:QQ(3), 1:QQ(4)}}, (2, 2), QQ)
+    assert A.rref() == (eye2, [0, 1])
+
+    A = SDM({0:{0:QQ(1), 1:QQ(2), 2:QQ(3)},
+             1:{0:QQ(4), 1:QQ(5), 2:QQ(6)},
+             2:{0:QQ(7), 1:QQ(8), 2:QQ(9)} }, (3, 3), QQ)
+    Arref = SDM({0:{0:QQ(1), 2:QQ(-1)}, 1:{1:QQ(1), 2:QQ(2)}}, (3, 3), QQ)
+    assert A.rref() == (Arref, [0, 1])
+
+    A = SDM({0:{0:QQ(1), 1:QQ(2), 3:QQ(1)},
+             1:{0:QQ(1), 1:QQ(1), 2:QQ(9)}}, (2, 4), QQ)
+    Arref = SDM({0:{0:QQ(1), 2:QQ(18), 3:QQ(-1)},
+                 1:{1:QQ(1), 2:QQ(-9), 3:QQ(1)}}, (2, 4), QQ)
+    assert A.rref() == (Arref, [0, 1])
+
+    A = SDM({0:{0:QQ(1), 1:QQ(1), 2:QQ(1)},
+             1:{0:QQ(1), 1:QQ(2), 2:QQ(2)}}, (2, 3), QQ)
+    Arref = SDM(
+            {0: {0: QQ(1,1)}, 1: {1: QQ(1,1), 2: QQ(1,1)}},
+            (2, 3), QQ)
+    assert A.rref() == (Arref, [0, 1])
+
+
+def test_SDM_particular():
+    A = SDM({0:{0:QQ(1)}}, (2, 2), QQ)
+    Apart = SDM.zeros((1, 2), QQ)
+    assert A.particular() == Apart
+
+
+def test_SDM_is_zero_matrix():
+    A = SDM({0: {0: QQ(1)}}, (2, 2), QQ)
+    Azero = SDM.zeros((1, 2), QQ)
+    assert A.is_zero_matrix() is False
+    assert Azero.is_zero_matrix() is True
+
+
+def test_SDM_is_upper():
+    A = SDM({0: {0: QQ(1), 1: QQ(2), 2: QQ(3), 3: QQ(4)},
+                       1: {1: QQ(5), 2: QQ(6), 3: QQ(7)},
+                                 2: {2: QQ(8), 3: QQ(9)}}, (3, 4), QQ)
+    B = SDM({0: {0: QQ(1), 1: QQ(2), 2: QQ(3), 3: QQ(4)},
+                       1: {1: QQ(5), 2: QQ(6), 3: QQ(7)},
+                       2: {1: QQ(7), 2: QQ(8), 3: QQ(9)}}, (3, 4), QQ)
+    assert A.is_upper() is True
+    assert B.is_upper() is False
+
+
+def test_SDM_is_lower():
+    A = SDM({0: {0: QQ(1), 1: QQ(2), 2: QQ(3), 3: QQ(4)},
+                       1: {1: QQ(5), 2: QQ(6), 3: QQ(7)},
+                                 2: {2: QQ(8), 3: QQ(9)}}, (3, 4), QQ
+            ).transpose()
+    B = SDM({0: {0: QQ(1), 1: QQ(2), 2: QQ(3), 3: QQ(4)},
+                       1: {1: QQ(5), 2: QQ(6), 3: QQ(7)},
+                       2: {1: QQ(7), 2: QQ(8), 3: QQ(9)}}, (3, 4), QQ
+            ).transpose()
+    assert A.is_lower() is True
+    assert B.is_lower() is False