sglyddlmZddlmZddlmZddlmZmZddl m Z m Z m Z m Z mZmZmZedk7rdgZedZd gZedg Gd d Zdd lmZdd lmZy)) GROUND_TYPES) import_module)doctest_depends_onZZQQ)DMBadInputError DMDomainErrorDMNonSquareMatrixErrorDMNonInvertibleMatrixError DMRankError DMShapeError DMValueErrorflint*DFM ground_typesceZdZdZdZdZdZdZedZ dZ edZ ed Z ed Z ed Zd Zd ZdZedZdZdZdZdZdZdZedZedZdZdZedZdZedZ dZ!edZ"dZ#d Z$d!Z%d"Z&d#Z'd$Z(d%Z)d&Z*d'Z+d(Z,d)Z-d*Z.d+Z/d,Z0d-Z1d.Z2ed/Z3ed0Z4ed1Z5ed2Z6d3Z7d4Z8d5Z9d6Z:d7Z;d8Zd;Z?d<Z@d=ZAeBd>?d@ZCeBd>?dAZDeBd>?dBZEdCZFeBd>?dDZGdEZHdLdGZIdHZJdMdIZKeBd>?dNdJZLeBd>?dNdKZMyF)Ora& 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|j|}d|vr ||}n||}|j |||S#ttf$rtd|wxYw)Construct from a nested list.rz"Input should be a list of list of )_get_flint_func ValueError TypeErrorr _new)clsrowslistshapedomain flint_matreps L/var/www/html/venv/lib/python3.12/site-packages/sympy/polys/matrices/_dfm.py__new__z DFM.__new__mss''/ E> U)U#CxxUF++  * U%(J6(&STT Us 8Ac|j|||tj|}||_|x|_\|_|_||_|S)z)Internal constructor from a flint matrix.)_checkobjectr%r#r rowscolsr!)rr#r r!objs r$rzDFM._new{sJ 3v&nnS!).. &CHch  cP|j||j|jS)z>Create a new DFM with the same shape and domain but a new rep.)rr r!)selfr#s r$_new_repz DFM._new_repsyydjj$++66r,cN|j|jf}||k7r td|tk(r%t |t j s td|tk(r%t |t js td|ttfvr tdy)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#r r!repshapes r$r'z DFM._checksIIK- u !"LM M R< 3 ?<= = r\*S%.."A<= = B8 #%&KL L$r,c|ttfvS)z4Return True if the given domain is supported by DFM.rrr!s r$_supports_domainzDFM._supports_domains"b!!r,c||tk(rtjS|tk(rtjSt d)z3Return the flint matrix class for the given domain.r1)rrr5rr7r8r;s r$rzDFM._get_flint_funcs2 R<>> ! r\>> !%&KL Lr,c8|j|jS)z5Callable to create a flint matrix of the same domain.)rr!r.s r$_funcz DFM._funcs##DKK00r,c4t|jS)zReturn ``str(self)``.)strto_ddmr?s r$__str__z DFM.__str__s4;;=!!r,c@dt|jddS)zReturn ``repr(self)``.rN)reprrCr?s r$__repr__z DFM.__repr__s"T$++-(,-..r,ct|tstS|j|jk(xr|j|jk(S)zReturn ``self == other``.)r4rNotImplementedr!r#r.others r$__eq__z DFM.__eq__s9%%! !{{ell*Dtxx599/DDr,c||||S)r)rrr r!s r$ from_listz DFM.from_lists8UF++r,c6|jjS)zConvert to a nested list.)r#tolistr?s r$to_listz DFM.to_listsxx  r,cV|j|j|jS)zReturn a copy of self.)r/r@r#r?s r$copyzDFM.copys}}TZZ122r,cttj|j|j|jS)zConvert to a DDM.)DDMrPrSr r!r?s r$rCz DFM.to_ddm#}}T\\^TZZEEr,cttj|j|j|jS)zConvert to a SDM.)SDMrPrSr r!r?s r$to_sdmz DFM.to_sdmrXr,c|S)z Return self.rOr?s r$to_dfmz DFM.to_dfms r,c|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 rOr?s r$ to_dfm_or_ddmzDFM.to_dfm_or_ddms  r,cl|j|j|j|jS)zConvert from a DDM.)rPrSr r!)rddms r$from_ddmz DFM.from_ddms%}}S[[]CIIszzBBr,c|j|} |g||}||||S#t$rtd|t$rtd|wxYw)z Inverse of :meth:`to_list_flat`.z'Incorrect number of elements for shape zInput should be a list of )rrr r)relementsr r!funcr#s r$from_list_flatzDFM.from_list_flats""6* I((x(C 3v&&  U!$KE7"ST T I!$>vh"GH H Is '.Ac6|jjS)zConvert to a flat list.)r#entriesr?s r$ to_list_flatzDFM.to_list_flatsxx!!r,c>|jjS)z$Convert to a flat list of non-zeros.)rC to_flat_nzr?s r$rkzDFM.to_flat_nzs{{}''))r,cLtj|||jS)zInverse of :meth:`to_flat_nz`.)rW from_flat_nzr])rrddatar!s r$rmzDFM.from_flat_nzs"$7>>@@r,c>|jjS)zConvert to a DOD.)rCto_dodr?s r$rpz DFM.to_dod{{}##%%r,cLtj|||jS)zInverse of :meth:`to_dod`.)rWfrom_dodr])rdodr r!s r$rsz DFM.from_dod ||C/6688r,c>|jjS)zConvert to a DOK.)rCto_dokr?s r$rwz DFM.to_dok rqr,cLtj|||jS)zInverse of :math:`to_dod`.)rWfrom_dokr])rdokr r!s r$ryz DFM.from_dokrur,c#K|j\}}|j}t|D]%}t|D]}|||f}|s |||f'yw)z0Iterater over the non-zero values of the matrix.Nr r#ranger.mnr#ijrepijs r$ iter_valueszDFM.iter_valuess_zz1hhq $A1X $AqD ad)O $ $s AAAc#K|j\}}|j}t|D]$}t|D]}|||f}|s ||f|f&yw)zBIterate over indices and values of nonzero elements of the matrix.Nr|r~s r$ iter_itemszDFM.iter_itemss`zz1hhq *A1X *AqD q65/) * *s AA Ac||jk(r|jS|tk(rM|jtk(r:|j t j |j|j|S|tk(r@|jtk(r-|jj|jStd)zConvert to a new domain.r1) r!rUrrrrr7r#r rC convert_tor]r8)r.r!s r$rzDFM.convert_to's T[[ 99;  r\dkkR/99U^^DHH5tzz6J J r\dkkR/;;=++F3::< <&&KL Lr,c |j\}}|dkr||z }|dkr||z } |j||fS#t$rtd|d|d|jwxYw)zGet the ``(i, j)``-th entry.rInvalid indices (, ) for Matrix of shape r r#r IndexError)r.rrrrs r$getitemz DFM.getitem5s~zz1 q5 FA q5 FA ]88AqD> ! ]02aS8Ntzzl[\ \ ]s 6(Ac |j\}}|dkr||z }|dkr||z } ||j||f<y#t$rtd|d|d|jwxYw)zSet the ``(i, j)``-th entry.rrrrNr)r.rrvaluerrs r$setitemz DFM.setitemCs}zz1 q5 FA q5 FA ]"DHHQTN ]02aS8Ntzzl[\ \ ]s 7(Ac |j}|Dcgc]}|Dcgc] }|||f c}}}}t|t|f}|j|||jScc}wcc}}w)z%Extract a submatrix with no checking.)r#lenrPr!)r. i_indices j_indicesMrrlolr s r$_extractz DFM._extractQsd HH5>?+A!Q$+??YY0~~c5$++66,?s A)A$ A)$A)c|j\}}g}g}|D]H}|dkr||z}n|}d|cxkr|ksntd|d|j|j|J|D]H} | dkr| |z} n| } d| cxkr|ksntd| d|j|j| J|j||S)zExtract a submatrix.rzInvalid row index z for Matrix of shape zInvalid column index )r rappendr) r.rcolslistrrnew_rowsnew_colsri_posrj_poss r$extractz DFM.extractYs zz1 #A1uA>> #5aS8Mdjj\!Z[[ OOE " # #A1uA>> #8;PQUQ[Q[P\!]^^ OOE " #}}Xx00r,c||j\}}t||}t||}|j||S)z Slice a DFM.)r r}r)r.rowslicecolslicerrrrs r$ extract_slicezDFM.extract_slicews>zz1!HX& !HX& }}Y 22r,c:|j|j SzNegate a DFM matrix.r/r#r?s r$negzDFM.negs}}dhhY''r,cR|j|j|jzS)zAdd two DFM matrices.rrKs r$addzDFM.add}}TXX 122r,cR|j|j|jz S)zSubtract two DFM matrices.rrKs r$subzDFM.subrr,c>|j|j|zS)z1Multiply a DFM matrix from the right by a scalar.rrKs r$mulzDFM.muls}}TXX-..r,c>|j||jzS)z0Multiply a DFM matrix from the left by a scalar.rrKs r$rmulzDFM.rmuls}}UTXX-..r,cx|jj|jjS)z/Elementwise multiplication of two DFM matrices.)rCmul_elementwiser]rKs r$rzDFM.mul_elementwises*{{},,U\\^<CCEEr,c|j|jf}|j|j|jz||jS)zMultiply two DFM matrices.)r)r*rr#r!)r.rLr s r$matmulz DFM.matmuls8EJJ'yyEII-udkkBBr,c"|jSr)rr?s r$__neg__z DFM.__neg__sxxzr,cP|j|}|j||||S)zReturn a zero DFM matrix.)rr)rr r!res r$zerosz DFM.zeross+""6*xxe eV44r,cJtj||jS)zReturn a one DFM matrix.)rWonesr])rr r!s r$rzDFM.onessxxv&--//r,cJtj||jS)z%Return the identity matrix of size n.)rWeyer])rrr!s r$rzDFM.eyeswwq&!((**r,cJtj||jS)zReturn a diagonal matrix.)rWdiagr])rrdr!s r$rzDFM.diagsxx&)0022r,c^|jj||jS)z/Apply a function to each entry of a DFM matrix.)rC applyfuncr])r.rer!s r$rz DFM.applyfuncs${{}&&tV4;;==r,c|j|jj|j|jf|j S)zTranspose a DFM matrix.)rr# transposer*r)r!r?s r$rz DFM.transposes3yy++- 499/Et{{SSr,c|jj|Dcgc]}|jc}jScc}w)zHorizontally stack matrices.)rChstackr]r.othersos r$rz DFM.hstack8#t{{}##&%AQahhj%ABIIKK%AAc|jj|Dcgc]}|jc}jScc}w)zVertically stack matrices.)rCvstackr]rs r$rz DFM.vstackrrc|j}|j\}}tt||Dcgc] }|||f c}Scc}w)z$Return the diagonal of a DFM matrix.)r#r r}min)r.rrrrs r$diagonalz DFM.diagonals? HHzz1!&s1ay!12A!Q$222sAc|j}t|jD]}t|D] }|||fs yy)z2Return ``True`` if the matrix is upper triangular.FT)r#r}r)r.rrrs r$is_upperz DFM.is_uppersI HHtyy! !A1X !QT7  ! !r,c|j}t|jD]*}t|dz|jD] }|||fs y,y)z2Return ``True`` if the matrix is lower triangular.r FTr#r}r)r*rs r$is_lowerz DFM.is_lowersT HHtyy! !A1q5$)), !QT7  ! !r,cF|jxr|jS)z*Return ``True`` if the matrix is diagonal.)rrr?s r$ is_diagonalzDFM.is_diagonals}}24==?2r,c|j}t|jD]&}t|jD] }|||fs y(y)z1Return ``True`` if the matrix is the zero matrix.FTrrs r$is_zero_matrixzDFM.is_zero_matrixsN HHtyy! !A499% !QT7  ! !r,c>|jjS)z5Return the number of non-zero elements in the matrix.)rCnnzr?s r$rzDFM.nnz{{}  ""r,c>|jjS)z7Return the strongly connected components of the matrix.)rCsccr?s r$rzDFM.sccrr,rrc6|jjS)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#detr?s r$rzDFM.detsbxx||~r,c^|jjjdddS)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#charpolycoeffsr?s r$rz DFM.charpoly0s*Txx  "))+DbD11r,c8|j}|j\}}||k7r td|tk(rt d|z|t k(r* |j |jjStd|z#t$r tdwxYw)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) r!r r rr rr/r#invZeroDivisionErrorr r8)r.Krrs r$rzDFM.inv\sn KKzz1 6()LM M 7 81 <= = "W M}}TXX\\^44 &&Ka&OP P % M01KLL Ms (BBc|jj\}}}|j|j|fS)z*Return the LU decomposition of the matrix.)rClur])r.LUswapss r$rzDFM.lus5kkm&&( 1exxz188:u,,r,c |j|jk(s%td|jd|j|jjstd|jz|j\}}|j\}}||k7rt d|d|d|d|||f}||k7r;|j j |j jS |jj|j}|j|||jS#t$r tdwxYw)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: z != zField expected, got %szMatrix size mismatch: z * z vs z Matrix det == 0; not invertible.) r!r is_Fieldr rrClu_solver]r#solverr r)r.rhsrrrk sol_shapesols r$rz DFM.lu_solves\{{cjj($++szz Z[ [ {{## 84;; FG Gzz1yy1 6QPQSTVWXY YF 6;;=))#**,7>>@ @ Q((..)Cyyi55! Q,-OP P Qs ,%D..Ech|jj\}}|j|fS)/Return a basis for the nullspace of the matrix.)rC nullspacer])r.ra nonpivotss r$rz DFM.nullspaces-&002Yzz|Y&&r,Ncl|jj|\}}|j|fS)r)pivots)r[nullspace_from_rrefr])r.rsdmrs r$rzDFM.nullspace_from_rrefs2::&:IYzz|Y&&r,cZ|jjjS)z+Return a particular solution to the system.)rC particularr]r?s r$rzDFM.particulars {{}'')0022r,cd}||}||}d|cxkrdkstdtd|j\}}|jj|k7r t d|jj |||||S)zACall the fmpz_mat.lll() method but check rank to avoid segfaults.ctj|r+t|jt|jz St|SN)rof_typefloat numerator denominator)xs r$to_floatzDFM._lll..to_float*s3zz!}Q[[)E!--,@@@Qxr,g?r z delta must be between 0.25 and 1z-Matrix must have full row rank for Flint LLL.) transformdeltaetar#gram)rr r#rankrlll) r.r r r r#r r rrs r$_lllzDFM._lll s smeaAB B AB Bzz1 88==?a MN Nxx||iu#3UY|ZZr,c|jtk7rtd|jz|j|jkDr t d|j |}|j|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 )r!rr r)r*rrr/)r.r r#s r$rzDFM.lll>s`, ;;"  5 CD D YY "MN Niiei$}}S!!r,c\|jtk7rtd|jz|j|jkDr t d|j d|\}}|j|}|j||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)r r ) r!rr r)r*rrr/r)r.r r#TbasisT_dfms r$ lll_transformzDFM.lll_transform\s2 ;;"  5 CD D YY "MN NT7Q c" !dii3T[[Ae|r,r)FgGz?gRQ?zbasisapprox)g?)N__name__ __module__ __qualname____doc__fmtis_DFMis_DDMr% classmethodrr/r'r<rpropertyr@rDrHrMrPrSrUrCr[r]r_rbrfrirkrmrprsrwryrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrOr,r$rrEs D C F F ,7 M M""MM11"/E,,!3FF CC ' '"*AA&99&99$* M ] ]71<3(33//F C5500 ++ 33>TLL3 3##W-0.0dW-)2.)2VW-FQ.FQP- W-H6.H6T',' 3[<W-".":W- . r,)rW)rZN)sympy.external.gmpyrsympy.external.importtoolsrsympy.utilities.decoratorrsympy.polys.domainsrr exceptionsr r r r rrr__doctest_skip__r__all__rsympy.polys.matrices.ddmrWrZrOr,r$r,svT-48&7u g ''+w w ,w v)(r,