a khˀ@sddlmZddlmZddlmZddlmZmZddl m Z m Z m Z m Z mZmZmZedkrfdgZedZd gZedgd Gd d d Zdd lmZdd lmZdS)) GROUND_TYPES) import_module)doctest_depends_on)ZZQQ)DMBadInputError DMDomainErrorDMNonSquareMatrixErrorDMNonInvertibleMatrixError DMRankError DMShapeError DMValueErrorflint*DFMZ 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]] ZdenseTFc Cs\||}d|vrFz ||}WqNttfyBtd|YqN0n||}||||S)Construct from a nested list.rz"Input should be a list of list of )_get_flint_func ValueError TypeErrorr_new)clsrowslistshapedomainZ flint_matreprG/var/www/auris/lib/python3.9/site-packages/sympy/polys/matrices/_dfm.py__new__ms  z DFM.__new__cCs:||||t|}||_||_\|_|_||_|S)z)Internal constructor from a flint matrix.)_checkobjectrrrrowscolsr)rrrrobjrrrr{s  zDFM._newcCs|||j|jS)z>Create a new DFM with the same shape and domain but a new rep.)rrr)selfrrrr_new_repsz DFM._new_repcCs||f}||kr td|tkr>t|tjs>tdnZ|tkr\t|tj s\tdn<|j r~t|tj tj fs~tdn|ttfvr|j st ddS)Nz(Shape of rep does not match shape of DFMzRep is not a flint.fmpz_matzRep is not a flint.fmpq_matz1Rep is not a flint.fmpz_mod_mat or flint.nmod_mat#Only ZZ and QQ are supported by DFM)ZnrowsZncolsrr isinstancerfmpz_mat RuntimeErrorrfmpq_matis_FF fmpz_mod_matnmod_matNotImplementedError)rrrrZrepshaperrrr s   z DFM._checkcCs|ttfvp|jo|jS)z4Return True if the given domain is supported by DFM.)rrr,Z _is_flint)rrrrr_supports_domainszDFM._supports_domaincst|tkrtjS|tkrtjS|jrh|t|jtj rNtj fdd}nt fdd}|St ddS)z3Return the flint matrix class for the given domain.cs>t|dkr(t|dtjr(|dSg|RSdS)Nrr)lenr(rr.e)_clscrr_funcs z"DFM._get_flint_func.._funccstjg|RSN)rr-r2)mrrz%DFM._get_flint_func..r'N) rrr)rr+r,Zcharacteristicr(ZoneZnmodr.Z fmpz_mod_ctxr/)rrr6r)r4r5r8rrs  zDFM._get_flint_funccCs ||jS)z5Callable to create a flint matrix of the same domain.)rrr%rrrr6sz DFM._funccCs t|S)zReturn ``str(self)``.)strto_ddmr;rrr__str__sz DFM.__str__cCsdt|ddS)zReturn ``repr(self)``.rN)reprr=r;rrr__repr__sz DFM.__repr__cCs&t|tstS|j|jko$|j|jkS)zReturn ``self == other``.)r(rNotImplementedrrr%otherrrr__eq__s z DFM.__eq__cCs ||||S)rr)rrrrrrr from_listsz DFM.from_listcCs |jS)zConvert to a nested list.)rtolistr;rrrto_listsz DFM.to_listcCs|||jS)zReturn a copy of self.)r&r6rr;rrrcopyszDFM.copycCst||j|jS)zConvert to a DDM.)DDMrFrHrrr;rrrr=sz DFM.to_ddmcCst||j|jS)zConvert to a SDM.)SDMrFrHrrr;rrrto_sdmsz DFM.to_sdmcCs|S)z Return self.rr;rrrto_dfmsz DFM.to_dfmcCs|S)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 rr;rrr to_dfm_or_ddmszDFM.to_dfm_or_ddmcCs|||j|jS)zConvert from a DDM.)rFrHrr)rddmrrrfrom_ddmsz DFM.from_ddmcCsl||}z|g||R}Wn>ty@td|Yn ty^td|Yn0||||S)z Inverse of :meth:`to_list_flat`.z'Incorrect number of elements for shape zInput should be a list of )rrrr)relementsrrfuncrrrrfrom_list_flats   zDFM.from_list_flatcCs |jS)zConvert to a flat list.)rentriesr;rrr to_list_flatszDFM.to_list_flatcCs |S)z$Convert to a flat list of non-zeros.)r= to_flat_nzr;rrrrVszDFM.to_flat_nzcCst|||S)zInverse of :meth:`to_flat_nz`.)rJ from_flat_nzrM)rrQdatarrrrrW szDFM.from_flat_nzcCs |S)zConvert to a DOD.)r=to_dodr;rrrrYsz DFM.to_dodcCst|||S)zInverse of :meth:`to_dod`.)rJfrom_dodrM)rZdodrrrrrrZsz DFM.from_dodcCs |S)zConvert to a DOK.)r=to_dokr;rrrr[sz DFM.to_dokcCst|||S)zInverse of :math:`to_dod`.)rJfrom_dokrM)rZdokrrrrrr\sz DFM.from_dokccsN|j\}}|j}t|D]0}t|D]"}|||f}|r$|||fVq$qdS)z/Iterate over the non-zero values of the matrix.Nrrranger%r8nrijZrepijrrr iter_values"s    zDFM.iter_valuesccsN|j\}}|j}t|D]0}t|D]"}|||f}|r$||f|fVq$qdS)zBIterate over indices and values of nonzero elements of the matrix.Nr]r_rrr iter_items,s    zDFM.iter_itemscCsd||jkr|S|tkr<|jtkr<|t|j|j|S| |rX| | St ddS)zConvert to a new domain.r'N)rrIrrrrr+rrr0r= convert_torMr/)r%rrrrre6s  zDFM.convert_toc Csn|j\}}|dkr||7}|dkr*||7}z|j||fWStyhtd|d|d|jYn0dS)zGet the ``(i, j)``-th entry.rInvalid indices (, ) for Matrix of shape Nrrr IndexError)r%rarbr8r`rrrgetitemDs  z DFM.getitemc Csp|j\}}|dkr||7}|dkr*||7}z||j||f<Wn.tyjtd|d|d|jYn0dS)zSet the ``(i, j)``-th entry.rrfrgrhNri)r%rarbvaluer8r`rrrsetitemRs  z DFM.setitemcs:|jfdd|D}t|tf}||||jS)z%Extract a submatrix with no checking.cs g|]fddDqS)csg|]}|fqSrr).0rb)Mrarr dr:z+DFM._extract...r)rnro j_indices)rarrpdr:z DFM._extract..)rr1rFr)r% i_indicesrrZlolrrrqr_extract`sz DFM._extractc Cs|j\}}g}g}|D]P}|dkr,||}n|}d|krD|ks\ntd|d|j||q|D]P} | dkr| |} n| } d| kr|ksntd| d|j|| ql|||S)zExtract a submatrix.rzInvalid row index z for Matrix of shape zInvalid column index )rrjappendrt) r%rZcolslistr8r`Znew_rowsZnew_colsraZi_posrbZj_posrrrextracths$     z DFM.extractcCs.|j\}}t||}t||}|||S)z Slice a DFM.)rr^rt)r%ZrowsliceZcolslicer8r`rsrrrrr extract_slices   zDFM.extract_slicecCs||j SzNegate a DFM matrix.r&rr;rrrnegszDFM.negcCs||j|jS)zAdd two DFM matrices.ryrCrrraddszDFM.addcCs||j|jS)zSubtract two DFM matrices.ryrCrrrsubszDFM.subcCs||j|S)z1Multiply a DFM matrix from the right by a scalar.ryrCrrrmulszDFM.mulcCs|||jS)z0Multiply a DFM matrix from the left by a scalar.ryrCrrrrmulszDFM.rmulcCs||S)z/Elementwise multiplication of two DFM matrices.)r=mul_elementwiserMrCrrrrszDFM.mul_elementwisecCs$|j|jf}||j|j||jS)zMultiply two DFM matrices.)r"r#rrr)r%rDrrrrmatmuls z DFM.matmulcCs|Srx)rzr;rrr__neg__sz DFM.__neg__cCs||}|||||S)zReturn a zero DFM matrix.)rr)rrrrRrrrzeross z DFM.zeroscCst||S)zReturn a one DFM matrix.)rJonesrM)rrrrrrrszDFM.onescCst||S)z%Return the identity matrix of size n.)rJeyerM)rr`rrrrrszDFM.eyecCst||S)zReturn a diagonal matrix.)rJdiagrM)rrQrrrrrszDFM.diagcCs|||S)z/Apply a function to each entry of a DFM matrix.)r= applyfuncrM)r%rRrrrrrsz DFM.applyfunccCs||j|j|jf|jS)zTranspose a DFM matrix.)rr transposer#r"rr;rrrrsz DFM.transposecGs|jdd|DS)zHorizontally stack matrices.cSsg|] }|qSrr=rnorrrrpr:zDFM.hstack..)r=hstackrMr%othersrrrrsz DFM.hstackcGs|jdd|DS)zVertically stack matrices.cSsg|] }|qSrrrrrrrpr:zDFM.vstack..)r=vstackrMrrrrrsz DFM.vstackcs,|j|j\}}fddtt||DS)z$Return the diagonal of a DFM matrix.csg|]}||fqSrr)rnrarorrrpr:z DFM.diagonal..)rrr^min)r%r8r`rrrdiagonals z DFM.diagonalcCsD|j}t|jD].}tt||jD]}|||fr$dSq$qdS)z2Return ``True`` if the matrix is upper triangular.FT)rr^r"rr#r%rorarbrrris_uppers   z DFM.is_uppercCsD|j}t|jD].}t|d|jD]}|||fr$dSq$qdS)z2Return ``True`` if the matrix is lower triangular.rFTrr^r"r#rrrris_lowers   z DFM.is_lowercCs|o|S)z*Return ``True`` if the matrix is diagonal.)rrr;rrr is_diagonalszDFM.is_diagonalcCs>|j}t|jD](}t|jD]}|||frdSqqdS)z1Return ``True`` if the matrix is the zero matrix.FTrrrrris_zero_matrixs   zDFM.is_zero_matrixcCs |S)z5Return the number of non-zero elements in the matrix.)r=nnzr;rrrrszDFM.nnzcCs |S)z7Return the strongly connected components of the matrix.)r=sccr;rrrrszDFM.sccrrcCs |jS)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. )rdetr;rrrr s1zDFM.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)rcharpolyZcoeffsr;rrrr?s*z DFM.charpolycCs|j}|j\}}||kr td|tkr6td|nJ|tksD|jrtz||j WSt ypt dYq0n t d|dS)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 %sN) rrr rr rr,r&rinvZeroDivisionErrorr r/)r%Kr8r`rrrrks7  zDFM.invcCs$|\}}}|||fS)z*Return the LU decomposition of the matrix.)r=lurM)r%LUZswapsrrrrszDFM.lucCs |\}}||fS)z*Return the QR decomposition of the matrix.)r=qrrM)r%QRrrrrszDFM.qrcCs|j|jks td|j|jf|jjs6td|j|j\}}|j\}}||krftd||||f||f}||kr||Sz|j |j}Wnt yt dYn0| |||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 Zis_Fieldrr r=lu_solverMrZsolverr r)r%rhsr8r`rbkZ sol_shapeZsolrrrrs .    z DFM.lu_solvec Cs|jtkrt|jdd}|dur|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) rrgetattrrrrrr=rM) r%rPrDrr8r`Zddm_pZddm_lZddm_dZddm_urrrrs   zDFM.fflucCs|\}}||fS)/Return a basis for the nullspace of the matrix.)r= nullspacerM)r%rO nonpivotsrrrr5sz DFM.nullspaceNcCs |j|d\}}||fS)r)pivots)rLnullspace_from_rrefrM)r%rZsdmrrrrrKszDFM.nullspace_from_rrefcCs|S)z+Return a particular solution to the system.)r= particularrMr;rrrrQszDFM.particularGz?RQ?zbasisapproxc Csldd}||}||}d|kr,dks6ntd|j\}}|j|krVtd|jj|||||dS)zACall the fmpz_mat.lll() method but check rank to avoid segfaults.cSs*t|rt|jt|jSt|SdSr7)rZof_typefloat numerator denominator)xrrrto_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)rrrZrankr lll) r%rrrrrrr8r`rrr_lllUs  zDFM._lll?cCsD|jtkrtd|jn|j|jkr.td|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%rrrrrrss    zDFM.lllcCsj|jtkrtd|jn|j|jkr.td|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%rrTZbasisZT_dfmrrr lll_transforms   zDFM.lll_transform)N)Frrrr)r)r)P__name__ __module__ __qualname____doc__fmtZis_DFMZis_DDMr classmethodrr&r r0rpropertyr6r>rArErFrHrIr=rLrMrNrPrSrUrVrWrYrZr[r\rcrdrerkrmrtrvrwrzr{r|r}r~rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrEs"                       2 + H J!   )rJ)rKN)Zsympy.external.gmpyrZsympy.external.importtoolsrZsympy.utilities.decoratorrZsympy.polys.domainsrr exceptionsrr r r r r rZ__doctest_skip__r__all__rZsympy.polys.matrices.ddmrJrKrrrr*s$   $  v