glyddlmZddlmZddlmZddlmZmZddl m Z m Z m Z m Z mZmZmZedkrdgZedZd gZedg Gd d Zdd lmZdd lmZdS)) 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>?dDZGdEZHdQdGZIdHZJdRdMZKeBd>?dSdOZLeBd>?dSdPZMdFS)Tra& 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||}d|vr4 ||}n,#ttf$rtd|wxYw||}||||S)Construct from a nested list.rz"Input should be a list of list of )_get_flint_func ValueError TypeErrorr _new)clsrowslistshapedomain flint_matreps U/var/www/html/ai-engine/env/lib/python3.11/site-packages/sympy/polys/matrices/_dfm.py__new__z DFM.__new__ms''// E>> Ui)) * U U U%&S6&S&STTT U)U#CxxUF+++s '$A c||||t|}||_|x|_\|_|_||_|S)z)Internal constructor from a flint matrix.)_checkobjectr%r#r rowscolsr!)rr#r r!objs r$rzDFM._new{sS 3v&&&nnS!!).. &CHch  cD|||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_repsyydj$+666r,c||f}||krtd|tkr)t |t jstd|tkr)t |t j std|ttfvrtddS)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._checksIIKK- u  !"LMM M R<< 3 ? ?<<== = r\\*S%."A"A\<== = B8 # #%&KLL L$ #r,c"|ttfvS)z4Return True if the given domain is supported by DFM.rrr!s r$_supports_domainzDFM._supports_domains"b!!r,c||tkr tjS|tkr tjSt d)z3Return the flint matrix class for the given domain.r1)rrr5rr7r8r;s r$rzDFM._get_flint_funcs5 R<<> ! r\\> !%&KLL Lr,c6||jS)z5Callable to create a flint matrix of the same domain.)rr!r.s r$_funcz DFM._funcs##DK000r,cDt|S)zReturn ``str(self)``.)strto_ddmr?s r$__str__z DFM.__str__s4;;==!!!r,cZdt|ddS)zReturn ``repr(self)``.rN)reprrCr?s r$__repr__z DFM.__repr__s).T$++--((,...r,czt|tstS|j|jko|j|jkS)zReturn ``self == other``.)r4rNotImplementedr!r#r.others r$__eq__z DFM.__eq__s9%%% "! !{el*Dtx59/DDr,c||||S)r)rrr r!s r$ from_listz DFM.from_listss8UF+++r,c4|jS)zConvert to a nested list.)r#tolistr?s r$to_listz DFM.to_listsx   r,c\|||jS)zReturn a copy of self.)r/r@r#r?s r$copyzDFM.copys"}}TZZ11222r,cftj||j|jS)zConvert to a DDM.)DDMrPrSr r!r?s r$rCz DFM.to_ddm"}T\\^^TZEEEr,cftj||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,ch|||j|jS)zConvert from a DDM.)rPrSr r!)rddms r$from_ddmz DFM.from_ddms&}}S[[]]CIszBBBr,c||} |g||R}n;#t$rtd|t$rtd|wxYw||||S)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(((CC U U U!"SE"S"STT T I I I!"Gv"G"GHH H Is3v&&&s "8Ac4|jS)zConvert to a flat list.)r#entriesr?s r$ to_list_flatzDFM.to_list_flatsx!!!r,cN|S)z$Convert to a flat list of non-zeros.)rC to_flat_nzr?s r$rkzDFM.to_flat_nzs{{}}'')))r,cRtj|||S)zInverse of :meth:`to_flat_nz`.)rW from_flat_nzr])rrddatar!s r$rmzDFM.from_flat_nzs%$77>>@@@r,cN|S)zConvert to a DOD.)rCto_dodr?s r$rpz DFM.to_dod{{}}##%%%r,cRtj|||S)zInverse of :meth:`to_dod`.)rWfrom_dodr])rdodr r!s r$rsz DFM.from_dod$|C//66888r,cN|S)zConvert to a DOK.)rCto_dokr?s r$rwz DFM.to_dok rqr,cRtj|||S)zInverse of :math:`to_dod`.)rWfrom_dokr])rdokr r!s r$ryz DFM.from_dokrur,c#K|j\}}|j}t|D],}t|D]}|||f}|r |||fV-dS)z0Iterater over the non-zero values of the matrix.Nr r#ranger.mnr#ijrepijs r$ iter_valueszDFM.iter_valuessxz1hq $ $A1XX $ $AqD $ad)OOO $ $ $r,c#K|j\}}|j}t|D](}t|D]}|||f}|r||f|fV)dS)zBIterate over indices and values of nonzero elements of the matrix.Nr|r~s r$ iter_itemszDFM.iter_itemss{z1hq * *A1XX * *AqD *q65/))) * * *r,c||jkr|S|tkrI|jtkr9|t |j|j|S|tkrI|jtkr9| | Std)zConvert to a new domain.r1) r!rUrrrrr7r#r rC convert_tor]r8)r.r!s r$rzDFM.convert_to's T[ 99;;  r\\dkR//99U^^DH55tz6JJ J r\\dkR//;;==++F33::<< <&&KLL 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.getitem5sz1 q55 FA q55 FA ]8AqD> ! ] ] ][[[a[[tz[[\\ \ ]s 1(Ac |j\}}|dkr||z }|dkr||z } ||j||f<dS#t$rtd|d|d|jwxYw)zSet the ``(i, j)``-th entry.rrrrNr)r.rrvaluerrs r$setitemz DFM.setitemCsz1 q55 FA q55 FA ]"DHQTNNN ] ] ][[[a[[tz[[\\ \ ]s 0(Ac|jfd|D}t|tf}||||jS)z%Extract a submatrix with no checking.c0g|]fdDS)c$g|] }|f SrOrO).0rMrs r$ z+DFM._extract...Us!+++A!Q$+++r,rO)rrr j_indicess @r$rz DFM._extract..Us2???++++++++???r,)r#lenrPr!)r. i_indicesrlolr rs ` @r$_extractz DFM._extractQsW H?????Y???YY0~~c5$+666r,c|j\}}g}g}|D]N}|dkr||z}n|}d|cxkr|ksntd|d|j||O|D]N} | dkr| |z} n| } d| cxkr|ksntd| d|j|| O|||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 z1 # #A1uuA>>>>>>>> !Za!Z!Zdj!Z!Z[[[ OOE " " " " # #A1uuA>>>>>>>> !]!]!]QUQ[!]!]^^^ OOE " " " "}}Xx000r,c|j\}}t||}t||}|||S)z Slice a DFM.)r r}r)r.rowslicecolslicerrrrs r$ extract_slicezDFM.extract_slicewsCz1!HHX& !HHX& }}Y 222r,c8||j SzNegate a DFM matrix.r/r#r?s r$negzDFM.negs}}dhY'''r,cF||j|jzS)zAdd two DFM matrices.rrKs r$addzDFM.add}}TX 1222r,cF||j|jz S)zSubtract two DFM matrices.rrKs r$subzDFM.subrr,c<||j|zS)z1Multiply a DFM matrix from the right by a scalar.rrKs r$mulzDFM.muls}}TX-...r,c<|||jzS)z0Multiply a DFM matrix from the left by a scalar.rrKs r$rmulzDFM.rmuls}}UTX-...r,c||S)z/Elementwise multiplication of two DFM matrices.)rCmul_elementwiser]rKs r$rzDFM.mul_elementwises4{{}},,U\\^^<<CCEEEr,cp|j|jf}||j|jz||jS)zMultiply two DFM matrices.)r)r*rr#r!)r.rLr s r$matmulz DFM.matmuls1EJ'yyEI-udkBBBr,c*|Sr)rr?s r$__neg__z DFM.__neg__sxxzzr,c`||}|||||S)zReturn a zero DFM matrix.)rr)rr r!res r$zerosz DFM.zeross3""6**xxe eV444r,cPtj||S)zReturn a one DFM matrix.)rWonesr])rr r!s r$rzDFM.oness"xv&&--///r,cPtj||S)z%Return the identity matrix of size n.)rWeyer])rrr!s r$rzDFM.eyes"wq&!!((***r,cPtj||S)zReturn a diagonal matrix.)rWdiagr])rrdr!s r$rzDFM.diags"x&))00222r,cv|||S)z/Apply a function to each entry of a DFM matrix.)rC applyfuncr])r.rer!s r$rz DFM.applyfuncs,{{}}&&tV44;;===r,c||j|j|jf|jS)zTranspose a DFM matrix.)rr# transposer*r)r!r?s r$rz DFM.transposes1yy++-- 49/Et{SSSr,cr|jd|DS)zHorizontally stack matrices.c6g|]}|SrOrCros r$rzDFM.hstack.. %A%A%AQahhjj%A%A%Ar,)rChstackr]r.otherss r$rz DFM.hstack5#t{{}}#%A%A&%A%A%ABIIKKKr,cr|jd|DS)zVertically stack matrices.c6g|]}|SrOrrs r$rzDFM.vstack..rr,)rCvstackr]rs r$rz DFM.vstackrr,cx|j|j\}}fdtt||DS)z$Return the diagonal of a DFM matrix.c$g|] }||f SrOrO)rrrs r$rz DFM.diagonal..s!222A!Q$222r,)r#r r}min)r.rrrs @r$diagonalz DFM.diagonals? Hz12222s1ayy!1!12222r,c|j}t|jD]"}t|D]}|||frdS#dS)z2Return ``True`` if the matrix is upper triangular.FT)r#r}r)r.rrrs r$is_upperz DFM.is_uppersa Hty!! ! !A1XX ! !QT7! 555! !tr,c|j}t|jD]+}t|dz|jD]}|||frdS,dS)z2Return ``True`` if the matrix is lower triangular.r FTr#r}r)r*rs r$is_lowerz DFM.is_lowersk Hty!! ! !A1q5$),, ! !QT7! 555! !tr,cR|o|S)z*Return ``True`` if the matrix is diagonal.)rrr?s r$ is_diagonalzDFM.is_diagonals}}24==??2r,c|j}t|jD]'}t|jD]}|||frdS(dS)z1Return ``True`` if the matrix is the zero matrix.FTrrs r$is_zero_matrixzDFM.is_zero_matrixse Hty!! ! !A49%% ! !QT7! 555! !tr,cN|S)z5Return the number of non-zero elements in the matrix.)rCnnzr?s r$rzDFM.nnz{{}}  """r,cN|S)z7Return the strongly connected components of the matrix.)rCsccr?s r$rzDFM.sccrr,rrc4|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. )r#detr?s r$rzDFM.detsbx||~~r,cj|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#charpolycoeffsr?s r$rz DFM.charpoly0s0Tx  ""))++DDbD11r,cV|j}|j\}}||krtd|tkrt d|z|t krJ ||jS#t$rtdwxYwtd|z)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 Kz1 66()LMM M 77 81 <== = "WW M}}TX\\^^444$ M M M01KLLL M &&Ka&OPP Ps +A<<Bc|\}}}|||fS)z*Return the LU decomposition of the matrix.)rClur])r.LUswapss r$rzDFM.lus>kkmm&&(( 1exxzz188::u,,r,c n|j|jkstd|jd|j|jjstd|jz|j\}}|j\}}||krt d|d|d|d|||f}||krK||S |j |j}n#t$rtdwxYw| |||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: 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_solvesP\{cj((-$+++szz Z[[ [ {# H 84; FGG Gz1y1 66,QQQPQPQPQSTSTSTVWVWXYY YF 66;;==))#**,,77>>@@ @ Q(..))CC  Q Q Q,-OPP P Qyyi555s C>>Dc|\}}||fS)/Return a basis for the nullspace of the matrix.)rC nullspacer])r.ra nonpivotss r$rz DFM.nullspaces4&0022Yzz||Y&&r,Nc||\}}||fS)r)pivots)r[nullspace_from_rrefr])r.rsdmrs r$rzDFM.nullspace_from_rrefs9::&:IIYzz||Y&&r,cr|S)z+Return a particular solution to the system.)rC particularr]r?s r$r zDFM.particulars({{}}''))00222r,Gz?RQ?zbasisapproxcd}||}||}d|cxkrdksntd|j\}}|j|krt d|j|||||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*s<z!}} Q[))E!-,@,@@@Qxxr,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.rrrr#rrrrs r$_lllzDFM._lll s   hsmmeaABB Bz1 8==??a  MNN Nx||iu#3UY|ZZZr,?c|jtkrtd|jz|j|jkrt 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)r!rr r)r*rrr/)r.rr#s r$rzDFM.lll>sj, ;"   5 CDD D Y " "MNN Niiei$$}}S!!!r,cD|jtkrtd|jz|j|jkrt d|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. r r!T)rr) r!rr r)r*rrr/r)r.rr#TbasisT_dfms r$ lll_transformzDFM.lll_transform\s2 ;"   5 CDD D Y " "MNN NT77Q c"" !di3T[AAe|r,r)Fr r r r )r)N__name__ __module__ __qualname____doc__fmtis_DFMis_DDMr% classmethodrr/r'r<rpropertyr@rDrHrMrPrSrUrCr[r]r_rbrfrirkrmrprsrwryrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrr&rOr,r$rrEs  D C F F , , ,[777 M M[ M""["MM[M11X1"""///EEE,,[,!!!333FFFFFF CC[C ' '[ '"""***AA[A&&&99[9&&&99[9$$$*** M M M ] ] ] ] ] ]777111<333(((333333//////FFF CCC55[500[0 ++[+ 33[3>>>TTTLLLLLL333 333######W---00.-0dW---)2)2.-)2VW---FQFQ.-FQP--- W---H6H6.-H6T''','''' 333[[[[<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$r8sYT-,,,,,444444888888&&&&&&&&7u  g ''+++w w w w w w w ,+w v)(((((((((((((r,