o o hly@sddlmZddlmZddlmZddlmZmZddl m Z m Z m Z m Z mZmZmZedkr3dgZedZd gZedgd Gd d d Zdd lmZdd lmZdS)) GROUND_TYPES) import_module)doctest_depends_onZZQQ)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~ZEddZFeBdwdxddZGddZHdddZIddZJdddZKeBdwdxdddZLeBdwdxdddZMdS)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!m/var/www/html/construction_image-detection-poc/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#r rrowscolsr)rr rrobjr!r!r"r{s  zDFM._newcCs|||j|jS)z>Create a new DFM with the same shape and domain but a new rep.)rrr)selfr r!r!r"_new_repz DFM._new_repcCsp||f}||krtd|tkrt|tjstd|tkr,t|tj s,td|ttfvr6t ddS)Nz(Shape of rep does not match shape of DFMzRep is not a flint.fmpz_matzRep is not a flint.fmpq_mat#Only ZZ and QQ are supported by DFM) nrowsncolsr r isinstancerfmpz_mat RuntimeErrorrfmpq_matNotImplementedError)rr rrrepshaper!r!r"r$s z DFM._checkcCs |ttfvS)z4Return True if the given domain is supported by DFM.rrrr!r!r"_supports_domain zDFM._supports_domaincCs$|tkrtjS|tkrtjStd)z3Return the flint matrix class for the given domain.r,)rrr0rr2r3r5r!r!r"rs zDFM._get_flint_funccCs ||jS)z5Callable to create a flint matrix of the same domain.)rrr)r!r!r"_funcr7z DFM._funccCs t|S)zReturn ``str(self)``.)strto_ddmr8r!r!r"__str__ z DFM.__str__cCsdt|ddS)zReturn ``repr(self)``.rN)reprr;r8r!r!r"__repr__sz DFM.__repr__cCs&t|tstS|j|jko|j|jkS)zReturn ``self == other``.)r/rNotImplementedrr r)otherr!r!r"__eq__s z DFM.__eq__cCs ||||S)rr!)rrrrr!r!r" from_listr7z DFM.from_listcC |jS)zConvert to a nested list.)r tolistr8r!r!r"to_list z DFM.to_listcCs|||jS)zReturn a copy of self.)r*r9r r8r!r!r"copyr+zDFM.copycCt||j|jS)zConvert to a DDM.)DDMrErHrrr8r!r!r"r;z DFM.to_ddmcCrK)zConvert to a SDM.)SDMrErHrrr8r!r!r"to_sdmrMz DFM.to_sdmcC|S)z Return self.r!r8r!r!r"to_dfmsz DFM.to_dfmcCrP)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!r8r!r!r" to_dfm_or_ddmszDFM.to_dfm_or_ddmcCs|||j|jS)zConvert from a DDM.)rErHrr)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 )rrr r)relementsrrfuncr r!r!r"from_list_flats    zDFM.from_list_flatcCrF)zConvert to a flat list.)r entriesr8r!r!r" to_list_flatrIzDFM.to_list_flatcC |S)z$Convert to a flat list of non-zeros.)r; to_flat_nzr8r!r!r"r\r=zDFM.to_flat_nzcCt|||S)zInverse of :meth:`to_flat_nz`.)rL from_flat_nzrQ)rrVdatarr!r!r"r^zDFM.from_flat_nzcCr[)zConvert to a DOD.)r;to_dodr8r!r!r"rar=z DFM.to_dodcCr])zInverse of :meth:`to_dod`.)rLfrom_dodrQ)rdodrrr!r!r"rbr`z DFM.from_dodcCr[)zConvert to a DOK.)r;to_dokr8r!r!r"rd r=z DFM.to_dokcCr])zInverse of :math:`to_dod`.)rLfrom_dokrQ)rdokrrr!r!r"rer`z DFM.from_dokccsP|j\}}|j}t|D]}t|D]}|||f}|r$|||fVqq dS)z0Iterater over the non-zero values of the matrix.Nrr ranger)mnr ijrepijr!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.Nrgrir!r!r" iter_itemsrpzDFM.iter_itemscCsh||jkr |S|tkr|jtkr|t|j|j|S|tkr0|jtkr0| | St d)zConvert to a new domain.r,) rrJrrrrr2r rr; convert_torQr3)r)rr!r!r"rr's 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 rr r IndexError)r)rlrmrjrkr!r!r"getitem5s  z DFM.getitemc Csj|j\}}|dkr ||7}|dkr||7}z ||j||f<WdSty4td|d|d|jw)zSet the ``(i, j)``-th entry.rrsrtruNrv)r)rlrmvaluerjrkr!r!r"setitemCs  z DFM.setitemcs:|jfdd|D}t|tf}||||jS)z%Extract a submatrix with no checking.cs g|] fddDqS)csg|]}|fqSr!r!).0rm)Mrlr!r" Uz+DFM._extract...r!)r{r| j_indices)rlr"r}Us z DFM._extract..)r lenrEr)r) i_indicesrlolrr!rr"_extractQsz 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 )rrwappendr) r)rcolslistrjrknew_rowsnew_colsrli_posrmj_posr!r!r"extractYs$      z DFM.extractcCs.|j\}}t||}t||}|||S)z Slice a DFM.)rrhr)r)rowslicecolslicerjrkrrr!r!r" extract_slicews    zDFM.extract_slicecCs||j SzNegate a DFM matrix.r*r r8r!r!r"negszDFM.negcCs||j|jS)zAdd two DFM matrices.rrBr!r!r"addr+zDFM.addcCs||j|jS)zSubtract two DFM matrices.rrBr!r!r"subr+zDFM.subcCs||j|S)z1Multiply a DFM matrix from the right by a scalar.rrBr!r!r"mulzDFM.mulcCs|||jS)z0Multiply a DFM matrix from the left by a scalar.rrBr!r!r"rmulrzDFM.rmulcCs||S)z/Elementwise multiplication of two DFM matrices.)r;mul_elementwiserQrBr!r!r"rrUzDFM.mul_elementwisecCs$|j|jf}||j|j||jS)zMultiply two DFM matrices.)r&r'rr r)r)rCrr!r!r"matmuls z DFM.matmulcCs|Sr)rr8r!r!r"__neg__sz DFM.__neg__cCs||}|||||S)zReturn a zero DFM matrix.)rr)rrrrWr!r!r"zeross z DFM.zeroscCt||S)zReturn a one DFM matrix.)rLonesrQ)rrrr!r!r"rzDFM.onescCr)z%Return the identity matrix of size n.)rLeyerQ)rrkrr!r!r"rrzDFM.eyecCr)zReturn a diagonal matrix.)rLdiagrQ)rrVrr!r!r"rszDFM.diagcCs|||S)z/Apply a function to each entry of a DFM matrix.)r; applyfuncrQ)r)rWrr!r!r"rsz DFM.applyfunccCs||j|j|jf|jS)zTranspose a DFM matrix.)rr transposer'r&rr8r!r!r"rsz DFM.transposecG|jdd|DS)zHorizontally stack matrices.cSg|]}|qSr!r;r{or!r!r"r}zDFM.hstack..)r;hstackrQr)othersr!r!r"rz DFM.hstackcGr)zVertically stack matrices.cSrr!rrr!r!r"r}rzDFM.vstack..)r;vstackrQrr!r!r"rrz DFM.vstackcs,|j|j\}}fddtt||DS)z$Return the diagonal of a DFM matrix.csg|]}||fqSr!r!)r{rlr|r!r"r}r~z DFM.diagonal..)r rrhmin)r)rjrkr!rr"diagonals z DFM.diagonalcCs<|j}t|jD]}t|D] }|||frdSqqdS)z2Return ``True`` if the matrix is upper triangular.FT)r rhr&r)r|rlrmr!r!r"is_uppers  z DFM.is_uppercCsD|j}t|jD]}t|d|jD] }|||frdSqqdS)z2Return ``True`` if the matrix is lower triangular.rFTr rhr&r'rr!r!r"is_lowers z DFM.is_lowercCs|o|S)z*Return ``True`` if the matrix is diagonal.)rrr8r!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_matrixcCr[)z5Return the number of non-zero elements in the matrix.)r;nnzr8r!r!r"rr=zDFM.nnzcCr[)z7Return the strongly connected components of the matrix.)r;sccr8r!r!r"rr=zDFM.sccrrcCrF)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. )r detr8r!r!r"rs 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)r charpolycoeffsr8r!r!r"r0s*z DFM.charpolycCsr|j}|j\}}||krtd|tkrtd||tkr3z ||jWSt y2t 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 rr*r invZeroDivisionErrorr r3)r)Krjrkr!r!r"r\s7    zDFM.invcCs$|\}}}|||fS)z*Return the LU decomposition of the matrix.)r;lurQ)r)LUswapsr!r!r"rszDFM.lucCs|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_Fieldrrr;lu_solverQr solverr r)r)rhsrjrkrmk sol_shapesolr!r!r"rs" .   z DFM.lu_solvecCs|\}}||fS)/Return a basis for the nullspace of the matrix.)r; nullspacerQ)r)rS nonpivotsr!r!r"rs z DFM.nullspaceNcCs |j|d\}}||fS)r)pivots)rOnullspace_from_rrefrQ)r)rsdmrr!r!r"rs zDFM.nullspace_from_rrefcCs|S)z+Return a particular solution to the system.)r; particularrQr8r!r!r"rrzDFM.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|SN)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.) transformdeltaetar gram)rrr rankr lll) r)rrrr rrrjrkr!r!r"_lll s  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'rrr*)r)rr r!r!r"r>s    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'rrr*r)r)rr TbasisT_dfmr!r!r" lll_transform\s   zDFM.lll_transformr)Frrrr)r)N__name__ __module__ __qualname____doc__fmtis_DFMis_DDMr# classmethodrr*r$r6rpropertyr9r<r@rDrErHrJr;rOrQrRrTrXrZr\r^rarbrdrerorqrrrxrzrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr!r!r!r"rEs"                        2 + H J   )rL)rNN)sympy.external.gmpyrsympy.external.importtoolsrsympy.utilities.decoratorrsympy.polys.domainsrr exceptionsr r r r r rr__doctest_skip__r__all__rsympy.polys.matrices.ddmrLrNr!r!r!r"s& )  $   A