ЦilySSKJr SSKJr SSKJr SSKJrJr SSK J r J r J r J r JrJrJr \S:waS/r\"S5rS /r\"S/S 9"S S 55rSS KJr SS KJr g)) GROUND_TYPES) import_module)doctest_depends_onZZQQ)DMBadInputError DMDomainErrorDMNonSquareMatrixErrorDMNonInvertibleMatrixError DMRankError DMShapeError DMValueErrorflint*DFM ground_typesc\rSrSrSrSrSrSrSr\ S5r Sr \ S 5r \ S 5r \ S 5r\S 5rS rSrSr\ S5rSrSrSrSrSrSr\ S5r\ S5rSrSr\ S5rSr \ S5r!Sr"\ S5r#S r$S!r%S"r&S#r'S$r(S%r)S&r*S'r+S(r,S)r-S*r.S+r/S,r0S-r1S.r2S/r3\ S05r4\ S15r5\ S25r6\ S35r7S4r8S5r9S6r:S7r;S8rS;r?S<r@S=rAS>rB\C"S?S@9SA5rD\C"S?S@9SB5rE\C"S?S@9SC5rFSDrG\C"S?S@9SE5rHSFrISNSHjrJSIrKSOSJjrL\C"S?S@9SPSKj5rM\C"S?S@9SPSLj5rNSMrOgG)QrEa 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]] denseTFcURU5nSU;a U"U5nOU"U6nUR XRU5$![[4a [SU35ef=f)Construct from a nested list.rz"Input should be a list of list of )_get_flint_func ValueError TypeErrorr _new)clsrowslistshapedomain flint_matreps X/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/sympy/polys/matrices/_dfm.py__new__ DFM.__new__msq''/ E> U)U#CxxF++  * U%(J6(&STT Us 9AcURXU5 [RU5nXlU=UluUlUlX4lU$)z)Internal constructor from a flint matrix.)_checkobjectr&r$r!rowscolsr")rr$r!r"objs r%rDFM._new{sD 3v&nnS!).. &CHch  cNURXRUR5$)z>Create a new DFM with the same shape and domain but a new rep.)rr!r")selfr$s r%_new_rep DFM._new_repsyyjj$++66r/cjUR5UR54nXB:wa [S5eU[:Xa*[ U[ R 5(d [S5eU[:Xa*[ U[ R5(d [S5eU[[4;a [S5eg)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) DFM._checksIIK-  !"LM M R< 3 ? ?<= = r\*S%.."A"A<= = B8 #%&KL L$r/c U[[4;$)z4Return True if the given domain is supported by DFM.rrr"s r%_supports_domainDFM._supports_domains"b!!r/cU[:Xa[R$U[:Xa[R$[ S5e)z3Return the flint matrix class for the given domain.r5)rrr9rr;r<r@s r%rDFM._get_flint_funcs2 R<>> ! r\>> !%&KL Lr/c8URUR5$)z5Callable to create a flint matrix of the same domain.)rr"r1s r%_func DFM._funcs##DKK00r/c4[UR55$)zReturn ``str(self)``.)strto_ddmrFs r%__str__ DFM.__str__s4;;=!!r/c@S[UR55SS3$)zReturn ``repr(self)``.rN)reprrKrFs r%__repr__ DFM.__repr__s"T$++-(,-..r/c[U[5(d[$URUR:H=(a URUR:H$)zReturn ``self == other``.)r8rNotImplementedr"r$r1others r%__eq__ DFM.__eq__s<%%%! !{{ell*Dtxx599/DDr/cU"XU5$)r)rr r!r"s r% from_list DFM.from_lists8F++r/c6URR5$)zConvert to a nested list.)r$tolistrFs r%to_list DFM.to_listsxx  r/cVURURUR55$)zReturn a copy of self.)r2rGr$rFs r%copyDFM.copys}}TZZ122r/cv[R"UR5URUR5$)zConvert to a DDM.)DDMr[r_r!r"rFs r%rK DFM.to_ddm#}}T\\^TZZEEr/cv[R"UR5URUR5$)zConvert to a SDM.)SDMr[r_r!r"rFs r%to_sdm DFM.to_sdmrgr/cU$)z Return self.rZrFs r%to_dfm DFM.to_dfms r/cU$)a 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 rZrFs r% to_dfm_or_ddmDFM.to_dfm_or_ddms  r/clURUR5URUR5$)zConvert from a DDM.)r[r_r!r")rddms r%from_ddm DFM.from_ddms%}}S[[]CIIszzBBr/cURU5nU"/UQUP76nU"XRU5$![a [SU35e[a [SU35ef=f)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_flatDFM.from_list_flats}""6* I((x(C 3v&&  U!$KE7"ST T I!$>vh"GH H Is &0Ac6URR5$)zConvert to a flat list.)r$entriesrFs r% to_list_flatDFM.to_list_flatsxx!!r/c>UR5R5$)z$Convert to a flat list of non-zeros.)rK to_flat_nzrFs r%rDFM.to_flat_nzs{{}''))r/cL[R"XU5R5$)zInverse of :meth:`to_flat_nz`.)re from_flat_nzrm)rrwdatar"s r%rDFM.from_flat_nzs 7>>@@r/c>UR5R5$)zConvert to a DOD.)rKto_dodrFs r%r DFM.to_dod{{}##%%r/cL[R"XU5R5$)zInverse of :meth:`to_dod`.)refrom_dodrm)rdodr!r"s r%r DFM.from_dod||C/6688r/c>UR5R5$)zConvert to a DOK.)rKto_dokrFs r%r DFM.to_dok rr/cL[R"XU5R5$)zInverse of :math:`to_dod`.)refrom_dokrm)rdokr!r"s r%r DFM.from_dokrr/c## URupURn[U5H,n[U5HnX4U4nU(dMX4U4v M M. g7f)z0Iterater over the non-zero values of the matrix.Nr!r$ranger1mnr$ijrepijs r% iter_valuesDFM.iter_valuessPzzhhqA1XqD 5d)Os AAAc## URupURn[U5H+n[U5HnX4U4nU(dMXE4U4v M M- g7f)zBIterate over indices and values of nonzero elements of the matrix.Nrrs r% iter_itemsDFM.iter_itemssQzzhhqA1XqD 565/)s AAAcXR:XaUR5$U[:XaNUR[:Xa:UR [ R UR5URU5$U[:XaAUR[:Xa-UR5RU5R5$[S5e)zConvert to a new domain.r5) r"rbrrrrr;r$r!rK convert_tormr<)r1r"s r%rDFM.convert_to's [[ 99;  r\dkkR/99U^^DHH5tzz6J J r\dkkR/;;=++F3::< <&&KL Lr/c URup4US:aX- nUS:aX$- nURX4$![a [SUSUSUR35ef=f)zGet the ``(i, j)``-th entry.rInvalid indices (, ) for Matrix of shape r!r$r IndexError)r1rrrrs r%getitem DFM.getitem5svzz q5 FA q5 FA ]88AD> ! ]02aS8Ntzzl[\ \ ] 4)Ac URupEUS:aX- nUS:aX%- nX0RX4'g![a [SUSUSUR35ef=f)zSet the ``(i, j)``-th entry.rrrrNr)r1rrvaluerrs r%setitem DFM.setitemCsszz q5 FA q5 FA ]"HHQTN ]02aS8Ntzzl[\ \ ]rc URnUVVs/sHoBVs/sHoSXE4PM snPM nnn[U5[U54nURXgUR5$s snfs snnf)z%Extract a submatrix with no checking.)r$lenr[r")r1 i_indices j_indicesMrrlolr!s r%_extract DFM._extractQsc HH5>?Y+A!$+Y?YY0~~c$++66,?s A+A& A+&A+cURup4/n/nUHKnUS:aXs-nOUnSUs=::aU:dO [SUSUR35eURU5 MM UHKn U S:aX-n OU n SU s=::aU:dO [SU SUR35eURU 5 MM URXV5$)zExtract a submatrix.rzInvalid row index z for Matrix of shape zInvalid column index )r!rappendr) r1r colslistrrnew_rowsnew_colsri_posrj_poss r%extract DFM.extractYs zzA1u>> #5aS8Mdjj\!Z[[ OOE "A1u>> #8;PQUQ[Q[P\!]^^ OOE "}}X00r/cxURup4[U5Un[U5UnURXV5$)z Slice a DFM.)r!rr)r1rowslicecolslicerrrrs r% extract_sliceDFM.extract_slicews:zz!HX& !HX& }}Y22r/c:URUR*5$zNegate a DFM matrix.r2r$rFs r%negDFM.negs}}dhhY''r/cRURURUR-5$)zAdd two DFM matrices.rrUs r%addDFM.add}}TXX 122r/cRURURUR- 5$)zSubtract two DFM matrices.rrUs r%subDFM.subrr/c>URURU-5$)z1Multiply a DFM matrix from the right by a scalar.rrUs r%mulDFM.muls}}TXX-..r/c<URXR-5$)z0Multiply a DFM matrix from the left by a scalar.rrUs r%rmulDFM.rmuls}}UXX-..r/cxUR5RUR55R5$)z/Elementwise multiplication of two DFM matrices.)rKmul_elementwisermrUs r%rDFM.mul_elementwises*{{},,U\\^<CCEEr/cURUR4nURURUR-X R5$)zMultiply two DFM matrices.)r+r,rr$r")r1rVr!s r%matmul DFM.matmuls6EJJ'yyEII-ukkBBr/c"UR5$r)rrFs r%__neg__ DFM.__neg__sxxzr/cNURU5nURU"U6X5$)zReturn a zero DFM matrix.)rr)rr!r"rxs r%zeros DFM.zeross)""6*xxe e44r/cJ[R"X5R5$)zReturn a one DFM matrix.)reonesrm)rr!r"s r%rDFM.onessxx&--//r/cJ[R"X5R5$)z%Return the identity matrix of size n.)reeyerm)rrr"s r%rDFM.eyeswwq!((**r/cJ[R"X5R5$)zReturn a diagonal matrix.)rediagrm)rrwr"s r%rDFM.diagsxx)0022r/c\UR5RX5R5$)z/Apply a function to each entry of a DFM matrix.)rK applyfuncrm)r1rxr"s r%r DFM.applyfuncs"{{}&&t4;;==r/cURURR5URUR4UR 5$)zTranspose a DFM matrix.)rr$ transposer,r+r"rFs r%r DFM.transposes3yy++- 499/Et{{SSr/cUR5R"UVs/sHo"R5PM sn6R5$s snf)zHorizontally stack matrices.)rKhstackrmr1othersos r%r DFM.hstack8{{}##&%A&Qhhj&%ABIIKK%AA cUR5R"UVs/sHo"R5PM sn6R5$s snf)zVertically stack matrices.)rKvstackrmrs r%r DFM.vstackrrcURnURup#[[X#55Vs/sHoAXD4PM sn$s snf)z$Return the diagonal of a DFM matrix.)r$r!rmin)r1rrrrs r%diagonal DFM.diagonals= HHzz!&s1y!12!1A!$!1222sAcURn[UR5H#n[U5HnXU4(dM g M% g)z2Return ``True`` if the matrix is upper triangular.FT)r$rr+r1rrrs r%is_upper DFM.is_uppers? HHtyy!A1XT77 "r/cURn[UR5H1n[US-UR5HnXU4(dM g M3 g)z2Return ``True`` if the matrix is lower triangular.r FTr$rr+r,rs r%is_lower DFM.is_lowersJ HHtyy!A1q5$)),T77 -"r/cPUR5=(a UR5$)z*Return ``True`` if the matrix is diagonal.)rr rFs r% is_diagonalDFM.is_diagonals}}24==?2r/cURn[UR5H-n[UR5HnXU4(dM g M/ g)z1Return ``True`` if the matrix is the zero matrix.FTr rs r%is_zero_matrixDFM.is_zero_matrixsD HHtyy!A499%T77 &"r/c>UR5R5$)z5Return the number of non-zero elements in the matrix.)rKnnzrFs r%rDFM.nnz{{}  ""r/c>UR5R5$)z7Return the strongly connected components of the matrix.)rKsccrFs r%rDFM.sccrr/rrc6URR5$)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$detrFs r%rDFM.detsbxx||~r/c^URR5R5SSS2$)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$charpolycoeffsrFs r%r  DFM.charpoly0s*Txx  "))+DbD11r/c<URnURup#X#:wa [S5eU[:Xa[ SU-5eU[ :Xa*UR URR55$[SU-5e![a [S5ef=f)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 rr2r$invZeroDivisionErrorr r<)r1Krrs r%r$DFM.inv\sn KKzz 6()LM M 7 81 <= = "W M}}TXX\\^44 &&Ka&OP P % M01KLL Ms (BBcUR5R5upnUR5UR5U4$)z*Return the LU decomposition of the matrix.)rKlurm)r1LUswapss r%r)DFM.lus3kkm&&( exxz188:u,,r/c URUR:Xd'[SUR<SUR<35eURR(d[SUR-5eURup#URupEX$:wa[ SU<SU<SU<SU<35eX54nX#:wa;UR 5R UR 55R5$URRUR5nURXvUR5$![a [S5ef=f)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!rrKlu_solvermr$solver%r r)r1rhsrrrk sol_shapesols r%r0 DFM.lu_solves \{{cjj($++szz Z[ [ {{## 84;; FG Gzzyy 6QPQSTVWXY YF 6;;=))#**,7>>@ @ Q((..)Cyy55! Q,-OP P Qs 5%D66E cfUR5R5upUR5U4$)/Return a basis for the nullspace of the matrix.)rK nullspacerm)r1rs nonpivotss r%r9 DFM.nullspaces+&002zz|Y&&r/NcdUR5RUS9up#UR5U4$)r8)pivots)rjnullspace_from_rrefrm)r1r=sdmr:s r%r>DFM.nullspace_from_rrefs0::&:Izz|Y&&r/cZUR5R5R5$)z+Return a particular solution to the system.)rK particularrmrFs r%rBDFM.particulars {{}'')0022r/cSnU"U5nU"U5nSUs=:aS:d O [S5eURupxURR5U:wa [ S5eURR XX4US9$)zACall the fmpz_mat.lll() method but check rank to avoid segfaults.c[R"U5(a+[UR5[UR5- $[U5$N)rof_typefloat numerator denominator)xs r%to_floatDFM._lll..to_float*s5zz!}}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) r1rNrOrPr$rQrLrrs r%_lllDFM._lll s{ smeaAB Bzz 88==?a MN Nxx||i#UY|ZZr/cUR[:wa[SUR-5eURUR:a [ S5eUR US9nURU5$)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.)rO)r"rr r+r,rrTr2)r1rOr$s r%rSDFM.lll>s`, ;;"  5 CD D YY "MN Niiei$}}S!!r/cTUR[:wa[SUR-5eURUR:a [ S5eUR SUS9up#URU5nURX0RUR4UR5nXE4$)aCompute 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. rWrXT)rNrO) r"rr r+r,rrTr2r)r1rOr$TbasisT_dfms r% lll_transformDFM.lll_transform\s2 ;;"  5 CD D YY "MN NT7 c" !ii3T[[A|r/rZrF)FgGz?gRQ?zbasisapprox)g?)P__name__ __module__ __qualname____firstlineno____doc__fmtis_DFMis_DDMr& classmethodrr2r)rArpropertyrGrLrQrWr[r_rbrKrjrmrprtryr}rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrrr r$r)r0r9r>rBrTrSr^__static_attributes__rZr/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/)re)riN)sympy.external.gmpyrsympy.external.importtoolsrsympy.utilities.decoratorrsympy.polys.domainsrr exceptionsr r r r rrr__doctest_skip__r__all__rsympy.polys.matrices.ddmrerirZr/r%rusvT-48&7u g ''+w w ,w v)(r/