Add files using upload-large-folder tool

.gitattributes

@@ -1163,3 +1163,8 @@ vlmpy310/lib/python3.10/site-packages/av.libs/libavformat-071c54bd.so.61.7.100 f
 vlmpy310/lib/python3.10/site-packages/transformers/models/oneformer/__pycache__/modeling_oneformer.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 vlmpy310/lib/python3.10/site-packages/transformers/models/seamless_m4t/__pycache__/modeling_seamless_m4t.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 llava_next/lib/python3.10/site-packages/rich/__pycache__/_emoji_codes.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+vlmpy310/lib/python3.10/site-packages/babel/locale-data/he.dat filter=lfs diff=lfs merge=lfs -text
+vlmpy310/lib/python3.10/site-packages/babel/locale-data/zh_Hant.dat filter=lfs diff=lfs merge=lfs -text
+vlmpy310/lib/python3.10/site-packages/babel/locale-data/so.dat filter=lfs diff=lfs merge=lfs -text
+vlmpy310/lib/python3.10/site-packages/babel/locale-data/bn.dat filter=lfs diff=lfs merge=lfs -text
+vlmpy310/lib/python3.10/site-packages/babel/locale-data/gu.dat filter=lfs diff=lfs merge=lfs -text

llava_next/lib/python3.10/site-packages/sympy/polys/matrices/_dfm.py

@@ -0,0 +1,898 @@
+#
+# sympy.polys.matrices.dfm
+#
+# This modules defines the DFM class which is a wrapper for dense flint
+# matrices as found in python-flint.
+#
+# As of python-flint 0.4.1 matrices over the following domains can be supported
+# by python-flint:
+#
+#   ZZ: flint.fmpz_mat
+#   QQ: flint.fmpq_mat
+#   GF(p): flint.nmod_mat (p prime and p < ~2**62)
+#
+# The underlying flint library has many more domains, but these are not yet
+# supported by python-flint.
+#
+# The DFM class is a wrapper for the flint matrices and provides a common
+# interface for all supported domains that is interchangeable with the DDM
+# and SDM classes so that DomainMatrix can be used with any as its internal
+# matrix representation.
+#
+
+# TODO:
+#
+# Implement the following methods that are provided by python-flint:
+#
+# - hnf (Hermite normal form)
+# - snf (Smith normal form)
+# - minpoly
+# - is_hnf
+# - is_snf
+# - rank
+#
+# The other types DDM and SDM do not have these methods and the algorithms
+# for hnf, snf and rank are already implemented. Algorithms for minpoly,
+# is_hnf and is_snf would need to be added.
+#
+# Add more methods to python-flint to expose more of Flint's functionality
+# and also to make some of the above methods simpler or more efficient e.g.
+# slicing, fancy indexing etc.
+
+from sympy.external.gmpy import GROUND_TYPES
+from sympy.external.importtools import import_module
+from sympy.utilities.decorator import doctest_depends_on
+
+from sympy.polys.domains import ZZ, QQ
+
+from .exceptions import (
+    DMBadInputError,
+    DMDomainError,
+    DMNonSquareMatrixError,
+    DMNonInvertibleMatrixError,
+    DMRankError,
+    DMShapeError,
+    DMValueError,
+)
+
+
+if GROUND_TYPES != 'flint':
+    __doctest_skip__ = ['*']
+
+
+flint = import_module('flint')
+
+
+__all__ = ['DFM']
+
+
+@doctest_depends_on(ground_types=['flint'])
+class DFM:
+    """
+    Dense FLINT matrix. This class is a wrapper for matrices from python-flint.
+
+    >>> from sympy.polys.domains import ZZ
+    >>> from sympy.polys.matrices.dfm import DFM
+    >>> dfm = DFM([[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]], (2, 2), ZZ)
+    >>> dfm
+    [[1, 2], [3, 4]]
+    >>> dfm.rep
+    [1, 2]
+    [3, 4]
+    >>> type(dfm.rep)  # doctest: +SKIP
+    <class 'flint._flint.fmpz_mat'>
+
+    Usually, the DFM class is not instantiated directly, but is created as the
+    internal representation of :class:`~.DomainMatrix`. When
+    `SYMPY_GROUND_TYPES` is set to `flint` and `python-flint` is installed, the
+    :class:`DFM` class is used automatically as the internal representation of
+    :class:`~.DomainMatrix` in dense format if the domain is supported by
+    python-flint.
+
+    >>> from sympy.polys.matrices.domainmatrix import DM
+    >>> dM = DM([[1, 2], [3, 4]], ZZ)
+    >>> dM.rep
+    [[1, 2], [3, 4]]
+
+    A :class:`~.DomainMatrix` can be converted to :class:`DFM` by calling the
+    :meth:`to_dfm` method:
+
+    >>> dM.to_dfm()
+    [[1, 2], [3, 4]]
+
+    """
+
+    fmt = 'dense'
+    is_DFM = True
+    is_DDM = False
+
+    def __new__(cls, rowslist, shape, domain):
+        """Construct from a nested list."""
+        flint_mat = cls._get_flint_func(domain)
+
+        if 0 not in shape:
+            try:
+                rep = flint_mat(rowslist)
+            except (ValueError, TypeError):
+                raise DMBadInputError(f"Input should be a list of list of {domain}")
+        else:
+            rep = flint_mat(*shape)
+
+        return cls._new(rep, shape, domain)
+
+    @classmethod
+    def _new(cls, rep, shape, domain):
+        """Internal constructor from a flint matrix."""
+        cls._check(rep, shape, domain)
+        obj = object.__new__(cls)
+        obj.rep = rep
+        obj.shape = obj.rows, obj.cols = shape
+        obj.domain = domain
+        return obj
+
+    def _new_rep(self, rep):
+        """Create a new DFM with the same shape and domain but a new rep."""
+        return self._new(rep, self.shape, self.domain)
+
+    @classmethod
+    def _check(cls, rep, shape, domain):
+        repshape = (rep.nrows(), rep.ncols())
+        if repshape != shape:
+            raise DMBadInputError("Shape of rep does not match shape of DFM")
+        if domain == ZZ and not isinstance(rep, flint.fmpz_mat):
+            raise RuntimeError("Rep is not a flint.fmpz_mat")
+        elif domain == QQ and not isinstance(rep, flint.fmpq_mat):
+            raise RuntimeError("Rep is not a flint.fmpq_mat")
+        elif domain not in (ZZ, QQ):
+            raise NotImplementedError("Only ZZ and QQ are supported by DFM")
+
+    @classmethod
+    def _supports_domain(cls, domain):
+        """Return True if the given domain is supported by DFM."""
+        return domain in (ZZ, QQ)
+
+    @classmethod
+    def _get_flint_func(cls, domain):
+        """Return the flint matrix class for the given domain."""
+        if domain == ZZ:
+            return flint.fmpz_mat
+        elif domain == QQ:
+            return flint.fmpq_mat
+        else:
+            raise NotImplementedError("Only ZZ and QQ are supported by DFM")
+
+    @property
+    def _func(self):
+        """Callable to create a flint matrix of the same domain."""
+        return self._get_flint_func(self.domain)
+
+    def __str__(self):
+        """Return ``str(self)``."""
+        return str(self.to_ddm())
+
+    def __repr__(self):
+        """Return ``repr(self)``."""
+        return f'DFM{repr(self.to_ddm())[3:]}'
+
+    def __eq__(self, other):
+        """Return ``self == other``."""
+        if not isinstance(other, DFM):
+            return NotImplemented
+        # Compare domains first because we do *not* want matrices with
+        # different domains to be equal but e.g. a flint fmpz_mat and fmpq_mat
+        # with the same entries will compare equal.
+        return self.domain == other.domain and self.rep == other.rep
+
+    @classmethod
+    def from_list(cls, rowslist, shape, domain):
+        """Construct from a nested list."""
+        return cls(rowslist, shape, domain)
+
+    def to_list(self):
+        """Convert to a nested list."""
+        return self.rep.tolist()
+
+    def copy(self):
+        """Return a copy of self."""
+        return self._new_rep(self._func(self.rep))
+
+    def to_ddm(self):
+        """Convert to a DDM."""
+        return DDM.from_list(self.to_list(), self.shape, self.domain)
+
+    def to_sdm(self):
+        """Convert to a SDM."""
+        return SDM.from_list(self.to_list(), self.shape, self.domain)
+
+    def to_dfm(self):
+        """Return self."""
+        return self
+
+    def to_dfm_or_ddm(self):
+        """
+        Convert to a :class:`DFM`.
+
+        This :class:`DFM` method exists to parallel the :class:`~.DDM` and
+        :class:`~.SDM` methods. For :class:`DFM` it will always return self.
+
+        See Also
+        ========
+
+        to_ddm
+        to_sdm
+        sympy.polys.matrices.domainmatrix.DomainMatrix.to_dfm_or_ddm
+        """
+        return self
+
+    @classmethod
+    def from_ddm(cls, ddm):
+        """Convert from a DDM."""
+        return cls.from_list(ddm.to_list(), ddm.shape, ddm.domain)
+
+    @classmethod
+    def from_list_flat(cls, elements, shape, domain):
+        """Inverse of :meth:`to_list_flat`."""
+        func = cls._get_flint_func(domain)
+        try:
+            rep = func(*shape, elements)
+        except ValueError:
+            raise DMBadInputError(f"Incorrect number of elements for shape {shape}")
+        except TypeError:
+            raise DMBadInputError(f"Input should be a list of {domain}")
+        return cls(rep, shape, domain)
+
+    def to_list_flat(self):
+        """Convert to a flat list."""
+        return self.rep.entries()
+
+    def to_flat_nz(self):
+        """Convert to a flat list of non-zeros."""
+        return self.to_ddm().to_flat_nz()
+
+    @classmethod
+    def from_flat_nz(cls, elements, data, domain):
+        """Inverse of :meth:`to_flat_nz`."""
+        return DDM.from_flat_nz(elements, data, domain).to_dfm()
+
+    def to_dod(self):
+        """Convert to a DOD."""
+        return self.to_ddm().to_dod()
+
+    @classmethod
+    def from_dod(cls, dod, shape, domain):
+        """Inverse of :meth:`to_dod`."""
+        return DDM.from_dod(dod, shape, domain).to_dfm()
+
+    def to_dok(self):
+        """Convert to a DOK."""
+        return self.to_ddm().to_dok()
+
+    @classmethod
+    def from_dok(cls, dok, shape, domain):
+        """Inverse of :math:`to_dod`."""
+        return DDM.from_dok(dok, shape, domain).to_dfm()
+
+    def iter_values(self):
+        """Iterater over the non-zero values of the matrix."""
+        m, n = self.shape
+        rep = self.rep
+        for i in range(m):
+            for j in range(n):
+                repij = rep[i, j]
+                if repij:
+                    yield rep[i, j]
+
+    def iter_items(self):
+        """Iterate over indices and values of nonzero elements of the matrix."""
+        m, n = self.shape
+        rep = self.rep
+        for i in range(m):
+            for j in range(n):
+                repij = rep[i, j]
+                if repij:
+                    yield ((i, j), repij)
+
+    def convert_to(self, domain):
+        """Convert to a new domain."""
+        if domain == self.domain:
+            return self.copy()
+        elif domain == QQ and self.domain == ZZ:
+            return self._new(flint.fmpq_mat(self.rep), self.shape, domain)
+        elif domain == ZZ and self.domain == QQ:
+            # XXX: python-flint has no fmpz_mat.from_fmpq_mat
+            return self.to_ddm().convert_to(domain).to_dfm()
+        else:
+            # It is the callers responsibility to convert to DDM before calling
+            # this method if the domain is not supported by DFM.
+            raise NotImplementedError("Only ZZ and QQ are supported by DFM")
+
+    def getitem(self, i, j):
+        """Get the ``(i, j)``-th entry."""
+        # XXX: flint matrices do not support negative indices
+        # XXX: They also raise ValueError instead of IndexError
+        m, n = self.shape
+        if i < 0:
+            i += m
+        if j < 0:
+            j += n
+        try:
+            return self.rep[i, j]
+        except ValueError:
+            raise IndexError(f"Invalid indices ({i}, {j}) for Matrix of shape {self.shape}")
+
+    def setitem(self, i, j, value):
+        """Set the ``(i, j)``-th entry."""
+        # XXX: flint matrices do not support negative indices
+        # XXX: They also raise ValueError instead of IndexError
+        m, n = self.shape
+        if i < 0:
+            i += m
+        if j < 0:
+            j += n
+        try:
+            self.rep[i, j] = value
+        except ValueError:
+            raise IndexError(f"Invalid indices ({i}, {j}) for Matrix of shape {self.shape}")
+
+    def _extract(self, i_indices, j_indices):
+        """Extract a submatrix with no checking."""
+        # Indices must be positive and in range.
+        M = self.rep
+        lol = [[M[i, j] for j in j_indices] for i in i_indices]
+        shape = (len(i_indices), len(j_indices))
+        return self.from_list(lol, shape, self.domain)
+
+    def extract(self, rowslist, colslist):
+        """Extract a submatrix."""
+        # XXX: flint matrices do not support fancy indexing or negative indices
+        #
+        # Check and convert negative indices before calling _extract.
+        m, n = self.shape
+
+        new_rows = []
+        new_cols = []
+
+        for i in rowslist:
+            if i < 0:
+                i_pos = i + m
+            else:
+                i_pos = i
+            if not 0 <= i_pos < m:
+                raise IndexError(f"Invalid row index {i} for Matrix of shape {self.shape}")
+            new_rows.append(i_pos)
+
+        for j in colslist:
+            if j < 0:
+                j_pos = j + n
+            else:
+                j_pos = j
+            if not 0 <= j_pos < n:
+                raise IndexError(f"Invalid column index {j} for Matrix of shape {self.shape}")
+            new_cols.append(j_pos)
+
+        return self._extract(new_rows, new_cols)
+
+    def extract_slice(self, rowslice, colslice):
+        """Slice a DFM."""
+        # XXX: flint matrices do not support slicing
+        m, n = self.shape
+        i_indices = range(m)[rowslice]
+        j_indices = range(n)[colslice]
+        return self._extract(i_indices, j_indices)
+
+    def neg(self):
+        """Negate a DFM matrix."""
+        return self._new_rep(-self.rep)
+
+    def add(self, other):
+        """Add two DFM matrices."""
+        return self._new_rep(self.rep + other.rep)
+
+    def sub(self, other):
+        """Subtract two DFM matrices."""
+        return self._new_rep(self.rep - other.rep)
+
+    def mul(self, other):
+        """Multiply a DFM matrix from the right by a scalar."""
+        return self._new_rep(self.rep * other)
+
+    def rmul(self, other):
+        """Multiply a DFM matrix from the left by a scalar."""
+        return self._new_rep(other * self.rep)
+
+    def mul_elementwise(self, other):
+        """Elementwise multiplication of two DFM matrices."""
+        # XXX: flint matrices do not support elementwise multiplication
+        return self.to_ddm().mul_elementwise(other.to_ddm()).to_dfm()
+
+    def matmul(self, other):
+        """Multiply two DFM matrices."""
+        shape = (self.rows, other.cols)
+        return self._new(self.rep * other.rep, shape, self.domain)
+
+    # XXX: For the most part DomainMatrix does not expect DDM, SDM, or DFM to
+    # have arithmetic operators defined. The only exception is negation.
+    # Perhaps that should be removed.
+
+    def __neg__(self):
+        """Negate a DFM matrix."""
+        return self.neg()
+
+    @classmethod
+    def zeros(cls, shape, domain):
+        """Return a zero DFM matrix."""
+        func = cls._get_flint_func(domain)
+        return cls._new(func(*shape), shape, domain)
+
+    # XXX: flint matrices do not have anything like ones or eye
+    # In the methods below we convert to DDM and then back to DFM which is
+    # probably about as efficient as implementing these methods directly.
+
+    @classmethod
+    def ones(cls, shape, domain):
+        """Return a one DFM matrix."""
+        # XXX: flint matrices do not have anything like ones
+        return DDM.ones(shape, domain).to_dfm()
+
+    @classmethod
+    def eye(cls, n, domain):
+        """Return the identity matrix of size n."""
+        # XXX: flint matrices do not have anything like eye
+        return DDM.eye(n, domain).to_dfm()
+
+    @classmethod
+    def diag(cls, elements, domain):
+        """Return a diagonal matrix."""
+        return DDM.diag(elements, domain).to_dfm()
+
+    def applyfunc(self, func, domain):
+        """Apply a function to each entry of a DFM matrix."""
+        return self.to_ddm().applyfunc(func, domain).to_dfm()
+
+    def transpose(self):
+        """Transpose a DFM matrix."""
+        return self._new(self.rep.transpose(), (self.cols, self.rows), self.domain)
+
+    def hstack(self, *others):
+        """Horizontally stack matrices."""
+        return self.to_ddm().hstack(*[o.to_ddm() for o in others]).to_dfm()
+
+    def vstack(self, *others):
+        """Vertically stack matrices."""
+        return self.to_ddm().vstack(*[o.to_ddm() for o in others]).to_dfm()
+
+    def diagonal(self):
+        """Return the diagonal of a DFM matrix."""
+        M = self.rep
+        m, n = self.shape
+        return [M[i, i] for i in range(min(m, n))]
+
+    def is_upper(self):
+        """Return ``True`` if the matrix is upper triangular."""
+        M = self.rep
+        for i in range(self.rows):
+            for j in range(i):
+                if M[i, j]:
+                    return False
+        return True
+
+    def is_lower(self):
+        """Return ``True`` if the matrix is lower triangular."""
+        M = self.rep
+        for i in range(self.rows):
+            for j in range(i + 1, self.cols):
+                if M[i, j]:
+                    return False
+        return True
+
+    def is_diagonal(self):
+        """Return ``True`` if the matrix is diagonal."""
+        return self.is_upper() and self.is_lower()
+
+    def is_zero_matrix(self):
+        """Return ``True`` if the matrix is the zero matrix."""
+        M = self.rep
+        for i in range(self.rows):
+            for j in range(self.cols):
+                if M[i, j]:
+                    return False
+        return True
+
+    def nnz(self):
+        """Return the number of non-zero elements in the matrix."""
+        return self.to_ddm().nnz()
+
+    def scc(self):
+        """Return the strongly connected components of the matrix."""
+        return self.to_ddm().scc()
+
+    @doctest_depends_on(ground_types='flint')
+    def det(self):
+        """
+        Compute the determinant of the matrix using FLINT.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> M = Matrix([[1, 2], [3, 4]])
+        >>> dfm = M.to_DM().to_dfm()
+        >>> dfm
+        [[1, 2], [3, 4]]
+        >>> dfm.det()
+        -2
+
+        Notes
+        =====
+
+        Calls the ``.det()`` method of the underlying FLINT matrix.
+
+        For :ref:`ZZ` or :ref:`QQ` this calls ``fmpz_mat_det`` or
+        ``fmpq_mat_det`` respectively.
+
+        At the time of writing the implementation of ``fmpz_mat_det`` uses one
+        of several algorithms depending on the size of the matrix and bit size
+        of the entries. The algorithms used are:
+
+        - Cofactor for very small (up to 4x4) matrices.
+        - Bareiss for small (up to 25x25) matrices.
+        - Modular algorithms for larger matrices (up to 60x60) or for larger
+          matrices with large bit sizes.
+        - Modular "accelerated" for larger matrices (60x60 upwards) if the bit
+          size is smaller than the dimensions of the matrix.
+
+        The implementation of ``fmpq_mat_det`` clears denominators from each
+        row (not the whole matrix) and then calls ``fmpz_mat_det`` and divides
+        by the product of the denominators.
+
+        See Also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.det
+            Higher level interface to compute the determinant of a matrix.
+        """
+        # XXX: At least the first three algorithms described above should also
+        # be implemented in the pure Python DDM and SDM classes which at the
+        # time of writng just use Bareiss for all matrices and domains.
+        # Probably in Python the thresholds would be different though.
+        return self.rep.det()
+
+    @doctest_depends_on(ground_types='flint')
+    def charpoly(self):
+        """
+        Compute the characteristic polynomial of the matrix using FLINT.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> M = Matrix([[1, 2], [3, 4]])
+        >>> dfm = M.to_DM().to_dfm()  # need ground types = 'flint'
+        >>> dfm
+        [[1, 2], [3, 4]]
+        >>> dfm.charpoly()
+        [1, -5, -2]
+
+        Notes
+        =====
+
+        Calls the ``.charpoly()`` method of the underlying FLINT matrix.
+
+        For :ref:`ZZ` or :ref:`QQ` this calls ``fmpz_mat_charpoly`` or
+        ``fmpq_mat_charpoly`` respectively.
+
+        At the time of writing the implementation of ``fmpq_mat_charpoly``
+        clears a denominator from the whole matrix and then calls
+        ``fmpz_mat_charpoly``. The coefficients of the characteristic
+        polynomial are then multiplied by powers of the denominator.
+
+        The ``fmpz_mat_charpoly`` method uses a modular algorithm with CRT
+        reconstruction. The modular algorithm uses ``nmod_mat_charpoly`` which
+        uses Berkowitz for small matrices and non-prime moduli or otherwise
+        the Danilevsky method.
+
+        See Also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.charpoly
+            Higher level interface to compute the characteristic polynomial of
+            a matrix.
+        """
+        # FLINT polynomial coefficients are in reverse order compared to SymPy.
+        return self.rep.charpoly().coeffs()[::-1]
+
+    @doctest_depends_on(ground_types='flint')
+    def inv(self):
+        """
+        Compute the inverse of a matrix using FLINT.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, QQ
+        >>> M = Matrix([[1, 2], [3, 4]])
+        >>> dfm = M.to_DM().to_dfm().convert_to(QQ)
+        >>> dfm
+        [[1, 2], [3, 4]]
+        >>> dfm.inv()
+        [[-2, 1], [3/2, -1/2]]
+        >>> dfm.matmul(dfm.inv())
+        [[1, 0], [0, 1]]
+
+        Notes
+        =====
+
+        Calls the ``.inv()`` method of the underlying FLINT matrix.
+
+        For now this will raise an error if the domain is :ref:`ZZ` but will
+        use the FLINT method for :ref:`QQ`.
+
+        The FLINT methods for :ref:`ZZ` and :ref:`QQ` are ``fmpz_mat_inv`` and
+        ``fmpq_mat_inv`` respectively. The ``fmpz_mat_inv`` method computes an
+        inverse with denominator. This is implemented by calling
+        ``fmpz_mat_solve`` (see notes in :meth:`lu_solve` about the algorithm).
+
+        The ``fmpq_mat_inv`` method clears denominators from each row and then
+        multiplies those into the rhs identity matrix before calling
+        ``fmpz_mat_solve``.
+
+        See Also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.inv
+            Higher level method for computing the inverse of a matrix.
+        """
+        # TODO: Implement similar algorithms for DDM and SDM.
+        #
+        # XXX: The flint fmpz_mat and fmpq_mat inv methods both return fmpq_mat
+        # by default. The fmpz_mat method has an optional argument to return
+        # fmpz_mat instead for unimodular matrices.
+        #
+        # The convention in DomainMatrix is to raise an error if the matrix is
+        # not over a field regardless of whether the matrix is invertible over
+        # its domain or over any associated field. Maybe DomainMatrix.inv
+        # should be changed to always return a matrix over an associated field
+        # except with a unimodular argument for returning an inverse over a
+        # ring if possible.
+        #
+        # For now we follow the existing DomainMatrix convention...
+        K = self.domain
+        m, n = self.shape
+
+        if m != n:
+            raise DMNonSquareMatrixError("cannot invert a non-square matrix")
+
+        if K == ZZ:
+            raise DMDomainError("field expected, got %s" % K)
+        elif K == QQ:
+            try:
+                return self._new_rep(self.rep.inv())
+            except ZeroDivisionError:
+                raise DMNonInvertibleMatrixError("matrix is not invertible")
+        else:
+            # If more domains are added for DFM then we will need to consider
+            # what happens here.
+            raise NotImplementedError("DFM.inv() is not implemented for %s" % K)
+
+    def lu(self):
+        """Return the LU decomposition of the matrix."""
+        L, U, swaps = self.to_ddm().lu()
+        return L.to_dfm(), U.to_dfm(), swaps
+
+    # XXX: The lu_solve function should be renamed to solve. Whether or not it
+    # uses an LU decomposition is an implementation detail. A method called
+    # lu_solve would make sense for a situation in which an LU decomposition is
+    # reused several times to solve iwth different rhs but that would imply a
+    # different call signature.
+    #
+    # The underlying python-flint method has an algorithm= argument so we could
+    # use that and have e.g. solve_lu and solve_modular or perhaps also a
+    # method= argument to choose between the two. Flint itself has more
+    # possible algorithms to choose from than are exposed by python-flint.
+
+    @doctest_depends_on(ground_types='flint')
+    def lu_solve(self, rhs):
+        """
+        Solve a matrix equation using FLINT.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix, QQ
+        >>> M = Matrix([[1, 2], [3, 4]])
+        >>> dfm = M.to_DM().to_dfm().convert_to(QQ)
+        >>> dfm
+        [[1, 2], [3, 4]]
+        >>> rhs = Matrix([1, 2]).to_DM().to_dfm().convert_to(QQ)
+        >>> dfm.lu_solve(rhs)
+        [[0], [1/2]]
+
+        Notes
+        =====
+
+        Calls the ``.solve()`` method of the underlying FLINT matrix.
+
+        For now this will raise an error if the domain is :ref:`ZZ` but will
+        use the FLINT method for :ref:`QQ`.
+
+        The FLINT methods for :ref:`ZZ` and :ref:`QQ` are ``fmpz_mat_solve``
+        and ``fmpq_mat_solve`` respectively. The ``fmpq_mat_solve`` method
+        uses one of two algorithms:
+
+        - For small matrices (<25 rows) it clears denominators between the
+          matrix and rhs and uses ``fmpz_mat_solve``.
+        - For larger matrices it uses ``fmpq_mat_solve_dixon`` which is a
+          modular approach with CRT reconstruction over :ref:`QQ`.
+
+        The ``fmpz_mat_solve`` method uses one of four algorithms:
+
+        - For very small (<= 3x3) matrices it uses a Cramer's rule.
+        - For small (<= 15x15) matrices it uses a fraction-free LU solve.
+        - Otherwise it uses either Dixon or another multimodular approach.
+
+        See Also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.lu_solve
+            Higher level interface to solve a matrix equation.
+        """
+        if not self.domain == rhs.domain:
+            raise DMDomainError("Domains must match: %s != %s" % (self.domain, rhs.domain))
+
+        # XXX: As for inv we should consider whether to return a matrix over
+        # over an associated field or attempt to find a solution in the ring.
+        # For now we follow the existing DomainMatrix convention...
+        if not self.domain.is_Field:
+            raise DMDomainError("Field expected, got %s" % self.domain)
+
+        m, n = self.shape
+        j, k = rhs.shape
+        if m != j:
+            raise DMShapeError("Matrix size mismatch: %s * %s vs %s * %s" % (m, n, j, k))
+        sol_shape = (n, k)
+
+        # XXX: The Flint solve method only handles square matrices. Probably
+        # Flint has functions that could be used to solve non-square systems
+        # but they are not exposed in python-flint yet. Alternatively we could
+        # put something here using the features that are available like rref.
+        if m != n:
+            return self.to_ddm().lu_solve(rhs.to_ddm()).to_dfm()
+
+        try:
+            sol = self.rep.solve(rhs.rep)
+        except ZeroDivisionError:
+            raise DMNonInvertibleMatrixError("Matrix det == 0; not invertible.")
+
+        return self._new(sol, sol_shape, self.domain)
+
+    def nullspace(self):
+        """Return a basis for the nullspace of the matrix."""
+        # Code to compute nullspace using flint:
+        #
+        # V, nullity = self.rep.nullspace()
+        # V_dfm = self._new_rep(V)._extract(range(self.rows), range(nullity))
+        #
+        # XXX: That gives the nullspace but does not give us nonpivots. So we
+        # use the slower DDM method anyway. It would be better to change the
+        # signature of the nullspace method to not return nonpivots.
+        #
+        # XXX: Also python-flint exposes a nullspace method for fmpz_mat but
+        # not for fmpq_mat. This is the reverse of the situation for DDM etc
+        # which only allow nullspace over a field. The nullspace method for
+        # DDM, SDM etc should be changed to allow nullspace over ZZ as well.
+        # The DomainMatrix nullspace method does allow the domain to be a ring
+        # but does not directly call the lower-level nullspace methods and uses
+        # rref_den instead. Nullspace methods should also be added to all
+        # matrix types in python-flint.
+        ddm, nonpivots = self.to_ddm().nullspace()
+        return ddm.to_dfm(), nonpivots
+
+    def nullspace_from_rref(self, pivots=None):
+        """Return a basis for the nullspace of the matrix."""
+        # XXX: Use the flint nullspace method!!!
+        sdm, nonpivots = self.to_sdm().nullspace_from_rref(pivots=pivots)
+        return sdm.to_dfm(), nonpivots
+
+    def particular(self):
+        """Return a particular solution to the system."""
+        return self.to_ddm().particular().to_dfm()
+
+    def _lll(self, transform=False, delta=0.99, eta=0.51, rep='zbasis', gram='approx'):
+        """Call the fmpz_mat.lll() method but check rank to avoid segfaults."""
+
+        # XXX: There are tests that pass e.g. QQ(5,6) for delta. That fails
+        # with a TypeError in flint because if QQ is fmpq then conversion with
+        # float fails. We handle that here but there are two better fixes:
+        #
+        # - Make python-flint's fmpq convert with float(x)
+        # - Change the tests because delta should just be a float.
+
+        def to_float(x):
+            if QQ.of_type(x):
+                return float(x.numerator) / float(x.denominator)
+            else:
+                return float(x)
+
+        delta = to_float(delta)
+        eta = to_float(eta)
+
+        if not 0.25 < delta < 1:
+            raise DMValueError("delta must be between 0.25 and 1")
+
+        # XXX: The flint lll method segfaults if the matrix is not full rank.
+        m, n = self.shape
+        if self.rep.rank() != m:
+            raise DMRankError("Matrix must have full row rank for Flint LLL.")
+
+        # Actually call the flint method.
+        return self.rep.lll(transform=transform, delta=delta, eta=eta, rep=rep, gram=gram)
+
+    @doctest_depends_on(ground_types='flint')
+    def lll(self, delta=0.75):
+        """Compute LLL-reduced basis using FLINT.
+
+        See :meth:`lll_transform` for more information.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> M = Matrix([[1, 2, 3], [4, 5, 6]])
+        >>> M.to_DM().to_dfm().lll()
+        [[2, 1, 0], [-1, 1, 3]]
+
+        See Also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.lll
+            Higher level interface to compute LLL-reduced basis.
+        lll_transform
+            Compute LLL-reduced basis and transform matrix.
+        """
+        if self.domain != ZZ:
+            raise DMDomainError("ZZ expected, got %s" % self.domain)
+        elif self.rows > self.cols:
+            raise DMShapeError("Matrix must not have more rows than columns.")
+
+        rep = self._lll(delta=delta)
+        return self._new_rep(rep)
+
+    @doctest_depends_on(ground_types='flint')
+    def lll_transform(self, delta=0.75):
+        """Compute LLL-reduced basis and transform using FLINT.
+
+        Examples
+        ========
+
+        >>> from sympy import Matrix
+        >>> M = Matrix([[1, 2, 3], [4, 5, 6]]).to_DM().to_dfm()
+        >>> M_lll, T = M.lll_transform()
+        >>> M_lll
+        [[2, 1, 0], [-1, 1, 3]]
+        >>> T
+        [[-2, 1], [3, -1]]
+        >>> T.matmul(M) == M_lll
+        True
+
+        See Also
+        ========
+
+        sympy.polys.matrices.domainmatrix.DomainMatrix.lll
+            Higher level interface to compute LLL-reduced basis.
+        lll
+            Compute LLL-reduced basis without transform matrix.
+        """
+        if self.domain != ZZ:
+            raise DMDomainError("ZZ expected, got %s" % self.domain)
+        elif self.rows > self.cols:
+            raise DMShapeError("Matrix must not have more rows than columns.")
+
+        rep, T = self._lll(transform=True, delta=delta)
+        basis = self._new_rep(rep)
+        T_dfm = self._new(T, (self.rows, self.rows), self.domain)
+        return basis, T_dfm
+
+
+# Avoid circular imports
+from sympy.polys.matrices.ddm import DDM
+from sympy.polys.matrices.ddm import SDM

llava_next/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(divide_last=True)
+            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(divide_last=True)
+            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

llava_next/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 e in 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)

llava_next/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

llava_next/lib/python3.10/site-packages/sympy/polys/matrices/tests/test_inverse.py

@@ -0,0 +1,193 @@
+from sympy import ZZ, Matrix
+from sympy.polys.matrices import DM, DomainMatrix
+from sympy.polys.matrices.dense import ddm_iinv
+from sympy.polys.matrices.exceptions import DMNonInvertibleMatrixError
+from sympy.matrices.exceptions import NonInvertibleMatrixError
+
+import pytest
+from sympy.testing.pytest import raises
+from sympy.core.numbers import all_close
+
+from sympy.abc import x
+
+
+# Examples are given as adjugate matrix and determinant adj_det should match
+# these exactly but inv_den only matches after cancel_denom.
+
+
+INVERSE_EXAMPLES = [
+
+    (
+        'zz_1',
+        DomainMatrix([], (0, 0), ZZ),
+        DomainMatrix([], (0, 0), ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_2',
+        DM([[2]], ZZ),
+        DM([[1]], ZZ),
+        ZZ(2),
+    ),
+
+    (
+        'zz_3',
+        DM([[2, 0],
+            [0, 2]], ZZ),
+        DM([[2, 0],
+            [0, 2]], ZZ),
+        ZZ(4),
+    ),
+
+    (
+        'zz_4',
+        DM([[1, 2],
+            [3, 4]], ZZ),
+        DM([[ 4, -2],
+            [-3,  1]], ZZ),
+        ZZ(-2),
+    ),
+
+    (
+        'zz_5',
+        DM([[2, 2, 0],
+            [0, 2, 2],
+            [0, 0, 2]], ZZ),
+        DM([[4, -4, 4],
+            [0, 4, -4],
+            [0, 0,  4]], ZZ),
+        ZZ(8),
+    ),
+
+    (
+        'zz_6',
+        DM([[1, 2, 3],
+            [4, 5, 6],
+            [7, 8, 9]], ZZ),
+        DM([[-3,   6, -3],
+            [ 6, -12,  6],
+            [-3,   6, -3]], ZZ),
+        ZZ(0),
+    ),
+]
+
+
+@pytest.mark.parametrize('name, A, A_inv, den', INVERSE_EXAMPLES)
+def test_Matrix_inv(name, A, A_inv, den):
+
+    def _check(**kwargs):
+        if den != 0:
+            assert A.inv(**kwargs) == A_inv
+        else:
+            raises(NonInvertibleMatrixError, lambda: A.inv(**kwargs))
+
+    K = A.domain
+    A = A.to_Matrix()
+    A_inv = A_inv.to_Matrix() / K.to_sympy(den)
+    _check()
+    for method in ['GE', 'LU', 'ADJ', 'CH', 'LDL', 'QR']:
+        _check(method=method)
+
+
+@pytest.mark.parametrize('name, A, A_inv, den', INVERSE_EXAMPLES)
+def test_dm_inv_den(name, A, A_inv, den):
+    if den != 0:
+        A_inv_f, den_f = A.inv_den()
+        assert A_inv_f.cancel_denom(den_f) == A_inv.cancel_denom(den)
+    else:
+        raises(DMNonInvertibleMatrixError, lambda: A.inv_den())
+
+
+@pytest.mark.parametrize('name, A, A_inv, den', INVERSE_EXAMPLES)
+def test_dm_inv(name, A, A_inv, den):
+    A = A.to_field()
+    if den != 0:
+        A_inv = A_inv.to_field() / den
+        assert A.inv() == A_inv
+    else:
+        raises(DMNonInvertibleMatrixError, lambda: A.inv())
+
+
+@pytest.mark.parametrize('name, A, A_inv, den', INVERSE_EXAMPLES)
+def test_ddm_inv(name, A, A_inv, den):
+    A = A.to_field().to_ddm()
+    if den != 0:
+        A_inv = (A_inv.to_field() / den).to_ddm()
+        assert A.inv() == A_inv
+    else:
+        raises(DMNonInvertibleMatrixError, lambda: A.inv())
+
+
+@pytest.mark.parametrize('name, A, A_inv, den', INVERSE_EXAMPLES)
+def test_sdm_inv(name, A, A_inv, den):
+    A = A.to_field().to_sdm()
+    if den != 0:
+        A_inv = (A_inv.to_field() / den).to_sdm()
+        assert A.inv() == A_inv
+    else:
+        raises(DMNonInvertibleMatrixError, lambda: A.inv())
+
+
+@pytest.mark.parametrize('name, A, A_inv, den', INVERSE_EXAMPLES)
+def test_dense_ddm_iinv(name, A, A_inv, den):
+    A = A.to_field().to_ddm().copy()
+    K = A.domain
+    A_result = A.copy()
+    if den != 0:
+        A_inv = (A_inv.to_field() / den).to_ddm()
+        ddm_iinv(A_result, A, K)
+        assert A_result == A_inv
+    else:
+        raises(DMNonInvertibleMatrixError, lambda: ddm_iinv(A_result, A, K))
+
+
+@pytest.mark.parametrize('name, A, A_inv, den', INVERSE_EXAMPLES)
+def test_Matrix_adjugate(name, A, A_inv, den):
+    A = A.to_Matrix()
+    A_inv = A_inv.to_Matrix()
+    assert A.adjugate() == A_inv
+    for method in ["bareiss", "berkowitz", "bird", "laplace", "lu"]:
+        assert A.adjugate(method=method) == A_inv
+
+
+@pytest.mark.parametrize('name, A, A_inv, den', INVERSE_EXAMPLES)
+def test_dm_adj_det(name, A, A_inv, den):
+    assert A.adj_det() == (A_inv, den)
+
+
+def test_inverse_inexact():
+
+    M = Matrix([[x-0.3, -0.06, -0.22],
+                [-0.46, x-0.48, -0.41],
+                [-0.14, -0.39, x-0.64]])
+
+    Mn = Matrix([[1.0*x**2 - 1.12*x + 0.1473, 0.06*x + 0.0474, 0.22*x - 0.081],
+                 [0.46*x - 0.237, 1.0*x**2 - 0.94*x + 0.1612, 0.41*x - 0.0218],
+                 [0.14*x + 0.1122, 0.39*x - 0.1086, 1.0*x**2 - 0.78*x + 0.1164]])
+
+    d = 1.0*x**3 - 1.42*x**2 + 0.4249*x - 0.0546540000000002
+
+    Mi = Mn / d
+
+    M_dm = M.to_DM()
+    M_dmd = M_dm.to_dense()
+    M_dm_num, M_dm_den = M_dm.inv_den()
+    M_dmd_num, M_dmd_den = M_dmd.inv_den()
+
+    # XXX: We don't check M_dm().to_field().inv() which currently uses division
+    # and produces a more complicate result from gcd cancellation failing.
+    # DomainMatrix.inv() over RR(x) should be changed to clear denominators and
+    # use DomainMatrix.inv_den().
+
+    Minvs = [
+        M.inv(),
+        (M_dm_num.to_field() / M_dm_den).to_Matrix(),
+        (M_dmd_num.to_field() / M_dmd_den).to_Matrix(),
+        M_dm_num.to_Matrix() / M_dm_den.as_expr(),
+        M_dmd_num.to_Matrix() / M_dmd_den.as_expr(),
+    ]
+
+    for Minv in Minvs:
+        for Mi1, Mi2 in zip(Minv.flat(), Mi.flat()):
+            assert all_close(Mi2, Mi1)

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

@@ -0,0 +1,112 @@
+#
+# 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
+    ]
+    # Should _linsolve return floats here?
+    sol = {x:0, y: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]))

llava_next/lib/python3.10/site-packages/sympy/polys/matrices/tests/test_nullspace.py

@@ -0,0 +1,209 @@
+from sympy import ZZ, Matrix
+from sympy.polys.matrices import DM, DomainMatrix
+from sympy.polys.matrices.ddm import DDM
+from sympy.polys.matrices.sdm import SDM
+
+import pytest
+
+zeros = lambda shape, K: DomainMatrix.zeros(shape, K).to_dense()
+eye = lambda n, K: DomainMatrix.eye(n, K).to_dense()
+
+
+#
+# DomainMatrix.nullspace can have a divided answer or can return an undivided
+# uncanonical answer. The uncanonical answer is not unique but we can make it
+# unique by making it primitive (remove gcd). The tests here all show the
+# primitive form. We test two things:
+#
+#   A.nullspace().primitive()[1] == answer.
+#   A.nullspace(divide_last=True) == _divide_last(answer).
+#
+# The nullspace as returned by DomainMatrix and related classes is the
+# transpose of the nullspace as returned by Matrix. Matrix returns a list of
+# of column vectors whereas DomainMatrix returns a matrix whose rows are the
+# nullspace vectors.
+#
+
+
+NULLSPACE_EXAMPLES = [
+
+    (
+        'zz_1',
+         DM([[ 1, 2, 3]], ZZ),
+         DM([[-2, 1, 0],
+             [-3, 0, 1]], ZZ),
+    ),
+
+    (
+        'zz_2',
+         zeros((0, 0), ZZ),
+         zeros((0, 0), ZZ),
+    ),
+
+    (
+        'zz_3',
+        zeros((2, 0), ZZ),
+        zeros((0, 0), ZZ),
+    ),
+
+    (
+        'zz_4',
+        zeros((0, 2), ZZ),
+        eye(2, ZZ),
+    ),
+
+    (
+        'zz_5',
+        zeros((2, 2), ZZ),
+        eye(2, ZZ),
+    ),
+
+    (
+        'zz_6',
+        DM([[1, 2],
+            [3, 4]], ZZ),
+        zeros((0, 2), ZZ),
+    ),
+
+    (
+        'zz_7',
+        DM([[1, 1],
+            [1, 1]], ZZ),
+        DM([[-1, 1]], ZZ),
+    ),
+
+    (
+        'zz_8',
+        DM([[1],
+            [1]], ZZ),
+        zeros((0, 1), ZZ),
+    ),
+
+    (
+        'zz_9',
+        DM([[1, 1]], ZZ),
+        DM([[-1, 1]], ZZ),
+    ),
+
+    (
+        'zz_10',
+        DM([[0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
+            [1, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+            [0, 1, 0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 0, 1, 0, 0, 0, 0, 1, 0],
+            [0, 0, 0, 0, 1, 0, 0, 0, 0, 1]], ZZ),
+        DM([[ 0,  0, 1,  0,  0, 0, 0, 0, 0, 0],
+            [-1,  0, 0,  0,  0, 0, 1, 0, 0, 0],
+            [ 0, -1, 0,  0,  0, 0, 0, 1, 0, 0],
+            [ 0,  0, 0, -1,  0, 0, 0, 0, 1, 0],
+            [ 0,  0, 0,  0, -1, 0, 0, 0, 0, 1]], ZZ),
+    ),
+
+]
+
+
+def _to_DM(A, ans):
+    """Convert the answer to DomainMatrix."""
+    if isinstance(A, DomainMatrix):
+        return A.to_dense()
+    elif isinstance(A, DDM):
+        return DomainMatrix(list(A), A.shape, A.domain).to_dense()
+    elif isinstance(A, SDM):
+        return DomainMatrix(dict(A), A.shape, A.domain).to_dense()
+    else:
+        assert False # pragma: no cover
+
+
+def _divide_last(null):
+    """Normalize the nullspace by the rightmost non-zero entry."""
+    null = null.to_field()
+
+    if null.is_zero_matrix:
+        return null
+
+    rows = []
+    for i in range(null.shape[0]):
+        for j in reversed(range(null.shape[1])):
+            if null[i, j]:
+                rows.append(null[i, :] / null[i, j])
+                break
+        else:
+            assert False # pragma: no cover
+
+    return DomainMatrix.vstack(*rows)
+
+
+def _check_primitive(null, null_ans):
+    """Check that the primitive of the answer matches."""
+    null = _to_DM(null, null_ans)
+    cont, null_prim = null.primitive()
+    assert null_prim == null_ans
+
+
+def _check_divided(null, null_ans):
+    """Check the divided answer."""
+    null = _to_DM(null, null_ans)
+    null_ans_norm = _divide_last(null_ans)
+    assert null == null_ans_norm
+
+
+@pytest.mark.parametrize('name, A, A_null', NULLSPACE_EXAMPLES)
+def test_Matrix_nullspace(name, A, A_null):
+    A = A.to_Matrix()
+
+    A_null_cols = A.nullspace()
+
+    # We have to patch up the case where the nullspace is empty
+    if A_null_cols:
+        A_null_found = Matrix.hstack(*A_null_cols)
+    else:
+        A_null_found = Matrix.zeros(A.cols, 0)
+
+    A_null_found = A_null_found.to_DM().to_field().to_dense()
+
+    # The Matrix result is the transpose of DomainMatrix result.
+    A_null_found = A_null_found.transpose()
+
+    _check_divided(A_null_found, A_null)
+
+
+@pytest.mark.parametrize('name, A, A_null', NULLSPACE_EXAMPLES)
+def test_dm_dense_nullspace(name, A, A_null):
+    A = A.to_field().to_dense()
+    A_null_found = A.nullspace(divide_last=True)
+    _check_divided(A_null_found, A_null)
+
+
+@pytest.mark.parametrize('name, A, A_null', NULLSPACE_EXAMPLES)
+def test_dm_sparse_nullspace(name, A, A_null):
+    A = A.to_field().to_sparse()
+    A_null_found = A.nullspace(divide_last=True)
+    _check_divided(A_null_found, A_null)
+
+
+@pytest.mark.parametrize('name, A, A_null', NULLSPACE_EXAMPLES)
+def test_ddm_nullspace(name, A, A_null):
+    A = A.to_field().to_ddm()
+    A_null_found, _ = A.nullspace()
+    _check_divided(A_null_found, A_null)
+
+
+@pytest.mark.parametrize('name, A, A_null', NULLSPACE_EXAMPLES)
+def test_sdm_nullspace(name, A, A_null):
+    A = A.to_field().to_sdm()
+    A_null_found, _ = A.nullspace()
+    _check_divided(A_null_found, A_null)
+
+
+@pytest.mark.parametrize('name, A, A_null', NULLSPACE_EXAMPLES)
+def test_dm_dense_nullspace_fracfree(name, A, A_null):
+    A = A.to_dense()
+    A_null_found = A.nullspace()
+    _check_primitive(A_null_found, A_null)
+
+
+@pytest.mark.parametrize('name, A, A_null', NULLSPACE_EXAMPLES)
+def test_dm_sparse_nullspace_fracfree(name, A, A_null):
+    A = A.to_sparse()
+    A_null_found = A.nullspace()
+    _check_primitive(A_null_found, A_null)

llava_next/lib/python3.10/site-packages/sympy/polys/matrices/tests/test_rref.py

@@ -0,0 +1,737 @@
+from sympy import ZZ, QQ, ZZ_I, EX, Matrix, eye, zeros, symbols
+from sympy.polys.matrices import DM, DomainMatrix
+from sympy.polys.matrices.dense import ddm_irref_den, ddm_irref
+from sympy.polys.matrices.ddm import DDM
+from sympy.polys.matrices.sdm import SDM, sdm_irref, sdm_rref_den
+
+import pytest
+
+
+#
+# The dense and sparse implementations of rref_den are ddm_irref_den and
+# sdm_irref_den. These can give results that differ by some factor and also
+# give different results if the order of the rows is changed. The tests below
+# show all results on lowest terms as should be returned by cancel_denom.
+#
+# The EX domain is also a case where the dense and sparse implementations
+# can give results in different forms: the results should be equivalent but
+# are not canonical because EX does not have a canonical form.
+#
+
+
+a, b, c, d = symbols('a, b, c, d')
+
+
+qq_large_1 = DM([
+[  (1,2),  (1,3),  (1,5),  (1,7), (1,11), (1,13), (1,17), (1,19), (1,23), (1,29), (1,31)],
+[ (1,37), (1,41), (1,43), (1,47), (1,53), (1,59), (1,61), (1,67), (1,71), (1,73), (1,79)],
+[ (1,83), (1,89), (1,97),(1,101),(1,103),(1,107),(1,109),(1,113),(1,127),(1,131),(1,137)],
+[(1,139),(1,149),(1,151),(1,157),(1,163),(1,167),(1,173),(1,179),(1,181),(1,191),(1,193)],
+[(1,197),(1,199),(1,211),(1,223),(1,227),(1,229),(1,233),(1,239),(1,241),(1,251),(1,257)],
+[(1,263),(1,269),(1,271),(1,277),(1,281),(1,283),(1,293),(1,307),(1,311),(1,313),(1,317)],
+[(1,331),(1,337),(1,347),(1,349),(1,353),(1,359),(1,367),(1,373),(1,379),(1,383),(1,389)],
+[(1,397),(1,401),(1,409),(1,419),(1,421),(1,431),(1,433),(1,439),(1,443),(1,449),(1,457)],
+[(1,461),(1,463),(1,467),(1,479),(1,487),(1,491),(1,499),(1,503),(1,509),(1,521),(1,523)],
+[(1,541),(1,547),(1,557),(1,563),(1,569),(1,571),(1,577),(1,587),(1,593),(1,599),(1,601)],
+[(1,607),(1,613),(1,617),(1,619),(1,631),(1,641),(1,643),(1,647),(1,653),(1,659),(1,661)]],
+        QQ)
+
+qq_large_2 = qq_large_1 + 10**100 * DomainMatrix.eye(11, QQ)
+
+
+RREF_EXAMPLES = [
+    (
+        'zz_1',
+         DM([[1, 2, 3]], ZZ),
+         DM([[1, 2, 3]], ZZ),
+         ZZ(1),
+    ),
+
+    (
+        'zz_2',
+         DomainMatrix([], (0, 0), ZZ),
+         DomainMatrix([], (0, 0), ZZ),
+         ZZ(1),
+    ),
+
+    (
+        'zz_3',
+        DM([[1, 2],
+            [3, 4]], ZZ),
+        DM([[1, 0],
+            [0, 1]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_4',
+        DM([[1, 0],
+            [3, 4]], ZZ),
+        DM([[1, 0],
+            [0, 1]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_5',
+        DM([[0, 2],
+            [3, 4]], ZZ),
+        DM([[1, 0],
+            [0, 1]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_6',
+        DM([[1, 2, 3],
+            [4, 5, 6],
+            [7, 8, 9]], ZZ),
+        DM([[1, 0, -1],
+            [0, 1,  2],
+            [0, 0,  0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_7',
+        DM([[0, 0, 0],
+            [0, 0, 0],
+            [1, 0, 0]], ZZ),
+        DM([[1, 0, 0],
+            [0, 0, 0],
+            [0, 0, 0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_8',
+        DM([[0, 0, 0],
+            [0, 0, 0],
+            [0, 0, 0]], ZZ),
+        DM([[0, 0, 0],
+            [0, 0, 0],
+            [0, 0, 0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_9',
+        DM([[1, 1, 0],
+            [0, 0, 2],
+            [0, 0, 0]], ZZ),
+        DM([[1, 1, 0],
+            [0, 0, 1],
+            [0, 0, 0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_10',
+        DM([[2, 2, 0],
+            [0, 0, 2],
+            [0, 0, 0]], ZZ),
+        DM([[1, 1, 0],
+            [0, 0, 1],
+            [0, 0, 0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_11',
+        DM([[2, 2, 0],
+            [0, 2, 2],
+            [0, 0, 2]], ZZ),
+        DM([[1, 0, 0],
+            [0, 1, 0],
+            [0, 0, 1]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_12',
+        DM([[ 1,  2,  3],
+            [ 4,  5,  6],
+            [ 7,  8,  9],
+            [10, 11, 12]], ZZ),
+        DM([[1,  0, -1],
+            [0,  1,  2],
+            [0,  0,  0],
+            [0,  0,  0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_13',
+        DM([[ 1,  2,  3],
+            [ 4,  5,  6],
+            [ 7,  8,  9],
+            [10, 11, 13]], ZZ),
+        DM([[ 1,  0,  0],
+            [ 0,  1,  0],
+            [ 0,  0,  1],
+            [ 0,  0,  0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_14',
+        DM([[1, 2,  4, 3],
+            [4, 5, 10, 6],
+            [7, 8, 16, 9]], ZZ),
+        DM([[1, 0, 0, -1],
+            [0, 1, 2,  2],
+            [0, 0, 0,  0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_15',
+        DM([[1, 2,  4, 3],
+            [4, 5, 10, 6],
+            [7, 8, 17, 9]], ZZ),
+        DM([[1, 0, 0, -1],
+            [0, 1, 0,  2],
+            [0, 0, 1,  0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_16',
+        DM([[1, 2, 0, 1],
+            [1, 1, 9, 0]], ZZ),
+        DM([[1, 0, 18, -1],
+            [0, 1, -9,  1]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_17',
+        DM([[1, 1, 1],
+            [1, 2, 2]], ZZ),
+        DM([[1, 0, 0],
+            [0, 1, 1]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        # Here the sparse implementation and dense implementation give very
+        # different denominators: 4061232 and -1765176.
+        'zz_18',
+        DM([[94, 24,  0, 27, 0],
+            [79,  0,  0,  0, 0],
+            [85, 16, 71, 81, 0],
+            [ 0,  0, 72, 77, 0],
+            [21,  0, 34,  0, 0]], ZZ),
+        DM([[ 1,  0,  0,  0, 0],
+            [ 0,  1,  0,  0, 0],
+            [ 0,  0,  1,  0, 0],
+            [ 0,  0,  0,  1, 0],
+            [ 0,  0,  0,  0, 0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        # Let's have a denominator that cannot be cancelled.
+        'zz_19',
+        DM([[1, 2, 4],
+            [4, 5, 6]], ZZ),
+        DM([[3, 0, -8],
+            [0, 3, 10]], ZZ),
+        ZZ(3),
+    ),
+
+    (
+        'zz_20',
+        DM([[0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 4]], ZZ),
+        DM([[0, 0, 0, 0, 1],
+            [0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_21',
+        DM([[0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
+            [1, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+            [0, 1, 0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 0, 1, 0, 0, 0, 0, 1, 0],
+            [0, 0, 0, 0, 1, 0, 0, 0, 0, 1]], ZZ),
+        DM([[1, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+            [0, 1, 0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 0, 1, 0, 0, 0, 0, 1, 0],
+            [0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+            [0, 0, 0, 0, 0, 1, 0, 0, 0, 0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_22',
+        DM([[1, 1, 1, 0, 1],
+            [1, 1, 0, 1, 0],
+            [1, 0, 1, 0, 1],
+            [1, 1, 0, 1, 0],
+            [1, 0, 0, 0, 0]], ZZ),
+        DM([[1, 0, 0, 0, 0],
+            [0, 1, 0, 0, 0],
+            [0, 0, 1, 0, 1],
+            [0, 0, 0, 1, 0],
+            [0, 0, 0, 0, 0]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_large_1',
+        DM([
+[ 0,  0,  0, 81,  0,  0, 75,  0,  0,  0,  0,  0,  0, 27,  0,  0,  0,  0,  0,  0],
+[ 0,  0,  0,  0,  0, 86,  0, 92, 79, 54,  0,  7,  0,  0,  0,  0, 79,  0,  0,  0],
+[89, 54, 81,  0,  0, 20,  0,  0,  0,  0,  0,  0, 51,  0, 94,  0,  0, 77,  0,  0],
+[ 0,  0,  0, 96,  0,  0,  0,  0,  0,  0,  0,  0, 48, 29,  0,  0,  5,  0, 32,  0],
+[ 0, 70,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 60,  0,  0,  0, 11],
+[ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 37,  0, 43,  0,  0],
+[ 0,  0,  0,  0,  0, 38, 91,  0,  0,  0,  0, 38,  0,  0,  0,  0,  0, 26,  0,  0],
+[69,  0,  0,  0,  0,  0, 94,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 55],
+[ 0, 13, 18, 49, 49, 88,  0,  0, 35, 54,  0,  0, 51,  0,  0,  0,  0,  0,  0, 87],
+[ 0,  0,  0,  0, 31,  0, 40,  0,  0,  0,  0,  0,  0, 50,  0,  0,  0,  0, 88,  0],
+[ 0,  0,  0,  0,  0,  0,  0,  0, 98,  0,  0,  0, 15, 53,  0, 92,  0,  0,  0,  0],
+[ 0,  0,  0, 95,  0,  0,  0, 36,  0,  0,  0,  0,  0, 72,  0,  0,  0,  0, 73, 19],
+[ 0, 65, 14, 96,  0,  0,  0,  0,  0,  0,  0,  0,  0, 90,  0,  0,  0, 34,  0,  0],
+[ 0,  0,  0, 16, 39, 44,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 51,  0,  0],
+[ 0, 17,  0,  0,  0, 99, 84, 13, 50, 84,  0,  0,  0,  0, 95,  0, 43, 33, 20,  0],
+[79,  0, 17, 52, 99, 12, 69,  0, 98,  0, 68,  0,  0,  0,  0,  0,  0,  0,  0,  0],
+[ 0,  0,  0, 82,  0, 44,  0,  0,  0, 97,  0,  0,  0,  0,  0, 10,  0,  0, 31,  0],
+[ 0,  0, 21,  0, 67,  0,  0,  0,  0,  0,  4,  0, 50,  0,  0,  0, 33,  0,  0,  0],
+[ 0,  0,  0,  0,  9, 42,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  8],
+[ 0, 77,  0,  0,  0,  0,  0,  0,  0,  0, 34, 93,  0,  0,  0,  0, 47,  0,  0,  0]],
+           ZZ),
+        DM([[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]], ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_large_2',
+        DM([
+[ 0,  0,  0,  0, 50,  0,  6, 81,  0,  1, 86,  0,  0, 98, 82, 94,  4,  0,  0, 29],
+[ 0, 44, 43,  0, 62,  0,  0,  0, 60,  0,  0,  0,  0, 71,  9,  0, 57, 41,  0, 93],
+[ 0,  0, 28,  0, 74, 89, 42,  0, 28,  0,  6,  0,  0,  0, 44,  0,  0,  0, 77, 19],
+[ 0, 21, 82,  0, 30, 88,  0, 89, 68,  0,  0,  0, 79, 41,  0,  0, 99,  0,  0,  0],
+[31,  0,  0,  0, 19, 64,  0,  0, 79,  0,  5,  0, 72, 10, 60, 32, 64, 59,  0, 24],
+[ 0,  0,  0,  0,  0, 57,  0, 94,  0, 83, 20,  0,  0,  9, 31,  0, 49, 26, 58,  0],
+[ 0, 65, 56, 31, 64,  0,  0,  0,  0,  0,  0, 52, 85,  0,  0,  0,  0, 51,  0,  0],
+[ 0, 35,  0,  0,  0, 69,  0,  0, 64,  0,  0,  0,  0, 70,  0,  0, 90,  0, 75, 76],
+[69,  7,  0, 90,  0,  0, 84,  0, 47, 69, 19, 20, 42,  0,  0, 32, 71, 35,  0,  0],
+[39,  0, 90,  0,  0,  4, 85,  0,  0, 55,  0,  0,  0, 35, 67, 40,  0, 40,  0, 77],
+[98, 63,  0, 71,  0, 50,  0,  2, 61,  0, 38,  0,  0,  0,  0, 75,  0, 40, 33, 56],
+[ 0, 73,  0, 64,  0, 38,  0, 35, 61,  0,  0, 52,  0,  7,  0, 51,  0,  0,  0, 34],
+[ 0,  0, 28,  0, 34,  5, 63, 45, 14, 42, 60, 16, 76, 54, 99,  0, 28, 30,  0,  0],
+[58, 37, 14,  0,  0,  0, 94,  0,  0, 90,  0,  0,  0,  0,  0,  0,  0,  8, 90, 53],
+[86, 74, 94,  0, 49, 10, 60,  0, 40, 18,  0,  0,  0, 31, 60, 24,  0,  1,  0, 29],
+[53,  0,  0, 97,  0,  0, 58,  0,  0, 39, 44, 47,  0,  0,  0, 12, 50,  0,  0, 11],
+[ 4,  0, 92, 10, 28,  0,  0, 89,  0,  0, 18, 54, 23, 39,  0,  2,  0, 48,  0, 92],
+[ 0,  0, 90, 77, 95, 33,  0,  0, 49, 22, 39,  0,  0,  0,  0,  0,  0, 40,  0,  0],
+[96,  0,  0,  0,  0, 38, 86,  0, 22, 76,  0,  0,  0,  0, 83, 88, 95, 65, 72,  0],
+[81, 65,  0,  4, 60,  0, 19,  0,  0, 68,  0,  0, 89,  0, 67, 22,  0,  0, 55, 33]],
+           ZZ),
+        DM([
+[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]],
+           ZZ),
+        ZZ(1),
+    ),
+
+    (
+        'zz_large_3',
+        DM([
+[62,35,89,58,22,47,30,28,52,72,17,56,80,26,64,21,10,35,24,42,96,32,23,50,92,37,76,94,63,66],
+[20,47,96,34,10,98,19,6,29,2,19,92,61,94,38,41,32,9,5,94,31,58,27,41,72,85,61,62,40,46],
+[69,26,35,68,25,52,94,13,38,65,81,10,29,15,5,4,13,99,85,0,80,51,60,60,26,77,85,2,87,25],
+[99,58,69,15,52,12,18,7,27,56,12,54,21,92,38,95,33,83,28,1,44,8,29,84,92,12,2,25,46,46],
+[93,13,55,48,35,87,24,40,23,35,25,32,0,19,0,85,4,79,26,11,46,75,7,96,76,11,7,57,99,75],
+[128,85,26,51,161,173,77,78,85,103,123,58,91,147,38,91,161,36,123,81,102,25,75,59,17,150,112,65,77,143],
+[15,59,61,82,12,83,34,8,94,71,66,7,91,21,48,69,26,12,64,38,97,87,38,15,51,33,93,43,66,89],
+[74,74,53,39,69,90,41,80,32,66,40,83,87,87,61,38,12,80,24,49,37,90,19,33,56,0,46,57,56,60],
+[82,11,0,25,56,58,39,49,92,93,80,38,19,62,33,85,19,61,14,30,45,91,97,34,97,53,92,28,33,43],
+[83,79,41,16,95,35,53,45,26,4,71,76,61,69,69,72,87,92,59,72,54,11,22,83,8,57,77,55,19,22],
+[49,34,13,31,72,77,52,70,46,41,37,6,42,66,35,6,75,33,62,57,30,14,26,31,9,95,89,13,12,90],
+[29,3,49,30,51,32,77,41,38,50,16,1,87,81,93,88,58,91,83,0,38,67,29,64,60,84,5,60,23,28],
+[79,51,13,20,89,96,25,8,39,62,86,52,49,81,3,85,86,3,61,24,72,11,49,28,8,55,23,52,65,53],
+[96,86,73,20,41,20,37,18,10,61,85,24,40,83,69,41,4,92,23,99,64,33,18,36,32,56,60,98,39,24],
+[32,62,47,80,51,66,17,1,9,30,65,75,75,88,99,92,64,53,53,86,38,51,41,14,35,18,39,25,26,32],
+[39,21,8,16,33,6,35,85,75,62,43,34,18,68,71,28,32,18,12,0,81,53,1,99,3,5,45,99,35,33],
+[19,95,89,45,75,94,92,5,84,93,34,17,50,56,79,98,68,82,65,81,51,90,5,95,33,71,46,61,14,7],
+[53,92,8,49,67,84,21,79,49,95,66,48,36,14,62,97,26,45,58,31,83,48,11,89,67,72,91,34,56,89],
+[56,76,99,92,40,8,0,16,15,48,35,72,91,46,81,14,86,60,51,7,33,12,53,78,48,21,3,89,15,79],
+[81,43,33,49,6,49,36,32,57,74,87,91,17,37,31,17,67,1,40,38,69,8,3,48,59,37,64,97,11,3],
+[98,48,77,16,2,48,57,38,63,59,79,35,16,71,60,86,71,41,14,76,80,97,77,69,4,58,22,55,26,73],
+[80,47,78,44,31,48,47,29,29,62,19,21,17,24,19,3,53,93,97,57,13,54,12,10,77,66,60,75,32,21],
+[86,63,2,13,71,38,86,23,18,15,91,65,77,65,9,92,50,0,17,42,99,80,99,27,10,99,92,9,87,84],
+[66,27,72,13,13,15,72,75,39,3,14,71,15,68,10,19,49,54,11,29,47,20,63,13,97,47,24,62,16,96],
+[42,63,83,60,49,68,9,53,75,87,40,25,12,63,0,12,0,95,46,46,55,25,89,1,51,1,1,96,80,52],
+[35,9,97,13,86,39,66,48,41,57,23,38,11,9,35,72,88,13,41,60,10,64,71,23,1,5,23,57,6,19],
+[70,61,5,50,72,60,77,13,41,94,1,45,52,22,99,47,27,18,99,42,16,48,26,9,88,77,10,94,11,92],
+[55,68,58,2,72,56,81,52,79,37,1,40,21,46,27,60,37,13,97,42,85,98,69,60,76,44,42,46,29,73],
+[73,0,43,17,89,97,45,2,68,14,55,60,95,2,74,85,88,68,93,76,38,76,2,51,45,76,50,79,56,18],
+[72,58,41,39,24,80,23,79,44,7,98,75,30,6,85,60,20,58,77,71,90,51,38,80,30,15,33,10,82,8]],
+            ZZ),
+        Matrix([
+    [eye(29) * 2028539767964472550625641331179545072876560857886207583101,
+     Matrix([ 4260575808093245475167216057435155595594339172099000182569,
+              169148395880755256182802335904188369274227936894862744452,
+              4915975976683942569102447281579134986891620721539038348914,
+              6113916866367364958834844982578214901958429746875633283248,
+              5585689617819894460378537031623265659753379011388162534838,
+              359776822829880747716695359574308645968094838905181892423,
+              -2800926112141776386671436511182421432449325232461665113305,
+              941642292388230001722444876624818265766384442910688463158,
+              3648811843256146649321864698600908938933015862008642023935,
+              -4104526163246702252932955226754097174212129127510547462419,
+              -704814955438106792441896903238080197619233342348191408078,
+              1640882266829725529929398131287244562048075707575030019335,
+              -4068330845192910563212155694231438198040299927120544468520,
+              136589038308366497790495711534532612862715724187671166593,
+              2544937011460702462290799932536905731142196510605191645593,
+              755591839174293940486133926192300657264122907519174116472,
+              -3683838489869297144348089243628436188645897133242795965021,
+              -522207137101161299969706310062775465103537953077871128403,
+              -2260451796032703984456606059649402832441331339246756656334,
+              -6476809325293587953616004856993300606040336446656916663680,
+              3521944238996782387785653800944972787867472610035040989081,
+              2270762115788407950241944504104975551914297395787473242379,
+              -3259947194628712441902262570532921252128444706733549251156,
+              -5624569821491886970999097239695637132075823246850431083557,
+              -3262698255682055804320585332902837076064075936601504555698,
+              5786719943788937667411185880136324396357603606944869545501,
+              -955257841973865996077323863289453200904051299086000660036,
+              -1294235552446355326174641248209752679127075717918392702116,
+              -3718353510747301598130831152458342785269166356215331448279,
+             ]),],
+        [zeros(1, 29), zeros(1, 1)],
+        ]).to_DM().to_dense(),
+        ZZ(2028539767964472550625641331179545072876560857886207583101),
+    ),
+
+
+    (
+        'qq_1',
+        DM([[(1,2), 0], [0, 2]], QQ),
+        DM([[1, 0], [0, 1]], QQ),
+        QQ(1),
+    ),
+
+    (
+        # Standard square case
+        'qq_2',
+        DM([[0, 1],
+            [1, 1]], QQ),
+        DM([[1, 0],
+            [0, 1]], QQ),
+        QQ(1),
+    ),
+
+    (
+        # m < n  case
+        'qq_3',
+        DM([[1, 2, 1],
+            [3, 4, 1]], QQ),
+        DM([[1, 0, -1],
+            [0, 1,  1]], QQ),
+        QQ(1),
+    ),
+
+    (
+        # same m < n  but reversed
+        'qq_4',
+        DM([[3, 4, 1],
+            [1, 2, 1]], QQ),
+        DM([[1, 0, -1],
+            [0, 1,  1]], QQ),
+        QQ(1),
+    ),
+
+    (
+        # m > n case
+        'qq_5',
+        DM([[1, 0],
+            [1, 3],
+            [0, 1]], QQ),
+        DM([[1, 0],
+            [0, 1],
+            [0, 0]], QQ),
+        QQ(1),
+    ),
+
+    (
+        # Example with missing pivot
+        'qq_6',
+        DM([[1, 0, 1],
+            [3, 0, 1]], QQ),
+        DM([[1, 0, 0],
+            [0, 0, 1]], QQ),
+        QQ(1),
+    ),
+
+    (
+        # This is intended to trigger the threshold where we give up on
+        # clearing denominators.
+        'qq_large_1',
+        qq_large_1,
+        DomainMatrix.eye(11, QQ).to_dense(),
+        QQ(1),
+    ),
+
+    (
+        # This is intended to trigger the threshold where we use rref_den over
+        # QQ.
+        'qq_large_2',
+        qq_large_2,
+        DomainMatrix.eye(11, QQ).to_dense(),
+        QQ(1),
+    ),
+
+    (
+        # Example with missing pivot and no replacement
+
+        # This example is just enough to show a different result from the dense
+        # and sparse versions of the algorithm:
+        #
+        #   >>> A = Matrix([[0, 1], [0, 2], [1, 0]])
+        #   >>> A.to_DM().to_sparse().rref_den()[0].to_Matrix()
+        #   Matrix([
+        #   [1, 0],
+        #   [0, 1],
+        #   [0, 0]])
+        #   >>> A.to_DM().to_dense().rref_den()[0].to_Matrix()
+        #   Matrix([
+        #   [2, 0],
+        #   [0, 2],
+        #   [0, 0]])
+        #
+        'qq_7',
+        DM([[0, 1],
+            [0, 2],
+            [1, 0]], QQ),
+        DM([[1, 0],
+            [0, 1],
+            [0, 0]], QQ),
+        QQ(1),
+    ),
+
+    (
+        # Gaussian integers
+        'zz_i_1',
+        DM([[(0,1), 1, 1],
+            [    1, 1, 1]], ZZ_I),
+        DM([[1, 0, 0],
+            [0, 1, 1]], ZZ_I),
+        ZZ_I(1),
+    ),
+
+    (
+        # EX: test_issue_23718
+        'EX_1',
+        DM([
+        [a, b, 1],
+        [c, d, 1]], EX),
+        DM([[a*d - b*c,         0, -b + d],
+            [        0, a*d - b*c,  a - c]], EX),
+        EX(a*d - b*c),
+    ),
+
+]
+
+
+def _to_DM(A, ans):
+    """Convert the answer to DomainMatrix."""
+    if isinstance(A, DomainMatrix):
+        return A.to_dense()
+    elif isinstance(A, Matrix):
+        return A.to_DM(ans.domain).to_dense()
+
+    if not (hasattr(A, 'shape') and hasattr(A, 'domain')):
+        shape, domain = ans.shape, ans.domain
+    else:
+        shape, domain = A.shape, A.domain
+
+    if isinstance(A, (DDM, list)):
+        return DomainMatrix(list(A), shape, domain).to_dense()
+    elif isinstance(A, (SDM, dict)):
+        return DomainMatrix(dict(A), shape, domain).to_dense()
+    else:
+        assert False # pragma: no cover
+
+
+def _pivots(A_rref):
+    """Return the pivots from the rref of A."""
+    return tuple(sorted(map(min, A_rref.to_sdm().values())))
+
+
+def _check_cancel(result, rref_ans, den_ans):
+    """Check the cancelled result."""
+    rref, den, pivots = result
+    if isinstance(rref, (DDM, SDM, list, dict)):
+        assert type(pivots) is list
+        pivots = tuple(pivots)
+    rref = _to_DM(rref, rref_ans)
+    rref2, den2 = rref.cancel_denom(den)
+    assert rref2 == rref_ans
+    assert den2 == den_ans
+    assert pivots == _pivots(rref)
+
+
+def _check_divide(result, rref_ans, den_ans):
+    """Check the divided result."""
+    rref, pivots = result
+    if isinstance(rref, (DDM, SDM, list, dict)):
+        assert type(pivots) is list
+        pivots = tuple(pivots)
+    rref_ans = rref_ans.to_field() / den_ans
+    rref = _to_DM(rref, rref_ans)
+    assert rref == rref_ans
+    assert _pivots(rref) == pivots
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_Matrix_rref(name, A, A_rref, den):
+    K = A.domain
+    A = A.to_Matrix()
+    A_rref_found, pivots = A.rref()
+    if K.is_EX:
+        A_rref_found = A_rref_found.expand()
+    _check_divide((A_rref_found, pivots), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_dm_dense_rref(name, A, A_rref, den):
+    A = A.to_field()
+    _check_divide(A.rref(), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_dm_dense_rref_den(name, A, A_rref, den):
+    _check_cancel(A.rref_den(), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_dm_sparse_rref(name, A, A_rref, den):
+    A = A.to_field().to_sparse()
+    _check_divide(A.rref(), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_dm_sparse_rref_den(name, A, A_rref, den):
+    A = A.to_sparse()
+    _check_cancel(A.rref_den(), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_dm_sparse_rref_den_keep_domain(name, A, A_rref, den):
+    A = A.to_sparse()
+    A_rref_f, den_f, pivots_f = A.rref_den(keep_domain=False)
+    A_rref_f = A_rref_f.to_field() / den_f
+    _check_divide((A_rref_f, pivots_f), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_dm_sparse_rref_den_keep_domain_CD(name, A, A_rref, den):
+    A = A.to_sparse()
+    A_rref_f, den_f, pivots_f = A.rref_den(keep_domain=False, method='CD')
+    A_rref_f = A_rref_f.to_field() / den_f
+    _check_divide((A_rref_f, pivots_f), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_dm_sparse_rref_den_keep_domain_GJ(name, A, A_rref, den):
+    A = A.to_sparse()
+    A_rref_f, den_f, pivots_f = A.rref_den(keep_domain=False, method='GJ')
+    A_rref_f = A_rref_f.to_field() / den_f
+    _check_divide((A_rref_f, pivots_f), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_ddm_rref_den(name, A, A_rref, den):
+    A = A.to_ddm()
+    _check_cancel(A.rref_den(), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_sdm_rref_den(name, A, A_rref, den):
+    A = A.to_sdm()
+    _check_cancel(A.rref_den(), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_ddm_rref(name, A, A_rref, den):
+    A = A.to_field().to_ddm()
+    _check_divide(A.rref(), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_sdm_rref(name, A, A_rref, den):
+    A = A.to_field().to_sdm()
+    _check_divide(A.rref(), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_ddm_irref(name, A, A_rref, den):
+    A = A.to_field().to_ddm().copy()
+    pivots_found = ddm_irref(A)
+    _check_divide((A, pivots_found), A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_ddm_irref_den(name, A, A_rref, den):
+    A = A.to_ddm().copy()
+    (den_found, pivots_found) = ddm_irref_den(A, A.domain)
+    result = (A, den_found, pivots_found)
+    _check_cancel(result, A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_sparse_sdm_rref(name, A, A_rref, den):
+    A = A.to_field().to_sdm()
+    _check_divide(sdm_irref(A)[:2], A_rref, den)
+
+
+@pytest.mark.parametrize('name, A, A_rref, den', RREF_EXAMPLES)
+def test_sparse_sdm_rref_den(name, A, A_rref, den):
+    A = A.to_sdm().copy()
+    K = A.domain
+    _check_cancel(sdm_rref_den(A, K), A_rref, den)

llava_next/lib/python3.10/site-packages/sympy/polys/matrices/tests/test_xxm.py

@@ -0,0 +1,864 @@
+#
+# Test basic features of DDM, SDM and DFM.
+#
+# These three types are supposed to be interchangeable, so we should use the
+# same tests for all of them for the most part.
+#
+# The tests here cover the basic part of the inerface that the three types
+# should expose and that DomainMatrix should mostly rely on.
+#
+# More in-depth tests of the heavier algorithms like rref etc should go in
+# their own test files.
+#
+# Any new methods added to the DDM, SDM or DFM classes should be tested here
+# and added to all classes.
+#
+
+from sympy.external.gmpy import GROUND_TYPES
+
+from sympy import ZZ, QQ, GF, ZZ_I, symbols
+
+from sympy.polys.matrices.exceptions import (
+    DMBadInputError,
+    DMDomainError,
+    DMNonSquareMatrixError,
+    DMNonInvertibleMatrixError,
+    DMShapeError,
+)
+
+from sympy.polys.matrices.domainmatrix import DM, DomainMatrix, DDM, SDM, DFM
+
+from sympy.testing.pytest import raises, skip
+import pytest
+
+
+def test_XXM_constructors():
+    """Test the DDM, etc constructors."""
+
+    lol = [
+        [ZZ(1), ZZ(2)],
+        [ZZ(3), ZZ(4)],
+        [ZZ(5), ZZ(6)],
+    ]
+    dod = {
+        0: {0: ZZ(1), 1: ZZ(2)},
+        1: {0: ZZ(3), 1: ZZ(4)},
+        2: {0: ZZ(5), 1: ZZ(6)},
+    }
+
+    lol_0x0 = []
+    lol_0x2 = []
+    lol_2x0 = [[], []]
+    dod_0x0 = {}
+    dod_0x2 = {}
+    dod_2x0 = {}
+
+    lol_bad = [
+        [ZZ(1), ZZ(2)],
+        [ZZ(3), ZZ(4)],
+        [ZZ(5), ZZ(6), ZZ(7)],
+    ]
+    dod_bad = {
+        0: {0: ZZ(1), 1: ZZ(2)},
+        1: {0: ZZ(3), 1: ZZ(4)},
+        2: {0: ZZ(5), 1: ZZ(6), 2: ZZ(7)},
+    }
+
+    XDM_dense = [DDM]
+    XDM_sparse = [SDM]
+
+    if GROUND_TYPES == 'flint':
+        XDM_dense.append(DFM)
+
+    for XDM in XDM_dense:
+
+        A = XDM(lol, (3, 2), ZZ)
+        assert A.rows == 3
+        assert A.cols == 2
+        assert A.domain == ZZ
+        assert A.shape == (3, 2)
+        if XDM is not DFM:
+            assert ZZ.of_type(A[0][0]) is True
+        else:
+            assert ZZ.of_type(A.rep[0, 0]) is True
+
+        Adm = DomainMatrix(lol, (3, 2), ZZ)
+        if XDM is DFM:
+            assert Adm.rep == A
+            assert Adm.rep.to_ddm() != A
+        elif GROUND_TYPES == 'flint':
+            assert Adm.rep.to_ddm() == A
+            assert Adm.rep != A
+        else:
+            assert Adm.rep == A
+            assert Adm.rep.to_ddm() == A
+
+        assert XDM(lol_0x0, (0, 0), ZZ).shape == (0, 0)
+        assert XDM(lol_0x2, (0, 2), ZZ).shape == (0, 2)
+        assert XDM(lol_2x0, (2, 0), ZZ).shape == (2, 0)
+        raises(DMBadInputError, lambda: XDM(lol, (2, 3), ZZ))
+        raises(DMBadInputError, lambda: XDM(lol_bad, (3, 2), ZZ))
+        raises(DMBadInputError, lambda: XDM(dod, (3, 2), ZZ))
+
+    for XDM in XDM_sparse:
+
+        A = XDM(dod, (3, 2), ZZ)
+        assert A.rows == 3
+        assert A.cols == 2
+        assert A.domain == ZZ
+        assert A.shape == (3, 2)
+        assert ZZ.of_type(A[0][0]) is True
+
+        assert DomainMatrix(dod, (3, 2), ZZ).rep == A
+
+        assert XDM(dod_0x0, (0, 0), ZZ).shape == (0, 0)
+        assert XDM(dod_0x2, (0, 2), ZZ).shape == (0, 2)
+        assert XDM(dod_2x0, (2, 0), ZZ).shape == (2, 0)
+        raises(DMBadInputError, lambda: XDM(dod, (2, 3), ZZ))
+        raises(DMBadInputError, lambda: XDM(lol, (3, 2), ZZ))
+        raises(DMBadInputError, lambda: XDM(dod_bad, (3, 2), ZZ))
+
+    raises(DMBadInputError, lambda: DomainMatrix(lol, (2, 3), ZZ))
+    raises(DMBadInputError, lambda: DomainMatrix(lol_bad, (3, 2), ZZ))
+    raises(DMBadInputError, lambda: DomainMatrix(dod_bad, (3, 2), ZZ))
+
+
+def test_XXM_eq():
+    """Test equality for DDM, SDM, DFM and DomainMatrix."""
+
+    lol1 = [[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]]
+    dod1 = {0: {0: ZZ(1), 1: ZZ(2)}, 1: {0: ZZ(3), 1: ZZ(4)}}
+
+    lol2 = [[ZZ(1), ZZ(2)], [ZZ(3), ZZ(5)]]
+    dod2 = {0: {0: ZZ(1), 1: ZZ(2)}, 1: {0: ZZ(3), 1: ZZ(5)}}
+
+    A1_ddm = DDM(lol1, (2, 2), ZZ)
+    A1_sdm = SDM(dod1, (2, 2), ZZ)
+    A1_dm_d = DomainMatrix(lol1, (2, 2), ZZ)
+    A1_dm_s = DomainMatrix(dod1, (2, 2), ZZ)
+
+    A2_ddm = DDM(lol2, (2, 2), ZZ)
+    A2_sdm = SDM(dod2, (2, 2), ZZ)
+    A2_dm_d = DomainMatrix(lol2, (2, 2), ZZ)
+    A2_dm_s = DomainMatrix(dod2, (2, 2), ZZ)
+
+    A1_all = [A1_ddm, A1_sdm, A1_dm_d, A1_dm_s]
+    A2_all = [A2_ddm, A2_sdm, A2_dm_d, A2_dm_s]
+
+    if GROUND_TYPES == 'flint':
+
+        A1_dfm = DFM([[1, 2], [3, 4]], (2, 2), ZZ)
+        A2_dfm = DFM([[1, 2], [3, 5]], (2, 2), ZZ)
+
+        A1_all.append(A1_dfm)
+        A2_all.append(A2_dfm)
+
+    for n, An in enumerate(A1_all):
+        for m, Am in enumerate(A1_all):
+            if n == m:
+                assert (An == Am) is True
+                assert (An != Am) is False
+            else:
+                assert (An == Am) is False
+                assert (An != Am) is True
+
+    for n, An in enumerate(A2_all):
+        for m, Am in enumerate(A2_all):
+            if n == m:
+                assert (An == Am) is True
+                assert (An != Am) is False
+            else:
+                assert (An == Am) is False
+                assert (An != Am) is True
+
+    for n, A1 in enumerate(A1_all):
+        for m, A2 in enumerate(A2_all):
+            assert (A1 == A2) is False
+            assert (A1 != A2) is True
+
+
+def test_to_XXM():
+    """Test to_ddm etc. for DDM, SDM, DFM and DomainMatrix."""
+
+    lol = [[ZZ(1), ZZ(2)], [ZZ(3), ZZ(4)]]
+    dod = {0: {0: ZZ(1), 1: ZZ(2)}, 1: {0: ZZ(3), 1: ZZ(4)}}
+
+    A_ddm = DDM(lol, (2, 2), ZZ)
+    A_sdm = SDM(dod, (2, 2), ZZ)
+    A_dm_d = DomainMatrix(lol, (2, 2), ZZ)
+    A_dm_s = DomainMatrix(dod, (2, 2), ZZ)
+
+    A_all = [A_ddm, A_sdm, A_dm_d, A_dm_s]
+
+    if GROUND_TYPES == 'flint':
+        A_dfm = DFM(lol, (2, 2), ZZ)
+        A_all.append(A_dfm)
+
+    for A in A_all:
+        assert A.to_ddm() == A_ddm
+        assert A.to_sdm() == A_sdm
+        if GROUND_TYPES != 'flint':
+            raises(NotImplementedError, lambda: A.to_dfm())
+            assert A.to_dfm_or_ddm() == A_ddm
+
+        # Add e.g. DDM.to_DM()?
+        # assert A.to_DM() == A_dm
+
+    if GROUND_TYPES == 'flint':
+        for A in A_all:
+            assert A.to_dfm() == A_dfm
+            for K in [ZZ, QQ, GF(5), ZZ_I]:
+                if isinstance(A, DFM) and not DFM._supports_domain(K):
+                    raises(NotImplementedError, lambda: A.convert_to(K))
+                else:
+                    A_K = A.convert_to(K)
+                    if DFM._supports_domain(K):
+                        A_dfm_K = A_dfm.convert_to(K)
+                        assert A_K.to_dfm() == A_dfm_K
+                        assert A_K.to_dfm_or_ddm() == A_dfm_K
+                    else:
+                        raises(NotImplementedError, lambda: A_K.to_dfm())
+                        assert A_K.to_dfm_or_ddm() == A_ddm.convert_to(K)
+
+
+def test_DFM_domains():
+    """Test which domains are supported by DFM."""
+
+    x, y = symbols('x, y')
+
+    if GROUND_TYPES in ('python', 'gmpy'):
+
+        supported = []
+        flint_funcs = {}
+        not_supported = [ZZ, QQ, GF(5), QQ[x], QQ[x,y]]
+
+    elif GROUND_TYPES == 'flint':
+
+        import flint
+        supported = [ZZ, QQ]
+        flint_funcs = {
+            ZZ: flint.fmpz_mat,
+            QQ: flint.fmpq_mat,
+        }
+        not_supported = [
+            # This could be supported but not yet implemented in SymPy:
+            GF(5),
+            # Other domains could be supported but not implemented as matrices
+            # in python-flint:
+            QQ[x],
+            QQ[x,y],
+            QQ.frac_field(x,y),
+            # Others would potentially never be supported by python-flint:
+            ZZ_I,
+        ]
+
+    else:
+        assert False, "Unknown GROUND_TYPES: %s" % GROUND_TYPES
+
+    for domain in supported:
+        assert DFM._supports_domain(domain) is True
+        assert DFM._get_flint_func(domain) == flint_funcs[domain]
+    for domain in not_supported:
+        assert DFM._supports_domain(domain) is False
+        raises(NotImplementedError, lambda: DFM._get_flint_func(domain))
+
+
+def _DM(lol, typ, K):
+    """Make a DM of type typ over K from lol."""
+    A = DM(lol, K)
+
+    if typ == 'DDM':
+        return A.to_ddm()
+    elif typ == 'SDM':
+        return A.to_sdm()
+    elif typ == 'DFM':
+        if GROUND_TYPES != 'flint':
+            skip("DFM not supported in this ground type")
+        return A.to_dfm()
+    else:
+        assert False, "Unknown type %s" % typ
+
+
+def _DMZ(lol, typ):
+    """Make a DM of type typ over ZZ from lol."""
+    return _DM(lol, typ, ZZ)
+
+
+def _DMQ(lol, typ):
+    """Make a DM of type typ over QQ from lol."""
+    return _DM(lol, typ, QQ)
+
+
+def DM_ddm(lol, K):
+    """Make a DDM over K from lol."""
+    return _DM(lol, 'DDM', K)
+
+
+def DM_sdm(lol, K):
+    """Make a SDM over K from lol."""
+    return _DM(lol, 'SDM', K)
+
+
+def DM_dfm(lol, K):
+    """Make a DFM over K from lol."""
+    return _DM(lol, 'DFM', K)
+
+
+def DMZ_ddm(lol):
+    """Make a DDM from lol."""
+    return _DMZ(lol, 'DDM')
+
+
+def DMZ_sdm(lol):
+    """Make a SDM from lol."""
+    return _DMZ(lol, 'SDM')
+
+
+def DMZ_dfm(lol):
+    """Make a DFM from lol."""
+    return _DMZ(lol, 'DFM')
+
+
+def DMQ_ddm(lol):
+    """Make a DDM from lol."""
+    return _DMQ(lol, 'DDM')
+
+
+def DMQ_sdm(lol):
+    """Make a SDM from lol."""
+    return _DMQ(lol, 'SDM')
+
+
+def DMQ_dfm(lol):
+    """Make a DFM from lol."""
+    return _DMQ(lol, 'DFM')
+
+
+DM_all = [DM_ddm, DM_sdm, DM_dfm]
+DMZ_all = [DMZ_ddm, DMZ_sdm, DMZ_dfm]
+DMQ_all = [DMQ_ddm, DMQ_sdm, DMQ_dfm]
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XDM_getitem(DM):
+    """Test getitem for DDM, etc."""
+
+    lol = [[0, 1], [2, 0]]
+    A = DM(lol)
+    m, n = A.shape
+
+    indices = [-3, -2, -1, 0, 1, 2]
+
+    for i in indices:
+        for j in indices:
+            if -2 <= i < m and -2 <= j < n:
+                assert A.getitem(i, j) == ZZ(lol[i][j])
+            else:
+                raises(IndexError, lambda: A.getitem(i, j))
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XDM_setitem(DM):
+    """Test setitem for DDM, etc."""
+
+    A = DM([[0, 1, 2], [3, 4, 5]])
+
+    A.setitem(0, 0, ZZ(6))
+    assert A == DM([[6, 1, 2], [3, 4, 5]])
+
+    A.setitem(0, 1, ZZ(7))
+    assert A == DM([[6, 7, 2], [3, 4, 5]])
+
+    A.setitem(0, 2, ZZ(8))
+    assert A == DM([[6, 7, 8], [3, 4, 5]])
+
+    A.setitem(0, -1, ZZ(9))
+    assert A == DM([[6, 7, 9], [3, 4, 5]])
+
+    A.setitem(0, -2, ZZ(10))
+    assert A == DM([[6, 10, 9], [3, 4, 5]])
+
+    A.setitem(0, -3, ZZ(11))
+    assert A == DM([[11, 10, 9], [3, 4, 5]])
+
+    raises(IndexError, lambda: A.setitem(0, 3, ZZ(12)))
+    raises(IndexError, lambda: A.setitem(0, -4, ZZ(13)))
+
+    A.setitem(1, 0, ZZ(14))
+    assert A == DM([[11, 10, 9], [14, 4, 5]])
+
+    A.setitem(1, 1, ZZ(15))
+    assert A == DM([[11, 10, 9], [14, 15, 5]])
+
+    A.setitem(-1, 1, ZZ(16))
+    assert A == DM([[11, 10, 9], [14, 16, 5]])
+
+    A.setitem(-2, 1, ZZ(17))
+    assert A == DM([[11, 17, 9], [14, 16, 5]])
+
+    raises(IndexError, lambda: A.setitem(2, 0, ZZ(18)))
+    raises(IndexError, lambda: A.setitem(-3, 0, ZZ(19)))
+
+    A.setitem(1, 2, ZZ(0))
+    assert A == DM([[11, 17, 9], [14, 16, 0]])
+
+    A.setitem(1, -2, ZZ(0))
+    assert A == DM([[11, 17, 9], [14, 0, 0]])
+
+    A.setitem(1, -3, ZZ(0))
+    assert A == DM([[11, 17, 9], [0, 0, 0]])
+
+    A.setitem(0, 0, ZZ(0))
+    assert A == DM([[0, 17, 9], [0, 0, 0]])
+
+    A.setitem(0, -1, ZZ(0))
+    assert A == DM([[0, 17, 0], [0, 0, 0]])
+
+    A.setitem(0, 0, ZZ(0))
+    assert A == DM([[0, 17, 0], [0, 0, 0]])
+
+    A.setitem(0, -2, ZZ(0))
+    assert A == DM([[0, 0, 0], [0, 0, 0]])
+
+    A.setitem(0, -3, ZZ(1))
+    assert A == DM([[1, 0, 0], [0, 0, 0]])
+
+
+class _Sliced:
+    def __getitem__(self, item):
+        return item
+
+
+_slice = _Sliced()
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_extract_slice(DM):
+    A = DM([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    assert A.extract_slice(*_slice[:,:]) == A
+    assert A.extract_slice(*_slice[1:,:]) == DM([[4, 5, 6], [7, 8, 9]])
+    assert A.extract_slice(*_slice[1:,1:]) == DM([[5, 6], [8, 9]])
+    assert A.extract_slice(*_slice[1:,:-1]) == DM([[4, 5], [7, 8]])
+    assert A.extract_slice(*_slice[1:,:-1:2]) == DM([[4], [7]])
+    assert A.extract_slice(*_slice[:,::2]) == DM([[1, 3], [4, 6], [7, 9]])
+    assert A.extract_slice(*_slice[::2,:]) == DM([[1, 2, 3], [7, 8, 9]])
+    assert A.extract_slice(*_slice[::2,::2]) == DM([[1, 3], [7, 9]])
+    assert A.extract_slice(*_slice[::2,::-2]) == DM([[3, 1], [9, 7]])
+    assert A.extract_slice(*_slice[::-2,::2]) == DM([[7, 9], [1, 3]])
+    assert A.extract_slice(*_slice[::-2,::-2]) == DM([[9, 7], [3, 1]])
+    assert A.extract_slice(*_slice[:,::-1]) == DM([[3, 2, 1], [6, 5, 4], [9, 8, 7]])
+    assert A.extract_slice(*_slice[::-1,:]) == DM([[7, 8, 9], [4, 5, 6], [1, 2, 3]])
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_extract(DM):
+
+    A = DM([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+
+    assert A.extract([0, 1, 2], [0, 1, 2]) == A
+    assert A.extract([1, 2], [1, 2]) == DM([[5, 6], [8, 9]])
+    assert A.extract([1, 2], [0, 1]) == DM([[4, 5], [7, 8]])
+    assert A.extract([1, 2], [0, 2]) == DM([[4, 6], [7, 9]])
+    assert A.extract([1, 2], [0]) == DM([[4], [7]])
+    assert A.extract([1, 2], []) == DM([[1]]).zeros((2, 0), ZZ)
+    assert A.extract([], [0, 1, 2]) == DM([[1]]).zeros((0, 3), ZZ)
+
+    raises(IndexError, lambda: A.extract([1, 2], [0, 3]))
+    raises(IndexError, lambda: A.extract([1, 2], [0, -4]))
+    raises(IndexError, lambda: A.extract([3, 1], [0, 1]))
+    raises(IndexError, lambda: A.extract([-4, 2], [3, 1]))
+
+    B = DM([[0, 0, 0], [0, 0, 0], [0, 0, 0]])
+    assert B.extract([1, 2], [1, 2]) == DM([[0, 0], [0, 0]])
+
+
+def test_XXM_str():
+
+    A = DomainMatrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]], (3, 3), ZZ)
+
+    assert str(A) == \
+        'DomainMatrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]], (3, 3), ZZ)'
+    assert str(A.to_ddm()) == \
+        '[[1, 2, 3], [4, 5, 6], [7, 8, 9]]'
+    assert str(A.to_sdm()) == \
+        '{0: {0: 1, 1: 2, 2: 3}, 1: {0: 4, 1: 5, 2: 6}, 2: {0: 7, 1: 8, 2: 9}}'
+
+    assert repr(A) == \
+        'DomainMatrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]], (3, 3), ZZ)'
+    assert repr(A.to_ddm()) == \
+        'DDM([[1, 2, 3], [4, 5, 6], [7, 8, 9]], (3, 3), ZZ)'
+    assert repr(A.to_sdm()) == \
+        'SDM({0: {0: 1, 1: 2, 2: 3}, 1: {0: 4, 1: 5, 2: 6}, 2: {0: 7, 1: 8, 2: 9}}, (3, 3), ZZ)'
+
+    B = DomainMatrix({0: {0: ZZ(1), 1: ZZ(2)}, 1: {0: ZZ(3)}}, (2, 2), ZZ)
+
+    assert str(B) == \
+        'DomainMatrix({0: {0: 1, 1: 2}, 1: {0: 3}}, (2, 2), ZZ)'
+    assert str(B.to_ddm()) == \
+        '[[1, 2], [3, 0]]'
+    assert str(B.to_sdm()) == \
+        '{0: {0: 1, 1: 2}, 1: {0: 3}}'
+
+    assert repr(B) == \
+        'DomainMatrix({0: {0: 1, 1: 2}, 1: {0: 3}}, (2, 2), ZZ)'
+
+    if GROUND_TYPES != 'gmpy':
+        assert repr(B.to_ddm()) == \
+            'DDM([[1, 2], [3, 0]], (2, 2), ZZ)'
+        assert repr(B.to_sdm()) == \
+            'SDM({0: {0: 1, 1: 2}, 1: {0: 3}}, (2, 2), ZZ)'
+    else:
+        assert repr(B.to_ddm()) == \
+            'DDM([[mpz(1), mpz(2)], [mpz(3), mpz(0)]], (2, 2), ZZ)'
+        assert repr(B.to_sdm()) == \
+            'SDM({0: {0: mpz(1), 1: mpz(2)}, 1: {0: mpz(3)}}, (2, 2), ZZ)'
+
+    if GROUND_TYPES == 'flint':
+
+        assert str(A.to_dfm()) == \
+            '[[1, 2, 3], [4, 5, 6], [7, 8, 9]]'
+        assert str(B.to_dfm()) == \
+            '[[1, 2], [3, 0]]'
+
+        assert repr(A.to_dfm()) == \
+            'DFM([[1, 2, 3], [4, 5, 6], [7, 8, 9]], (3, 3), ZZ)'
+        assert repr(B.to_dfm()) == \
+            'DFM([[1, 2], [3, 0]], (2, 2), ZZ)'
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_from_list(DM):
+    T = type(DM([[0]]))
+
+    lol = [[1, 2, 4], [4, 5, 6]]
+    lol_ZZ = [[ZZ(1), ZZ(2), ZZ(4)], [ZZ(4), ZZ(5), ZZ(6)]]
+    lol_ZZ_bad = [[ZZ(1), ZZ(2), ZZ(4)], [ZZ(4), ZZ(5), ZZ(6), ZZ(7)]]
+
+    assert T.from_list(lol_ZZ, (2, 3), ZZ) == DM(lol)
+    raises(DMBadInputError, lambda: T.from_list(lol_ZZ_bad, (3, 2), ZZ))
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_to_list(DM):
+    lol = [[1, 2, 4], [4, 5, 6]]
+    assert DM(lol).to_list() == [[ZZ(1), ZZ(2), ZZ(4)], [ZZ(4), ZZ(5), ZZ(6)]]
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_to_list_flat(DM):
+    lol = [[1, 2, 4], [4, 5, 6]]
+    assert DM(lol).to_list_flat() == [ZZ(1), ZZ(2), ZZ(4), ZZ(4), ZZ(5), ZZ(6)]
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_from_list_flat(DM):
+    T = type(DM([[0]]))
+    flat = [ZZ(1), ZZ(2), ZZ(4), ZZ(4), ZZ(5), ZZ(6)]
+    assert T.from_list_flat(flat, (2, 3), ZZ) == DM([[1, 2, 4], [4, 5, 6]])
+    raises(DMBadInputError, lambda: T.from_list_flat(flat, (3, 3), ZZ))
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_to_flat_nz(DM):
+    M = DM([[1, 2, 0], [0, 0, 0], [0, 0, 3]])
+    elements = [ZZ(1), ZZ(2), ZZ(3)]
+    indices = ((0, 0), (0, 1), (2, 2))
+    assert M.to_flat_nz() == (elements, (indices, M.shape))
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_from_flat_nz(DM):
+    T = type(DM([[0]]))
+    elements = [ZZ(1), ZZ(2), ZZ(3)]
+    indices = ((0, 0), (0, 1), (2, 2))
+    data = (indices, (3, 3))
+    result = DM([[1, 2, 0], [0, 0, 0], [0, 0, 3]])
+    assert T.from_flat_nz(elements, data, ZZ) == result
+    raises(DMBadInputError, lambda: T.from_flat_nz(elements, (indices, (2, 3)), ZZ))
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_to_dod(DM):
+    dod = {0: {0: ZZ(1), 2: ZZ(4)}, 1: {0: ZZ(4), 1: ZZ(5), 2: ZZ(6)}}
+    assert DM([[1, 0, 4], [4, 5, 6]]).to_dod() == dod
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_from_dod(DM):
+    T = type(DM([[0]]))
+    dod = {0: {0: ZZ(1), 2: ZZ(4)}, 1: {0: ZZ(4), 1: ZZ(5), 2: ZZ(6)}}
+    assert T.from_dod(dod, (2, 3), ZZ) == DM([[1, 0, 4], [4, 5, 6]])
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_to_dok(DM):
+    dod = {(0, 0): ZZ(1), (0, 2): ZZ(4),
+           (1, 0): ZZ(4), (1, 1): ZZ(5), (1, 2): ZZ(6)}
+    assert DM([[1, 0, 4], [4, 5, 6]]).to_dok() == dod
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_from_dok(DM):
+    T = type(DM([[0]]))
+    dod = {(0, 0): ZZ(1), (0, 2): ZZ(4),
+           (1, 0): ZZ(4), (1, 1): ZZ(5), (1, 2): ZZ(6)}
+    assert T.from_dok(dod, (2, 3), ZZ) == DM([[1, 0, 4], [4, 5, 6]])
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_iter_values(DM):
+    values = [ZZ(1), ZZ(4), ZZ(4), ZZ(5), ZZ(6)]
+    assert sorted(DM([[1, 0, 4], [4, 5, 6]]).iter_values()) == values
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_iter_items(DM):
+    items = [((0, 0), ZZ(1)), ((0, 2), ZZ(4)),
+             ((1, 0), ZZ(4)), ((1, 1), ZZ(5)), ((1, 2), ZZ(6))]
+    assert sorted(DM([[1, 0, 4], [4, 5, 6]]).iter_items()) == items
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_from_ddm(DM):
+    T = type(DM([[0]]))
+    ddm = DDM([[1, 2, 4], [4, 5, 6]], (2, 3), ZZ)
+    assert T.from_ddm(ddm) == DM([[1, 2, 4], [4, 5, 6]])
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_zeros(DM):
+    T = type(DM([[0]]))
+    assert T.zeros((2, 3), ZZ) == DM([[0, 0, 0], [0, 0, 0]])
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_ones(DM):
+    T = type(DM([[0]]))
+    assert T.ones((2, 3), ZZ) == DM([[1, 1, 1], [1, 1, 1]])
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_eye(DM):
+    T = type(DM([[0]]))
+    assert T.eye(3, ZZ) == DM([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+    assert T.eye((3, 2), ZZ) == DM([[1, 0], [0, 1], [0, 0]])
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_diag(DM):
+    T = type(DM([[0]]))
+    assert T.diag([1, 2, 3], ZZ) == DM([[1, 0, 0], [0, 2, 0], [0, 0, 3]])
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_transpose(DM):
+    A = DM([[1, 2, 3], [4, 5, 6]])
+    assert A.transpose() == DM([[1, 4], [2, 5], [3, 6]])
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_add(DM):
+    A = DM([[1, 2, 3], [4, 5, 6]])
+    B = DM([[1, 2, 3], [4, 5, 6]])
+    C = DM([[2, 4, 6], [8, 10, 12]])
+    assert A.add(B) == C
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_sub(DM):
+    A = DM([[1, 2, 3], [4, 5, 6]])
+    B = DM([[1, 2, 3], [4, 5, 6]])
+    C = DM([[0, 0, 0], [0, 0, 0]])
+    assert A.sub(B) == C
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_mul(DM):
+    A = DM([[1, 2, 3], [4, 5, 6]])
+    b = ZZ(2)
+    assert A.mul(b) == DM([[2, 4, 6], [8, 10, 12]])
+    assert A.rmul(b) == DM([[2, 4, 6], [8, 10, 12]])
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_matmul(DM):
+    A = DM([[1, 2, 3], [4, 5, 6]])
+    B = DM([[1, 2], [3, 4], [5, 6]])
+    C = DM([[22, 28], [49, 64]])
+    assert A.matmul(B) == C
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_mul_elementwise(DM):
+    A = DM([[1, 2, 3], [4, 5, 6]])
+    B = DM([[1, 2, 3], [4, 5, 6]])
+    C = DM([[1, 4, 9], [16, 25, 36]])
+    assert A.mul_elementwise(B) == C
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_neg(DM):
+    A = DM([[1, 2, 3], [4, 5, 6]])
+    C = DM([[-1, -2, -3], [-4, -5, -6]])
+    assert A.neg() == C
+
+
+@pytest.mark.parametrize('DM', DM_all)
+def test_XXM_convert_to(DM):
+    A = DM([[1, 2, 3], [4, 5, 6]], ZZ)
+    B = DM([[1, 2, 3], [4, 5, 6]], QQ)
+    assert A.convert_to(QQ) == B
+    assert B.convert_to(ZZ) == A
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_scc(DM):
+    A = DM([
+        [0, 1, 0, 0, 0, 0],
+        [1, 0, 0, 0, 0, 0],
+        [0, 0, 1, 0, 0, 0],
+        [0, 0, 0, 1, 0, 1],
+        [0, 0, 0, 0, 1, 0],
+        [0, 0, 0, 1, 0, 1]])
+    assert A.scc() == [[0, 1], [2], [3, 5], [4]]
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_hstack(DM):
+    A = DM([[1, 2, 3], [4, 5, 6]])
+    B = DM([[7, 8], [9, 10]])
+    C = DM([[1, 2, 3, 7, 8], [4, 5, 6, 9, 10]])
+    ABC = DM([[1, 2, 3, 7, 8, 1, 2, 3, 7, 8],
+              [4, 5, 6, 9, 10, 4, 5, 6, 9, 10]])
+    assert A.hstack(B) == C
+    assert A.hstack(B, C) == ABC
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_vstack(DM):
+    A = DM([[1, 2, 3], [4, 5, 6]])
+    B = DM([[7, 8, 9]])
+    C = DM([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    ABC = DM([[1, 2, 3], [4, 5, 6], [7, 8, 9], [1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    assert A.vstack(B) == C
+    assert A.vstack(B, C) == ABC
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_applyfunc(DM):
+    A = DM([[1, 2, 3], [4, 5, 6]])
+    B = DM([[2, 4, 6], [8, 10, 12]])
+    assert A.applyfunc(lambda x: 2*x, ZZ) == B
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_is_upper(DM):
+    assert DM([[1, 2, 3], [0, 5, 6]]).is_upper() is True
+    assert DM([[1, 2, 3], [4, 5, 6]]).is_upper() is False
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_is_lower(DM):
+    assert DM([[1, 0, 0], [4, 5, 0]]).is_lower() is True
+    assert DM([[1, 2, 3], [4, 5, 6]]).is_lower() is False
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_is_diagonal(DM):
+    assert DM([[1, 0, 0], [0, 5, 0]]).is_diagonal() is True
+    assert DM([[1, 2, 3], [4, 5, 6]]).is_diagonal() is False
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_diagonal(DM):
+    assert DM([[1, 0, 0], [0, 5, 0]]).diagonal() == [1, 5]
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_is_zero_matrix(DM):
+    assert DM([[0, 0, 0], [0, 0, 0]]).is_zero_matrix() is True
+    assert DM([[1, 0, 0], [0, 0, 0]]).is_zero_matrix() is False
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_det_ZZ(DM):
+    assert DM([[1, 2, 3], [4, 5, 6], [7, 8, 9]]).det() == 0
+    assert DM([[1, 2, 3], [4, 5, 6], [7, 8, 10]]).det() == -3
+
+
+@pytest.mark.parametrize('DM', DMQ_all)
+def test_XXM_det_QQ(DM):
+    dM1 = DM([[(1,2), (2,3)], [(3,4), (4,5)]])
+    assert dM1.det() == QQ(-1,10)
+
+
+@pytest.mark.parametrize('DM', DMQ_all)
+def test_XXM_inv_QQ(DM):
+    dM1 = DM([[(1,2), (2,3)], [(3,4), (4,5)]])
+    dM2 = DM([[(-8,1), (20,3)], [(15,2), (-5,1)]])
+    assert dM1.inv() == dM2
+    assert dM1.matmul(dM2) == DM([[1, 0], [0, 1]])
+
+    dM3 = DM([[(1,2), (2,3)], [(1,4), (1,3)]])
+    raises(DMNonInvertibleMatrixError, lambda: dM3.inv())
+
+    dM4 = DM([[(1,2), (2,3), (3,4)], [(1,4), (1,3), (1,2)]])
+    raises(DMNonSquareMatrixError, lambda: dM4.inv())
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_inv_ZZ(DM):
+    dM1 = DM([[1, 2, 3], [4, 5, 6], [7, 8, 10]])
+    # XXX: Maybe this should return a DM over QQ instead?
+    # XXX: Handle unimodular matrices?
+    raises(DMDomainError, lambda: dM1.inv())
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_charpoly_ZZ(DM):
+    dM1 = DM([[1, 2, 3], [4, 5, 6], [7, 8, 10]])
+    assert dM1.charpoly() == [1, -16, -12, 3]
+
+
+@pytest.mark.parametrize('DM', DMQ_all)
+def test_XXM_charpoly_QQ(DM):
+    dM1 = DM([[(1,2), (2,3)], [(3,4), (4,5)]])
+    assert dM1.charpoly() == [QQ(1,1), QQ(-13,10), QQ(-1,10)]
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_lu_solve_ZZ(DM):
+    dM1 = DM([[1, 2, 3], [4, 5, 6], [7, 8, 10]])
+    dM2 = DM([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+    raises(DMDomainError, lambda: dM1.lu_solve(dM2))
+
+
+@pytest.mark.parametrize('DM', DMQ_all)
+def test_XXM_lu_solve_QQ(DM):
+    dM1 = DM([[1, 2, 3], [4, 5, 6], [7, 8, 10]])
+    dM2 = DM([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+    dM3 = DM([[(-2,3),(-4,3),(1,1)],[(-2,3),(11,3),(-2,1)],[(1,1),(-2,1),(1,1)]])
+    assert dM1.lu_solve(dM2) == dM3 == dM1.inv()
+
+    dM4 = DM([[1, 2, 3], [4, 5, 6]])
+    dM5 = DM([[1, 0], [0, 1], [0, 0]])
+    raises(DMShapeError, lambda: dM4.lu_solve(dM5))
+
+
+@pytest.mark.parametrize('DM', DMQ_all)
+def test_XXM_nullspace_QQ(DM):
+    dM1 = DM([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    # XXX: Change the signature to just return the nullspace. Possibly
+    # returning the rank or nullity makes sense but the list of nonpivots is
+    # not useful.
+    assert dM1.nullspace() == (DM([[1, -2, 1]]), [2])
+
+
+@pytest.mark.parametrize('DM', DMZ_all)
+def test_XXM_lll(DM):
+    M = DM([[1, 2, 3], [4, 5, 20]])
+    M_lll = DM([[1, 2, 3], [-1, -5, 5]])
+    T = DM([[1, 0], [-5, 1]])
+    assert M.lll() == M_lll
+    assert M.lll_transform() == (M_lll, T)
+    assert T.matmul(M) == M_lll

vlmpy310/lib/python3.10/site-packages/babel/locale-data/bn.dat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c917a9df4b64c5204a90e82d216cd9044d58de9973b42228bbc5a285a9d6f12c
+size 217482

vlmpy310/lib/python3.10/site-packages/babel/locale-data/gu.dat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d8b0511cdf49a126ff45e012b09b5598f597086e6b2e69a2a5078e9565fa8f4f
+size 206876

vlmpy310/lib/python3.10/site-packages/babel/locale-data/he.dat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:67d34108712607c9287293ce141a82b87c340fc0cc8c1661e9ca71c91727885f
+size 219719

vlmpy310/lib/python3.10/site-packages/babel/locale-data/so.dat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a3e3818cddb2df338dc9156c49b32091b6545428e20d3a7bfd490b782ee4fa6d
+size 162786

vlmpy310/lib/python3.10/site-packages/babel/locale-data/zh_Hant.dat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d57035e407e1ecfff4e17654e5c23048760ab1fc2152c122146c5599da09910
+size 153398

vlmpy310/lib/python3.10/site-packages/msgpack/__init__.py

@@ -0,0 +1,55 @@
+# ruff: noqa: F401
+import os
+
+from .exceptions import *  # noqa: F403
+from .ext import ExtType, Timestamp
+
+version = (1, 1, 0)
+__version__ = "1.1.0"
+
+
+if os.environ.get("MSGPACK_PUREPYTHON"):
+    from .fallback import Packer, Unpacker, unpackb
+else:
+    try:
+        from ._cmsgpack import Packer, Unpacker, unpackb
+    except ImportError:
+        from .fallback import Packer, Unpacker, unpackb
+
+
+def pack(o, stream, **kwargs):
+    """
+    Pack object `o` and write it to `stream`
+
+    See :class:`Packer` for options.
+    """
+    packer = Packer(**kwargs)
+    stream.write(packer.pack(o))
+
+
+def packb(o, **kwargs):
+    """
+    Pack object `o` and return packed bytes
+
+    See :class:`Packer` for options.
+    """
+    return Packer(**kwargs).pack(o)
+
+
+def unpack(stream, **kwargs):
+    """
+    Unpack an object from `stream`.
+
+    Raises `ExtraData` when `stream` contains extra bytes.
+    See :class:`Unpacker` for options.
+    """
+    data = stream.read()
+    return unpackb(data, **kwargs)
+
+
+# alias for compatibility to simplejson/marshal/pickle.
+load = unpack
+loads = unpackb
+
+dump = pack
+dumps = packb

vlmpy310/lib/python3.10/site-packages/msgpack/exceptions.py

@@ -0,0 +1,48 @@
+class UnpackException(Exception):
+    """Base class for some exceptions raised while unpacking.
+
+    NOTE: unpack may raise exception other than subclass of
+    UnpackException.  If you want to catch all error, catch
+    Exception instead.
+    """
+
+
+class BufferFull(UnpackException):
+    pass
+
+
+class OutOfData(UnpackException):
+    pass
+
+
+class FormatError(ValueError, UnpackException):
+    """Invalid msgpack format"""
+
+
+class StackError(ValueError, UnpackException):
+    """Too nested"""
+
+
+# Deprecated.  Use ValueError instead
+UnpackValueError = ValueError
+
+
+class ExtraData(UnpackValueError):
+    """ExtraData is raised when there is trailing data.
+
+    This exception is raised while only one-shot (not streaming)
+    unpack.
+    """
+
+    def __init__(self, unpacked, extra):
+        self.unpacked = unpacked
+        self.extra = extra
+
+    def __str__(self):
+        return "unpack(b) received extra data."
+
+
+# Deprecated.  Use Exception instead to catch all exception during packing.
+PackException = Exception
+PackValueError = ValueError
+PackOverflowError = OverflowError

vlmpy310/lib/python3.10/site-packages/msgpack/ext.py

@@ -0,0 +1,170 @@
+import datetime
+import struct
+from collections import namedtuple
+
+
+class ExtType(namedtuple("ExtType", "code data")):
+    """ExtType represents ext type in msgpack."""
+
+    def __new__(cls, code, data):
+        if not isinstance(code, int):
+            raise TypeError("code must be int")
+        if not isinstance(data, bytes):
+            raise TypeError("data must be bytes")
+        if not 0 <= code <= 127:
+            raise ValueError("code must be 0~127")
+        return super().__new__(cls, code, data)
+
+
+class Timestamp:
+    """Timestamp represents the Timestamp extension type in msgpack.
+
+    When built with Cython, msgpack uses C methods to pack and unpack `Timestamp`.
+    When using pure-Python msgpack, :func:`to_bytes` and :func:`from_bytes` are used to pack and
+    unpack `Timestamp`.
+
+    This class is immutable: Do not override seconds and nanoseconds.
+    """
+
+    __slots__ = ["seconds", "nanoseconds"]
+
+    def __init__(self, seconds, nanoseconds=0):
+        """Initialize a Timestamp object.
+
+        :param int seconds:
+            Number of seconds since the UNIX epoch (00:00:00 UTC Jan 1 1970, minus leap seconds).
+            May be negative.
+
+        :param int nanoseconds:
+            Number of nanoseconds to add to `seconds` to get fractional time.
+            Maximum is 999_999_999.  Default is 0.
+
+        Note: Negative times (before the UNIX epoch) are represented as neg. seconds + pos. ns.
+        """
+        if not isinstance(seconds, int):
+            raise TypeError("seconds must be an integer")
+        if not isinstance(nanoseconds, int):
+            raise TypeError("nanoseconds must be an integer")
+        if not (0 <= nanoseconds < 10**9):
+            raise ValueError("nanoseconds must be a non-negative integer less than 999999999.")
+        self.seconds = seconds
+        self.nanoseconds = nanoseconds
+
+    def __repr__(self):
+        """String representation of Timestamp."""
+        return f"Timestamp(seconds={self.seconds}, nanoseconds={self.nanoseconds})"
+
+    def __eq__(self, other):
+        """Check for equality with another Timestamp object"""
+        if type(other) is self.__class__:
+            return self.seconds == other.seconds and self.nanoseconds == other.nanoseconds
+        return False
+
+    def __ne__(self, other):
+        """not-equals method (see :func:`__eq__()`)"""
+        return not self.__eq__(other)
+
+    def __hash__(self):
+        return hash((self.seconds, self.nanoseconds))
+
+    @staticmethod
+    def from_bytes(b):
+        """Unpack bytes into a `Timestamp` object.
+
+        Used for pure-Python msgpack unpacking.
+
+        :param b: Payload from msgpack ext message with code -1
+        :type b: bytes
+
+        :returns: Timestamp object unpacked from msgpack ext payload
+        :rtype: Timestamp
+        """
+        if len(b) == 4:
+            seconds = struct.unpack("!L", b)[0]
+            nanoseconds = 0
+        elif len(b) == 8:
+            data64 = struct.unpack("!Q", b)[0]
+            seconds = data64 & 0x00000003FFFFFFFF
+            nanoseconds = data64 >> 34
+        elif len(b) == 12:
+            nanoseconds, seconds = struct.unpack("!Iq", b)
+        else:
+            raise ValueError(
+                "Timestamp type can only be created from 32, 64, or 96-bit byte objects"
+            )
+        return Timestamp(seconds, nanoseconds)
+
+    def to_bytes(self):
+        """Pack this Timestamp object into bytes.
+
+        Used for pure-Python msgpack packing.
+
+        :returns data: Payload for EXT message with code -1 (timestamp type)
+        :rtype: bytes
+        """
+        if (self.seconds >> 34) == 0:  # seconds is non-negative and fits in 34 bits
+            data64 = self.nanoseconds << 34 | self.seconds
+            if data64 & 0xFFFFFFFF00000000 == 0:
+                # nanoseconds is zero and seconds < 2**32, so timestamp 32
+                data = struct.pack("!L", data64)
+            else:
+                # timestamp 64
+                data = struct.pack("!Q", data64)
+        else:
+            # timestamp 96
+            data = struct.pack("!Iq", self.nanoseconds, self.seconds)
+        return data
+
+    @staticmethod
+    def from_unix(unix_sec):
+        """Create a Timestamp from posix timestamp in seconds.
+
+        :param unix_float: Posix timestamp in seconds.
+        :type unix_float: int or float
+        """
+        seconds = int(unix_sec // 1)
+        nanoseconds = int((unix_sec % 1) * 10**9)
+        return Timestamp(seconds, nanoseconds)
+
+    def to_unix(self):
+        """Get the timestamp as a floating-point value.
+
+        :returns: posix timestamp
+        :rtype: float
+        """
+        return self.seconds + self.nanoseconds / 1e9
+
+    @staticmethod
+    def from_unix_nano(unix_ns):
+        """Create a Timestamp from posix timestamp in nanoseconds.
+
+        :param int unix_ns: Posix timestamp in nanoseconds.
+        :rtype: Timestamp
+        """
+        return Timestamp(*divmod(unix_ns, 10**9))
+
+    def to_unix_nano(self):
+        """Get the timestamp as a unixtime in nanoseconds.
+
+        :returns: posix timestamp in nanoseconds
+        :rtype: int
+        """
+        return self.seconds * 10**9 + self.nanoseconds
+
+    def to_datetime(self):
+        """Get the timestamp as a UTC datetime.
+
+        :rtype: `datetime.datetime`
+        """
+        utc = datetime.timezone.utc
+        return datetime.datetime.fromtimestamp(0, utc) + datetime.timedelta(
+            seconds=self.seconds, microseconds=self.nanoseconds // 1000
+        )
+
+    @staticmethod
+    def from_datetime(dt):
+        """Create a Timestamp from datetime with tzinfo.
+
+        :rtype: Timestamp
+        """
+        return Timestamp(seconds=int(dt.timestamp()), nanoseconds=dt.microsecond * 1000)

vlmpy310/lib/python3.10/site-packages/msgpack/fallback.py

@@ -0,0 +1,929 @@
+"""Fallback pure Python implementation of msgpack"""
+
+import struct
+import sys
+from datetime import datetime as _DateTime
+
+if hasattr(sys, "pypy_version_info"):
+    from __pypy__ import newlist_hint
+    from __pypy__.builders import BytesBuilder
+
+    _USING_STRINGBUILDER = True
+
+    class BytesIO:
+        def __init__(self, s=b""):
+            if s:
+                self.builder = BytesBuilder(len(s))
+                self.builder.append(s)
+            else:
+                self.builder = BytesBuilder()
+
+        def write(self, s):
+            if isinstance(s, memoryview):
+                s = s.tobytes()
+            elif isinstance(s, bytearray):
+                s = bytes(s)
+            self.builder.append(s)
+
+        def getvalue(self):
+            return self.builder.build()
+
+else:
+    from io import BytesIO
+
+    _USING_STRINGBUILDER = False
+
+    def newlist_hint(size):
+        return []
+
+
+from .exceptions import BufferFull, ExtraData, FormatError, OutOfData, StackError
+from .ext import ExtType, Timestamp
+
+EX_SKIP = 0
+EX_CONSTRUCT = 1
+EX_READ_ARRAY_HEADER = 2
+EX_READ_MAP_HEADER = 3
+
+TYPE_IMMEDIATE = 0
+TYPE_ARRAY = 1
+TYPE_MAP = 2
+TYPE_RAW = 3
+TYPE_BIN = 4
+TYPE_EXT = 5
+
+DEFAULT_RECURSE_LIMIT = 511
+
+
+def _check_type_strict(obj, t, type=type, tuple=tuple):
+    if type(t) is tuple:
+        return type(obj) in t
+    else:
+        return type(obj) is t
+
+
+def _get_data_from_buffer(obj):
+    view = memoryview(obj)
+    if view.itemsize != 1:
+        raise ValueError("cannot unpack from multi-byte object")
+    return view
+
+
+def unpackb(packed, **kwargs):
+    """
+    Unpack an object from `packed`.
+
+    Raises ``ExtraData`` when *packed* contains extra bytes.
+    Raises ``ValueError`` when *packed* is incomplete.
+    Raises ``FormatError`` when *packed* is not valid msgpack.
+    Raises ``StackError`` when *packed* contains too nested.
+    Other exceptions can be raised during unpacking.
+
+    See :class:`Unpacker` for options.
+    """
+    unpacker = Unpacker(None, max_buffer_size=len(packed), **kwargs)
+    unpacker.feed(packed)
+    try:
+        ret = unpacker._unpack()
+    except OutOfData:
+        raise ValueError("Unpack failed: incomplete input")
+    except RecursionError:
+        raise StackError
+    if unpacker._got_extradata():
+        raise ExtraData(ret, unpacker._get_extradata())
+    return ret
+
+
+_NO_FORMAT_USED = ""
+_MSGPACK_HEADERS = {
+    0xC4: (1, _NO_FORMAT_USED, TYPE_BIN),
+    0xC5: (2, ">H", TYPE_BIN),
+    0xC6: (4, ">I", TYPE_BIN),
+    0xC7: (2, "Bb", TYPE_EXT),
+    0xC8: (3, ">Hb", TYPE_EXT),
+    0xC9: (5, ">Ib", TYPE_EXT),
+    0xCA: (4, ">f"),
+    0xCB: (8, ">d"),
+    0xCC: (1, _NO_FORMAT_USED),
+    0xCD: (2, ">H"),
+    0xCE: (4, ">I"),
+    0xCF: (8, ">Q"),
+    0xD0: (1, "b"),
+    0xD1: (2, ">h"),
+    0xD2: (4, ">i"),
+    0xD3: (8, ">q"),
+    0xD4: (1, "b1s", TYPE_EXT),
+    0xD5: (2, "b2s", TYPE_EXT),
+    0xD6: (4, "b4s", TYPE_EXT),
+    0xD7: (8, "b8s", TYPE_EXT),
+    0xD8: (16, "b16s", TYPE_EXT),
+    0xD9: (1, _NO_FORMAT_USED, TYPE_RAW),
+    0xDA: (2, ">H", TYPE_RAW),
+    0xDB: (4, ">I", TYPE_RAW),
+    0xDC: (2, ">H", TYPE_ARRAY),
+    0xDD: (4, ">I", TYPE_ARRAY),
+    0xDE: (2, ">H", TYPE_MAP),
+    0xDF: (4, ">I", TYPE_MAP),
+}
+
+
+class Unpacker:
+    """Streaming unpacker.
+
+    Arguments:
+
+    :param file_like:
+        File-like object having `.read(n)` method.
+        If specified, unpacker reads serialized data from it and `.feed()` is not usable.
+
+    :param int read_size:
+        Used as `file_like.read(read_size)`. (default: `min(16*1024, max_buffer_size)`)
+
+    :param bool use_list:
+        If true, unpack msgpack array to Python list.
+        Otherwise, unpack to Python tuple. (default: True)
+
+    :param bool raw:
+        If true, unpack msgpack raw to Python bytes.
+        Otherwise, unpack to Python str by decoding with UTF-8 encoding (default).
+
+    :param int timestamp:
+        Control how timestamp type is unpacked:
+
+            0 - Timestamp
+            1 - float  (Seconds from the EPOCH)
+            2 - int  (Nanoseconds from the EPOCH)
+            3 - datetime.datetime  (UTC).
+
+    :param bool strict_map_key:
+        If true (default), only str or bytes are accepted for map (dict) keys.
+
+    :param object_hook:
+        When specified, it should be callable.
+        Unpacker calls it with a dict argument after unpacking msgpack map.
+        (See also simplejson)
+
+    :param object_pairs_hook:
+        When specified, it should be callable.
+        Unpacker calls it with a list of key-value pairs after unpacking msgpack map.
+        (See also simplejson)
+
+    :param str unicode_errors:
+        The error handler for decoding unicode. (default: 'strict')
+        This option should be used only when you have msgpack data which
+        contains invalid UTF-8 string.
+
+    :param int max_buffer_size:
+        Limits size of data waiting unpacked.  0 means 2**32-1.
+        The default value is 100*1024*1024 (100MiB).
+        Raises `BufferFull` exception when it is insufficient.
+        You should set this parameter when unpacking data from untrusted source.
+
+    :param int max_str_len:
+        Deprecated, use *max_buffer_size* instead.
+        Limits max length of str. (default: max_buffer_size)
+
+    :param int max_bin_len:
+        Deprecated, use *max_buffer_size* instead.
+        Limits max length of bin. (default: max_buffer_size)
+
+    :param int max_array_len:
+        Limits max length of array.
+        (default: max_buffer_size)
+
+    :param int max_map_len:
+        Limits max length of map.
+        (default: max_buffer_size//2)
+
+    :param int max_ext_len:
+        Deprecated, use *max_buffer_size* instead.
+        Limits max size of ext type.  (default: max_buffer_size)
+
+    Example of streaming deserialize from file-like object::
+
+        unpacker = Unpacker(file_like)
+        for o in unpacker:
+            process(o)
+
+    Example of streaming deserialize from socket::
+
+        unpacker = Unpacker()
+        while True:
+            buf = sock.recv(1024**2)
+            if not buf:
+                break
+            unpacker.feed(buf)
+            for o in unpacker:
+                process(o)
+
+    Raises ``ExtraData`` when *packed* contains extra bytes.
+    Raises ``OutOfData`` when *packed* is incomplete.
+    Raises ``FormatError`` when *packed* is not valid msgpack.
+    Raises ``StackError`` when *packed* contains too nested.
+    Other exceptions can be raised during unpacking.
+    """
+
+    def __init__(
+        self,
+        file_like=None,
+        *,
+        read_size=0,
+        use_list=True,
+        raw=False,
+        timestamp=0,
+        strict_map_key=True,
+        object_hook=None,
+        object_pairs_hook=None,
+        list_hook=None,
+        unicode_errors=None,
+        max_buffer_size=100 * 1024 * 1024,
+        ext_hook=ExtType,
+        max_str_len=-1,
+        max_bin_len=-1,
+        max_array_len=-1,
+        max_map_len=-1,
+        max_ext_len=-1,
+    ):
+        if unicode_errors is None:
+            unicode_errors = "strict"
+
+        if file_like is None:
+            self._feeding = True
+        else:
+            if not callable(file_like.read):
+                raise TypeError("`file_like.read` must be callable")
+            self.file_like = file_like
+            self._feeding = False
+
+        #: array of bytes fed.
+        self._buffer = bytearray()
+        #: Which position we currently reads
+        self._buff_i = 0
+
+        # When Unpacker is used as an iterable, between the calls to next(),
+        # the buffer is not "consumed" completely, for efficiency sake.
+        # Instead, it is done sloppily.  To make sure we raise BufferFull at
+        # the correct moments, we have to keep track of how sloppy we were.
+        # Furthermore, when the buffer is incomplete (that is: in the case
+        # we raise an OutOfData) we need to rollback the buffer to the correct
+        # state, which _buf_checkpoint records.
+        self._buf_checkpoint = 0
+
+        if not max_buffer_size:
+            max_buffer_size = 2**31 - 1
+        if max_str_len == -1:
+            max_str_len = max_buffer_size
+        if max_bin_len == -1:
+            max_bin_len = max_buffer_size
+        if max_array_len == -1:
+            max_array_len = max_buffer_size
+        if max_map_len == -1:
+            max_map_len = max_buffer_size // 2
+        if max_ext_len == -1:
+            max_ext_len = max_buffer_size
+
+        self._max_buffer_size = max_buffer_size
+        if read_size > self._max_buffer_size:
+            raise ValueError("read_size must be smaller than max_buffer_size")
+        self._read_size = read_size or min(self._max_buffer_size, 16 * 1024)
+        self._raw = bool(raw)
+        self._strict_map_key = bool(strict_map_key)
+        self._unicode_errors = unicode_errors
+        self._use_list = use_list
+        if not (0 <= timestamp <= 3):
+            raise ValueError("timestamp must be 0..3")
+        self._timestamp = timestamp
+        self._list_hook = list_hook
+        self._object_hook = object_hook
+        self._object_pairs_hook = object_pairs_hook
+        self._ext_hook = ext_hook
+        self._max_str_len = max_str_len
+        self._max_bin_len = max_bin_len
+        self._max_array_len = max_array_len
+        self._max_map_len = max_map_len
+        self._max_ext_len = max_ext_len
+        self._stream_offset = 0
+
+        if list_hook is not None and not callable(list_hook):
+            raise TypeError("`list_hook` is not callable")
+        if object_hook is not None and not callable(object_hook):
+            raise TypeError("`object_hook` is not callable")
+        if object_pairs_hook is not None and not callable(object_pairs_hook):
+            raise TypeError("`object_pairs_hook` is not callable")
+        if object_hook is not None and object_pairs_hook is not None:
+            raise TypeError("object_pairs_hook and object_hook are mutually exclusive")
+        if not callable(ext_hook):
+            raise TypeError("`ext_hook` is not callable")
+
+    def feed(self, next_bytes):
+        assert self._feeding
+        view = _get_data_from_buffer(next_bytes)
+        if len(self._buffer) - self._buff_i + len(view) > self._max_buffer_size:
+            raise BufferFull
+
+        # Strip buffer before checkpoint before reading file.
+        if self._buf_checkpoint > 0:
+            del self._buffer[: self._buf_checkpoint]
+            self._buff_i -= self._buf_checkpoint
+            self._buf_checkpoint = 0
+
+        # Use extend here: INPLACE_ADD += doesn't reliably typecast memoryview in jython
+        self._buffer.extend(view)
+        view.release()
+
+    def _consume(self):
+        """Gets rid of the used parts of the buffer."""
+        self._stream_offset += self._buff_i - self._buf_checkpoint
+        self._buf_checkpoint = self._buff_i
+
+    def _got_extradata(self):
+        return self._buff_i < len(self._buffer)
+
+    def _get_extradata(self):
+        return self._buffer[self._buff_i :]
+
+    def read_bytes(self, n):
+        ret = self._read(n, raise_outofdata=False)
+        self._consume()
+        return ret
+
+    def _read(self, n, raise_outofdata=True):
+        # (int) -> bytearray
+        self._reserve(n, raise_outofdata=raise_outofdata)
+        i = self._buff_i
+        ret = self._buffer[i : i + n]
+        self._buff_i = i + len(ret)
+        return ret
+
+    def _reserve(self, n, raise_outofdata=True):
+        remain_bytes = len(self._buffer) - self._buff_i - n
+
+        # Fast path: buffer has n bytes already
+        if remain_bytes >= 0:
+            return
+
+        if self._feeding:
+            self._buff_i = self._buf_checkpoint
+            raise OutOfData
+
+        # Strip buffer before checkpoint before reading file.
+        if self._buf_checkpoint > 0:
+            del self._buffer[: self._buf_checkpoint]
+            self._buff_i -= self._buf_checkpoint
+            self._buf_checkpoint = 0
+
+        # Read from file
+        remain_bytes = -remain_bytes
+        if remain_bytes + len(self._buffer) > self._max_buffer_size:
+            raise BufferFull
+        while remain_bytes > 0:
+            to_read_bytes = max(self._read_size, remain_bytes)
+            read_data = self.file_like.read(to_read_bytes)
+            if not read_data:
+                break
+            assert isinstance(read_data, bytes)
+            self._buffer += read_data
+            remain_bytes -= len(read_data)
+
+        if len(self._buffer) < n + self._buff_i and raise_outofdata:
+            self._buff_i = 0  # rollback
+            raise OutOfData
+
+    def _read_header(self):
+        typ = TYPE_IMMEDIATE
+        n = 0
+        obj = None
+        self._reserve(1)
+        b = self._buffer[self._buff_i]
+        self._buff_i += 1
+        if b & 0b10000000 == 0:
+            obj = b
+        elif b & 0b11100000 == 0b11100000:
+            obj = -1 - (b ^ 0xFF)
+        elif b & 0b11100000 == 0b10100000:
+            n = b & 0b00011111
+            typ = TYPE_RAW
+            if n > self._max_str_len:
+                raise ValueError(f"{n} exceeds max_str_len({self._max_str_len})")
+            obj = self._read(n)
+        elif b & 0b11110000 == 0b10010000:
+            n = b & 0b00001111
+            typ = TYPE_ARRAY
+            if n > self._max_array_len:
+                raise ValueError(f"{n} exceeds max_array_len({self._max_array_len})")
+        elif b & 0b11110000 == 0b10000000:
+            n = b & 0b00001111
+            typ = TYPE_MAP
+            if n > self._max_map_len:
+                raise ValueError(f"{n} exceeds max_map_len({self._max_map_len})")
+        elif b == 0xC0:
+            obj = None
+        elif b == 0xC2:
+            obj = False
+        elif b == 0xC3:
+            obj = True
+        elif 0xC4 <= b <= 0xC6:
+            size, fmt, typ = _MSGPACK_HEADERS[b]
+            self._reserve(size)
+            if len(fmt) > 0:
+                n = struct.unpack_from(fmt, self._buffer, self._buff_i)[0]
+            else:
+                n = self._buffer[self._buff_i]
+            self._buff_i += size
+            if n > self._max_bin_len:
+                raise ValueError(f"{n} exceeds max_bin_len({self._max_bin_len})")
+            obj = self._read(n)
+        elif 0xC7 <= b <= 0xC9:
+            size, fmt, typ = _MSGPACK_HEADERS[b]
+            self._reserve(size)
+            L, n = struct.unpack_from(fmt, self._buffer, self._buff_i)
+            self._buff_i += size
+            if L > self._max_ext_len:
+                raise ValueError(f"{L} exceeds max_ext_len({self._max_ext_len})")
+            obj = self._read(L)
+        elif 0xCA <= b <= 0xD3:
+            size, fmt = _MSGPACK_HEADERS[b]
+            self._reserve(size)
+            if len(fmt) > 0:
+                obj = struct.unpack_from(fmt, self._buffer, self._buff_i)[0]
+            else:
+                obj = self._buffer[self._buff_i]
+            self._buff_i += size
+        elif 0xD4 <= b <= 0xD8:
+            size, fmt, typ = _MSGPACK_HEADERS[b]
+            if self._max_ext_len < size:
+                raise ValueError(f"{size} exceeds max_ext_len({self._max_ext_len})")
+            self._reserve(size + 1)
+            n, obj = struct.unpack_from(fmt, self._buffer, self._buff_i)
+            self._buff_i += size + 1
+        elif 0xD9 <= b <= 0xDB:
+            size, fmt, typ = _MSGPACK_HEADERS[b]
+            self._reserve(size)
+            if len(fmt) > 0:
+                (n,) = struct.unpack_from(fmt, self._buffer, self._buff_i)
+            else:
+                n = self._buffer[self._buff_i]
+            self._buff_i += size
+            if n > self._max_str_len:
+                raise ValueError(f"{n} exceeds max_str_len({self._max_str_len})")
+            obj = self._read(n)
+        elif 0xDC <= b <= 0xDD:
+            size, fmt, typ = _MSGPACK_HEADERS[b]
+            self._reserve(size)
+            (n,) = struct.unpack_from(fmt, self._buffer, self._buff_i)
+            self._buff_i += size
+            if n > self._max_array_len:
+                raise ValueError(f"{n} exceeds max_array_len({self._max_array_len})")
+        elif 0xDE <= b <= 0xDF:
+            size, fmt, typ = _MSGPACK_HEADERS[b]
+            self._reserve(size)
+            (n,) = struct.unpack_from(fmt, self._buffer, self._buff_i)
+            self._buff_i += size
+            if n > self._max_map_len:
+                raise ValueError(f"{n} exceeds max_map_len({self._max_map_len})")
+        else:
+            raise FormatError("Unknown header: 0x%x" % b)
+        return typ, n, obj
+
+    def _unpack(self, execute=EX_CONSTRUCT):
+        typ, n, obj = self._read_header()
+
+        if execute == EX_READ_ARRAY_HEADER:
+            if typ != TYPE_ARRAY:
+                raise ValueError("Expected array")
+            return n
+        if execute == EX_READ_MAP_HEADER:
+            if typ != TYPE_MAP:
+                raise ValueError("Expected map")
+            return n
+        # TODO should we eliminate the recursion?
+        if typ == TYPE_ARRAY:
+            if execute == EX_SKIP:
+                for i in range(n):
+                    # TODO check whether we need to call `list_hook`
+                    self._unpack(EX_SKIP)
+                return
+            ret = newlist_hint(n)
+            for i in range(n):
+                ret.append(self._unpack(EX_CONSTRUCT))
+            if self._list_hook is not None:
+                ret = self._list_hook(ret)
+            # TODO is the interaction between `list_hook` and `use_list` ok?
+            return ret if self._use_list else tuple(ret)
+        if typ == TYPE_MAP:
+            if execute == EX_SKIP:
+                for i in range(n):
+                    # TODO check whether we need to call hooks
+                    self._unpack(EX_SKIP)
+                    self._unpack(EX_SKIP)
+                return
+            if self._object_pairs_hook is not None:
+                ret = self._object_pairs_hook(
+                    (self._unpack(EX_CONSTRUCT), self._unpack(EX_CONSTRUCT)) for _ in range(n)
+                )
+            else:
+                ret = {}
+                for _ in range(n):
+                    key = self._unpack(EX_CONSTRUCT)
+                    if self._strict_map_key and type(key) not in (str, bytes):
+                        raise ValueError("%s is not allowed for map key" % str(type(key)))
+                    if isinstance(key, str):
+                        key = sys.intern(key)
+                    ret[key] = self._unpack(EX_CONSTRUCT)
+                if self._object_hook is not None:
+                    ret = self._object_hook(ret)
+            return ret
+        if execute == EX_SKIP:
+            return
+        if typ == TYPE_RAW:
+            if self._raw:
+                obj = bytes(obj)
+            else:
+                obj = obj.decode("utf_8", self._unicode_errors)
+            return obj
+        if typ == TYPE_BIN:
+            return bytes(obj)
+        if typ == TYPE_EXT:
+            if n == -1:  # timestamp
+                ts = Timestamp.from_bytes(bytes(obj))
+                if self._timestamp == 1:
+                    return ts.to_unix()
+                elif self._timestamp == 2:
+                    return ts.to_unix_nano()
+                elif self._timestamp == 3:
+                    return ts.to_datetime()
+                else:
+                    return ts
+            else:
+                return self._ext_hook(n, bytes(obj))
+        assert typ == TYPE_IMMEDIATE
+        return obj
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        try:
+            ret = self._unpack(EX_CONSTRUCT)
+            self._consume()
+            return ret
+        except OutOfData:
+            self._consume()
+            raise StopIteration
+        except RecursionError:
+            raise StackError
+
+    next = __next__
+
+    def skip(self):
+        self._unpack(EX_SKIP)
+        self._consume()
+
+    def unpack(self):
+        try:
+            ret = self._unpack(EX_CONSTRUCT)
+        except RecursionError:
+            raise StackError
+        self._consume()
+        return ret
+
+    def read_array_header(self):
+        ret = self._unpack(EX_READ_ARRAY_HEADER)
+        self._consume()
+        return ret
+
+    def read_map_header(self):
+        ret = self._unpack(EX_READ_MAP_HEADER)
+        self._consume()
+        return ret
+
+    def tell(self):
+        return self._stream_offset
+
+
+class Packer:
+    """
+    MessagePack Packer
+
+    Usage::
+
+        packer = Packer()
+        astream.write(packer.pack(a))
+        astream.write(packer.pack(b))
+
+    Packer's constructor has some keyword arguments:
+
+    :param default:
+        When specified, it should be callable.
+        Convert user type to builtin type that Packer supports.
+        See also simplejson's document.
+
+    :param bool use_single_float:
+        Use single precision float type for float. (default: False)
+
+    :param bool autoreset:
+        Reset buffer after each pack and return its content as `bytes`. (default: True).
+        If set this to false, use `bytes()` to get content and `.reset()` to clear buffer.
+
+    :param bool use_bin_type:
+        Use bin type introduced in msgpack spec 2.0 for bytes.
+        It also enables str8 type for unicode. (default: True)
+
+    :param bool strict_types:
+        If set to true, types will be checked to be exact. Derived classes
+        from serializable types will not be serialized and will be
+        treated as unsupported type and forwarded to default.
+        Additionally tuples will not be serialized as lists.
+        This is useful when trying to implement accurate serialization
+        for python types.
+
+    :param bool datetime:
+        If set to true, datetime with tzinfo is packed into Timestamp type.
+        Note that the tzinfo is stripped in the timestamp.
+        You can get UTC datetime with `timestamp=3` option of the Unpacker.
+
+    :param str unicode_errors:
+        The error handler for encoding unicode. (default: 'strict')
+        DO NOT USE THIS!!  This option is kept for very specific usage.
+
+    :param int buf_size:
+        Internal buffer size. This option is used only for C implementation.
+    """
+
+    def __init__(
+        self,
+        *,
+        default=None,
+        use_single_float=False,
+        autoreset=True,
+        use_bin_type=True,
+        strict_types=False,
+        datetime=False,
+        unicode_errors=None,
+        buf_size=None,
+    ):
+        self._strict_types = strict_types
+        self._use_float = use_single_float
+        self._autoreset = autoreset
+        self._use_bin_type = use_bin_type
+        self._buffer = BytesIO()
+        self._datetime = bool(datetime)
+        self._unicode_errors = unicode_errors or "strict"
+        if default is not None and not callable(default):
+            raise TypeError("default must be callable")
+        self._default = default
+
+    def _pack(
+        self,
+        obj,
+        nest_limit=DEFAULT_RECURSE_LIMIT,
+        check=isinstance,
+        check_type_strict=_check_type_strict,
+    ):
+        default_used = False
+        if self._strict_types:
+            check = check_type_strict
+            list_types = list
+        else:
+            list_types = (list, tuple)
+        while True:
+            if nest_limit < 0:
+                raise ValueError("recursion limit exceeded")
+            if obj is None:
+                return self._buffer.write(b"\xc0")
+            if check(obj, bool):
+                if obj:
+                    return self._buffer.write(b"\xc3")
+                return self._buffer.write(b"\xc2")
+            if check(obj, int):
+                if 0 <= obj < 0x80:
+                    return self._buffer.write(struct.pack("B", obj))
+                if -0x20 <= obj < 0:
+                    return self._buffer.write(struct.pack("b", obj))
+                if 0x80 <= obj <= 0xFF:
+                    return self._buffer.write(struct.pack("BB", 0xCC, obj))
+                if -0x80 <= obj < 0:
+                    return self._buffer.write(struct.pack(">Bb", 0xD0, obj))
+                if 0xFF < obj <= 0xFFFF:
+                    return self._buffer.write(struct.pack(">BH", 0xCD, obj))
+                if -0x8000 <= obj < -0x80:
+                    return self._buffer.write(struct.pack(">Bh", 0xD1, obj))
+                if 0xFFFF < obj <= 0xFFFFFFFF:
+                    return self._buffer.write(struct.pack(">BI", 0xCE, obj))
+                if -0x80000000 <= obj < -0x8000:
+                    return self._buffer.write(struct.pack(">Bi", 0xD2, obj))
+                if 0xFFFFFFFF < obj <= 0xFFFFFFFFFFFFFFFF:
+                    return self._buffer.write(struct.pack(">BQ", 0xCF, obj))
+                if -0x8000000000000000 <= obj < -0x80000000:
+                    return self._buffer.write(struct.pack(">Bq", 0xD3, obj))
+                if not default_used and self._default is not None:
+                    obj = self._default(obj)
+                    default_used = True
+                    continue
+                raise OverflowError("Integer value out of range")
+            if check(obj, (bytes, bytearray)):
+                n = len(obj)
+                if n >= 2**32:
+                    raise ValueError("%s is too large" % type(obj).__name__)
+                self._pack_bin_header(n)
+                return self._buffer.write(obj)
+            if check(obj, str):
+                obj = obj.encode("utf-8", self._unicode_errors)
+                n = len(obj)
+                if n >= 2**32:
+                    raise ValueError("String is too large")
+                self._pack_raw_header(n)
+                return self._buffer.write(obj)
+            if check(obj, memoryview):
+                n = obj.nbytes
+                if n >= 2**32:
+                    raise ValueError("Memoryview is too large")
+                self._pack_bin_header(n)
+                return self._buffer.write(obj)
+            if check(obj, float):
+                if self._use_float:
+                    return self._buffer.write(struct.pack(">Bf", 0xCA, obj))
+                return self._buffer.write(struct.pack(">Bd", 0xCB, obj))
+            if check(obj, (ExtType, Timestamp)):
+                if check(obj, Timestamp):
+                    code = -1
+                    data = obj.to_bytes()
+                else:
+                    code = obj.code
+                    data = obj.data
+                assert isinstance(code, int)
+                assert isinstance(data, bytes)
+                L = len(data)
+                if L == 1:
+                    self._buffer.write(b"\xd4")
+                elif L == 2:
+                    self._buffer.write(b"\xd5")
+                elif L == 4:
+                    self._buffer.write(b"\xd6")
+                elif L == 8:
+                    self._buffer.write(b"\xd7")
+                elif L == 16:
+                    self._buffer.write(b"\xd8")
+                elif L <= 0xFF:
+                    self._buffer.write(struct.pack(">BB", 0xC7, L))
+                elif L <= 0xFFFF:
+                    self._buffer.write(struct.pack(">BH", 0xC8, L))
+                else:
+                    self._buffer.write(struct.pack(">BI", 0xC9, L))
+                self._buffer.write(struct.pack("b", code))
+                self._buffer.write(data)
+                return
+            if check(obj, list_types):
+                n = len(obj)
+                self._pack_array_header(n)
+                for i in range(n):
+                    self._pack(obj[i], nest_limit - 1)
+                return
+            if check(obj, dict):
+                return self._pack_map_pairs(len(obj), obj.items(), nest_limit - 1)
+
+            if self._datetime and check(obj, _DateTime) and obj.tzinfo is not None:
+                obj = Timestamp.from_datetime(obj)
+                default_used = 1
+                continue
+
+            if not default_used and self._default is not None:
+                obj = self._default(obj)
+                default_used = 1
+                continue
+
+            if self._datetime and check(obj, _DateTime):
+                raise ValueError(f"Cannot serialize {obj!r} where tzinfo=None")
+
+            raise TypeError(f"Cannot serialize {obj!r}")
+
+    def pack(self, obj):
+        try:
+            self._pack(obj)
+        except:
+            self._buffer = BytesIO()  # force reset
+            raise
+        if self._autoreset:
+            ret = self._buffer.getvalue()
+            self._buffer = BytesIO()
+            return ret
+
+    def pack_map_pairs(self, pairs):
+        self._pack_map_pairs(len(pairs), pairs)
+        if self._autoreset:
+            ret = self._buffer.getvalue()
+            self._buffer = BytesIO()
+            return ret
+
+    def pack_array_header(self, n):
+        if n >= 2**32:
+            raise ValueError
+        self._pack_array_header(n)
+        if self._autoreset:
+            ret = self._buffer.getvalue()
+            self._buffer = BytesIO()
+            return ret
+
+    def pack_map_header(self, n):
+        if n >= 2**32:
+            raise ValueError
+        self._pack_map_header(n)
+        if self._autoreset:
+            ret = self._buffer.getvalue()
+            self._buffer = BytesIO()
+            return ret
+
+    def pack_ext_type(self, typecode, data):
+        if not isinstance(typecode, int):
+            raise TypeError("typecode must have int type.")
+        if not 0 <= typecode <= 127:
+            raise ValueError("typecode should be 0-127")
+        if not isinstance(data, bytes):
+            raise TypeError("data must have bytes type")
+        L = len(data)
+        if L > 0xFFFFFFFF:
+            raise ValueError("Too large data")
+        if L == 1:
+            self._buffer.write(b"\xd4")
+        elif L == 2:
+            self._buffer.write(b"\xd5")
+        elif L == 4:
+            self._buffer.write(b"\xd6")
+        elif L == 8:
+            self._buffer.write(b"\xd7")
+        elif L == 16:
+            self._buffer.write(b"\xd8")
+        elif L <= 0xFF:
+            self._buffer.write(b"\xc7" + struct.pack("B", L))
+        elif L <= 0xFFFF:
+            self._buffer.write(b"\xc8" + struct.pack(">H", L))
+        else:
+            self._buffer.write(b"\xc9" + struct.pack(">I", L))
+        self._buffer.write(struct.pack("B", typecode))
+        self._buffer.write(data)
+
+    def _pack_array_header(self, n):
+        if n <= 0x0F:
+            return self._buffer.write(struct.pack("B", 0x90 + n))
+        if n <= 0xFFFF:
+            return self._buffer.write(struct.pack(">BH", 0xDC, n))
+        if n <= 0xFFFFFFFF:
+            return self._buffer.write(struct.pack(">BI", 0xDD, n))
+        raise ValueError("Array is too large")
+
+    def _pack_map_header(self, n):
+        if n <= 0x0F:
+            return self._buffer.write(struct.pack("B", 0x80 + n))
+        if n <= 0xFFFF:
+            return self._buffer.write(struct.pack(">BH", 0xDE, n))
+        if n <= 0xFFFFFFFF:
+            return self._buffer.write(struct.pack(">BI", 0xDF, n))
+        raise ValueError("Dict is too large")
+
+    def _pack_map_pairs(self, n, pairs, nest_limit=DEFAULT_RECURSE_LIMIT):
+        self._pack_map_header(n)
+        for k, v in pairs:
+            self._pack(k, nest_limit - 1)
+            self._pack(v, nest_limit - 1)
+
+    def _pack_raw_header(self, n):
+        if n <= 0x1F:
+            self._buffer.write(struct.pack("B", 0xA0 + n))
+        elif self._use_bin_type and n <= 0xFF:
+            self._buffer.write(struct.pack(">BB", 0xD9, n))
+        elif n <= 0xFFFF:
+            self._buffer.write(struct.pack(">BH", 0xDA, n))
+        elif n <= 0xFFFFFFFF:
+            self._buffer.write(struct.pack(">BI", 0xDB, n))
+        else:
+            raise ValueError("Raw is too large")
+
+    def _pack_bin_header(self, n):
+        if not self._use_bin_type:
+            return self._pack_raw_header(n)
+        elif n <= 0xFF:
+            return self._buffer.write(struct.pack(">BB", 0xC4, n))
+        elif n <= 0xFFFF:
+            return self._buffer.write(struct.pack(">BH", 0xC5, n))
+        elif n <= 0xFFFFFFFF:
+            return self._buffer.write(struct.pack(">BI", 0xC6, n))
+        else:
+            raise ValueError("Bin is too large")
+
+    def bytes(self):
+        """Return internal buffer contents as bytes object"""
+        return self._buffer.getvalue()
+
+    def reset(self):
+        """Reset internal buffer.
+
+        This method is useful only when autoreset=False.
+        """
+        self._buffer = BytesIO()
+
+    def getbuffer(self):
+        """Return view of internal buffer."""
+        if _USING_STRINGBUILDER:
+            return memoryview(self.bytes())
+        else:
+            return self._buffer.getbuffer()

vlmpy310/lib/python3.10/site-packages/py_cpuinfo-9.0.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

vlmpy310/lib/python3.10/site-packages/py_cpuinfo-9.0.0.dist-info/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2022 Matthew Brennan Jones <matthew.brennan.jones@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vlmpy310/lib/python3.10/site-packages/py_cpuinfo-9.0.0.dist-info/METADATA

@@ -0,0 +1,27 @@
+Metadata-Version: 2.1
+Name: py-cpuinfo
+Version: 9.0.0
+Summary: Get CPU info with pure Python
+Home-page: https://github.com/workhorsy/py-cpuinfo
+Author: Matthew Brennan Jones
+Author-email: matthew.brennan.jones@gmail.com
+License: MIT
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Topic :: Utilities
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+License-File: LICENSE
+
+py-cpuinfo
+==========
+
+
+Py-cpuinfo gets CPU info with pure Python. Py-cpuinfo should work
+without any extra programs or libraries, beyond what your OS provides.
+It does not require any compilation(C/C++, assembly, et cetera) to use.
+It works with Python 3.
+
+Documentation can be viewed here: https://github.com/workhorsy/py-cpuinfo
+
+

vlmpy310/lib/python3.10/site-packages/py_cpuinfo-9.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+../../../bin/cpuinfo,sha256=cbFrrk_uu3L9jDppjHzFSmKr4kR7CDbIh27vGRm3EsI,220
+cpuinfo/__init__.py,sha256=T6gndqGAggfJCu4_iOziTnomCN7KzaAK_OYTewE4FMA,44
+cpuinfo/__main__.py,sha256=nSxC6Hqhi-0lN7Z4WwtKdxQdf3cUJefb5hOahCzh4Yg,33
+cpuinfo/__pycache__/__init__.cpython-310.pyc,,
+cpuinfo/__pycache__/__main__.cpython-310.pyc,,
+cpuinfo/__pycache__/cpuinfo.cpython-310.pyc,,
+cpuinfo/cpuinfo.py,sha256=HHyDlDUNovE3QzJ3hviiM1ngyOC4iD7i6oGiz2iTmVk,84388
+py_cpuinfo-9.0.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+py_cpuinfo-9.0.0.dist-info/LICENSE,sha256=3br3Y5a_XHqkWXWiHq_i4i7st9paoNt8sOYVL6r-800,1127
+py_cpuinfo-9.0.0.dist-info/METADATA,sha256=rRFelvhFdoYcXnXXYDAbgdIxQ8_iVUa5lUHgEmU3ncE,794
+py_cpuinfo-9.0.0.dist-info/RECORD,,
+py_cpuinfo-9.0.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py_cpuinfo-9.0.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+py_cpuinfo-9.0.0.dist-info/entry_points.txt,sha256=ZwrsclY_xUA0xJZK98bLxBdcowxnkK0ANYUT4FYcZJ8,42
+py_cpuinfo-9.0.0.dist-info/top_level.txt,sha256=XsjpunhkxD4hvznqQjrFNw0rtgizHEOGzewPZY3UEtU,8

vlmpy310/lib/python3.10/site-packages/py_cpuinfo-9.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

vlmpy310/lib/python3.10/site-packages/py_cpuinfo-9.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+cpuinfo = cpuinfo:main
+

vlmpy310/lib/python3.10/site-packages/py_cpuinfo-9.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cpuinfo

vlmpy310/lib/python3.10/site-packages/pyasn1-0.6.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip