o 3Ihˀ@sddlmZddlmZddlmZddlmZmZddl m Z m Z m Z m Z mZmZmZedkr3dgZedZd gZedgd Gd d d Zdd lmZdd lmZdS)) GROUND_TYPES) import_module)doctest_depends_on)ZZQQ)DMBadInputError DMDomainErrorDMNonSquareMatrixErrorDMNonInvertibleMatrixError DMRankError DMShapeError DMValueErrorflint*DFM ground_typesc@seZdZdZdZdZdZddZeddZ d d Z ed d Z ed dZ eddZ eddZddZddZddZeddZddZddZdd Zd!d"Zd#d$Zd%d&Zed'd(Zed)d*Zd+d,Zd-d.Zed/d0Zd1d2Zed3d4Z d5d6Z!ed7d8Z"d9d:Z#d;d<Z$d=d>Z%d?d@Z&dAdBZ'dCdDZ(dEdFZ)dGdHZ*dIdJZ+dKdLZ,dMdNZ-dOdPZ.dQdRZ/dSdTZ0dUdVZ1dWdXZ2edYdZZ3ed[d\Z4ed]d^Z5ed_d`Z6dadbZ7dcddZ8dedfZ9dgdhZ:didjZ;dkdlZdqdrZ?dsdtZ@dudvZAeBdwdxdydzZCeBdwdxd{d|ZDeBdwdxd}d~ZEddZFddZGeBdwdxddZHddZIddZJdddZKddZLdddZMeBdwdxdddZNeBdwdxdddZOdS)ra& 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 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]] denseTFc CsV||}d|vr z||}Wnttfytd|w||}||||S)Construct from a nested list.rz"Input should be a list of list of )_get_flint_func ValueError TypeErrorr_new)clsrowslistshapedomain flint_matrepr Y/home/air/sanwanet/gpt-api/venv/lib/python3.10/site-packages/sympy/polys/matrices/_dfm.py__new__ms  z DFM.__new__cCs:||||t|}||_||_\|_|_||_|S)z)Internal constructor from a flint matrix.)_checkobjectr"rrrowscolsr)rrrrobjr r r!r{s  zDFM._newcCs|||j|jS)z>Create a new DFM with the same shape and domain but a new rep.)rrr)selfrr r r!_new_repz DFM._new_repcCs||f}||krtd|tkrt|tjstd|tkr,t|tj s,td|j r._funccstjg|RSN)rr3r:)mr r!z%DFM._get_flint_func..r+) rrr/rr1r2characteristicr.onenmodr4 fmpz_mod_ctxr5)rrr>r )r<r=r@r!rs zDFM._get_flint_funccCs ||jS)z5Callable to create a flint matrix of the same domain.)rrr(r r r!r> z DFM._funccCs t|S)zReturn ``str(self)``.)strto_ddmrGr r r!__str__ z DFM.__str__cCsdt|ddS)zReturn ``repr(self)``.rN)reprrJrGr r r!__repr__sz DFM.__repr__cCs&t|tstS|j|jko|j|jkS)zReturn ``self == other``.)r.rNotImplementedrrr(otherr r r!__eq__s z DFM.__eq__cCs ||||S)rr )rrrrr r r! from_listrHz DFM.from_listcC |jS)zConvert to a nested list.)rtolistrGr r r!to_list z DFM.to_listcCs|||jS)zReturn a copy of self.)r)r>rrGr r r!copyr*zDFM.copycCt||j|jS)zConvert to a DDM.)DDMrTrWrrrGr r r!rJz DFM.to_ddmcCrZ)zConvert to a SDM.)SDMrTrWrrrGr r r!to_sdmr\z DFM.to_sdmcC|S)z Return self.r rGr r r!to_dfmsz DFM.to_dfmcCr_)aL 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 r rGr r r! to_dfm_or_ddmszDFM.to_dfm_or_ddmcCs|||j|jS)zConvert from a DDM.)rTrWrr)rddmr r r!from_ddmz DFM.from_ddmcCsd||}z |g||R}Wntytd|ty+td|w||||S)z Inverse of :meth:`to_list_flat`.z'Incorrect number of elements for shape zInput should be a list of )rrrr)relementsrrfuncrr r r!from_list_flats    zDFM.from_list_flatcCrU)zConvert to a flat list.)rentriesrGr r r! to_list_flatrXzDFM.to_list_flatcC |S)z$Convert to a flat list of non-zeros.)rJ to_flat_nzrGr r r!rkrLzDFM.to_flat_nzcCt|||S)zInverse of :meth:`to_flat_nz`.)r[ from_flat_nzr`)rredatarr r r!rm zDFM.from_flat_nzcCrj)zConvert to a DOD.)rJto_dodrGr r r!rprLz DFM.to_dodcCrl)zInverse of :meth:`to_dod`.)r[from_dodr`)rdodrrr r r!rqroz DFM.from_dodcCrj)zConvert to a DOK.)rJto_dokrGr r r!rsrLz DFM.to_dokcCrl)zInverse of :math:`to_dod`.)r[from_dokr`)rdokrrr r r!rtroz DFM.from_dokccsP|j\}}|j}t|D]}t|D]}|||f}|r$|||fVqq dS)z/Iterate over the non-zero values of the matrix.Nrrranger(r@nrijrepijr r r! iter_values"    zDFM.iter_valuesccsP|j\}}|j}t|D]}t|D]}|||f}|r$||f|fVqq dS)zBIterate over indices and values of nonzero elements of the matrix.Nrvrxr r r! iter_items,r~zDFM.iter_itemscCs`||jkr |S|tkr|jtkr|t|j|j|S| |r,| | St d)zConvert to a new domain.r+)rrYrrrrr1rrr8rJ convert_tor`r5)r(rr r r!r6s  zDFM.convert_toc Csf|j\}}|dkr ||7}|dkr||7}z|j||fWSty2td|d|d|jw)zGet the ``(i, j)``-th entry.rInvalid indices (, ) for Matrix of shape rrr IndexError)r(rzr{r@ryr r r!getitemDs  z DFM.getitemc Csj|j\}}|dkr ||7}|dkr||7}z ||j||f<WdSty4td|d|d|jw)zSet the ``(i, j)``-th entry.rrrrNr)r(rzr{valuer@ryr r r!setitemRs  z DFM.setitemcs:|jfdd|D}t|tf}||||jS)z%Extract a submatrix with no checking.cs g|] fddDqS)csg|]}|fqSr r ).0r{)Mrzr r! dz+DFM._extract...r )rr j_indices)rzr!rds z DFM._extract..)rr9rTr)r( i_indicesrlolrr rr!_extract`sz DFM._extractc Cs|j\}}g}g}|D](}|dkr||}n|}d|kr"|ks.ntd|d|j||q |D](} | dkrA| |} n| } d| krM|ksYntd| d|j|| q6|||S)zExtract a submatrix.rzInvalid row index z for Matrix of shape zInvalid column index )rrappendr) r(rcolslistr@rynew_rowsnew_colsrzi_posr{j_posr r r!extracths$      z DFM.extractcCs.|j\}}t||}t||}|||S)z Slice a DFM.)rrwr)r(rowslicecolslicer@ryrrr r r! extract_slices    zDFM.extract_slicecCs||j SzNegate a DFM matrix.r)rrGr r r!negszDFM.negcCs||j|jS)zAdd two DFM matrices.rrQr r r!addr*zDFM.addcCs||j|jS)zSubtract two DFM matrices.rrQr r r!subr*zDFM.subcCs||j|S)z1Multiply a DFM matrix from the right by a scalar.rrQr r r!mulzDFM.mulcCs|||jS)z0Multiply a DFM matrix from the left by a scalar.rrQr r r!rmulrzDFM.rmulcCs||S)z/Elementwise multiplication of two DFM matrices.)rJmul_elementwiser`rQr r r!rrdzDFM.mul_elementwisecCs$|j|jf}||j|j||jS)zMultiply two DFM matrices.)r%r&rrr)r(rRrr r r!matmuls z DFM.matmulcCs|Sr)rrGr r r!__neg__sz DFM.__neg__cCs||}|||||S)zReturn a zero DFM matrix.)rr)rrrrfr r r!zeross z DFM.zeroscCt||S)zReturn a one DFM matrix.)r[onesr`)rrrr r r!rzDFM.onescCr)z%Return the identity matrix of size n.)r[eyer`)rryrr r r!rrzDFM.eyecCr)zReturn a diagonal matrix.)r[diagr`)rrerr r r!rszDFM.diagcCs|||S)z/Apply a function to each entry of a DFM matrix.)rJ applyfuncr`)r(rfrr r r!rsz DFM.applyfunccCs||j|j|jf|jS)zTranspose a DFM matrix.)rr transposer&r%rrGr r r!rsz DFM.transposecG|jdd|DS)zHorizontally stack matrices.cSg|]}|qSr rJror r r!rrBzDFM.hstack..)rJhstackr`r(othersr r r!rz DFM.hstackcGr)zVertically stack matrices.cSrr rrr r r!rrBzDFM.vstack..)rJvstackr`rr r r!rrz DFM.vstackcs,|j|j\}}fddtt||DS)z$Return the diagonal of a DFM matrix.csg|]}||fqSr r )rrzrr r!rrz DFM.diagonal..)rrrwmin)r(r@ryr rr!diagonals z DFM.diagonalcCsD|j}t|jD]}tt||jD] }|||frdSqqdS)z2Return ``True`` if the matrix is upper triangular.FT)rrwr%rr&r(rrzr{r r r!is_upper z DFM.is_uppercCsD|j}t|jD]}t|d|jD] }|||frdSqqdS)z2Return ``True`` if the matrix is lower triangular.rFTrrwr%r&rr r r!is_lowerrz DFM.is_lowercCs|o|S)z*Return ``True`` if the matrix is diagonal.)rrrGr r r! is_diagonalrzDFM.is_diagonalcCs>|j}t|jD]}t|jD] }|||frdSqqdS)z1Return ``True`` if the matrix is the zero matrix.FTrrr r r!is_zero_matrixs zDFM.is_zero_matrixcCrj)z5Return the number of non-zero elements in the matrix.)rJnnzrGr r r!rrLzDFM.nnzcCrj)z7Return the strongly connected components of the matrix.)rJsccrGr r r!rrLzDFM.sccrrcCrU)a 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. )rdetrGr r r!r s 1zDFM.detcCs|jdddS)a# 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. N)rcharpolycoeffsrGr r r!r?s*z DFM.charpolycCsx|j}|j\}}||krtd|tkrtd||tks!|jr6z ||j WSt y5t dwt d|)a 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. z!cannot invert a non-square matrixzfield expected, got %szmatrix is not invertiblez#DFM.inv() is not implemented for %s) rrr rr rr2r)rinvZeroDivisionErrorr r5)r(Kr@ryr r r!rks7    zDFM.invcCs$|\}}}|||fS)z*Return the LU decomposition of the matrix.)rJlur`)r(LUswapsr r r!rszDFM.lucCs |\}}||fS)z*Return the QR decomposition of the matrix.)rJqrr`)r(QRr r r!rszDFM.qrcCs|j|jkstd|j|jf|jjstd|j|j\}}|j\}}||kr3td||||f||f}||krF||Sz |j |j}Wn t yZt dw| |||jS)a 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. zDomains must match: %s != %szField expected, got %sz(Matrix size mismatch: %s * %s vs %s * %sz Matrix det == 0; not invertible.) rr is_Fieldrr rJlu_solver`rsolverr r)r(rhsr@ryr{k sol_shapesolr r r!rs" .   z DFM.lu_solvec Cs|jtkrCt|jdd}|durC|j\}}}}|j\}}||||f|j||||f|j||||f|j|||j|jfS|\}} } } |}| }| }| }||||fS)a Fraction-free LU decomposition of DFM. Explanation =========== Uses `python-flint` if possible for a matrix of integers otherwise uses the DDM method. See Also ======== sympy.polys.matrices.ddm.DDM.fflu ffluN) rrgetattrrrrrrJr`) r(rPrDrr@ryddm_pddm_lddm_dddm_ur r r!rs   zDFM.fflucCs|\}}||fS)/Return a basis for the nullspace of the matrix.)rJ nullspacer`)r(rb nonpivotsr r r!r5s z DFM.nullspaceNcCs |j|d\}}||fS)r)pivots)r^nullspace_from_rrefr`)r(rsdmrr r r!rKs zDFM.nullspace_from_rrefcCs|S)z+Return a particular solution to the system.)rJ particularr`rGr r r!rQrzDFM.particularGz?RQ?zbasisapproxc Csrdd}||}||}d|krdkstdtd|j\}}|j|kr.td|jj|||||dS)zACall the fmpz_mat.lll() method but check rank to avoid segfaults.cSs&t|rt|jt|jSt|Sr?)rof_typefloat numerator denominator)xr r r!to_float_s zDFM._lll..to_floatg?rz delta must be between 0.25 and 1z-Matrix must have full row rank for Flint LLL.) transformdeltaetargram)rrrrankr lll) r(rrrrrrr@ryr r r!_lllUs  zDFM._lll?cCsB|jtkr td|j|j|jkrtd|j|d}||S)aCompute 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. ZZ expected, got %s,Matrix must not have more rows than columns.)r)rrr r%r&r rr))r(rrr r r!rss    zDFM.lllcCsh|jtkr td|j|j|jkrtd|jd|d\}}||}|||j|jf|j}||fS)adCompute 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. rrT)rr) rrr r%r&r rr)r)r(rrTbasisT_dfmr r r! lll_transforms   zDFM.lll_transformr?)Frrrr)r)P__name__ __module__ __qualname____doc__fmtis_DFMis_DDMr" classmethodrr)r#r8rpropertyr>rKrOrSrTrWrYrJr^r`rarcrgrirkrmrprqrsrtr}rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r r r!rEs"                        2 + H J!   )r[)r]N)sympy.external.gmpyrsympy.external.importtoolsrsympy.utilities.decoratorrsympy.polys.domainsrr exceptionsrr r r r r r__doctest_skip__r__all__rsympy.polys.matrices.ddmr[r]r r r r!s& )  $   v