+ iˀ^RIHt^RIHt^RIHt^RIHtHt^RI H t H t H t H t HtHtHt]R8wdR.t]!R4tR.t]!R.R 7!R R44t^R IHt^R IHtR #)) GROUND_TYPES) import_module)doctest_depends_on)ZZQQ)DMBadInputError DMDomainErrorDMNonSquareMatrixErrorDMNonInvertibleMatrixError DMRankError DMShapeError DMValueErrorflint*DFM ground_typesc a]tRt^EtoRtRtRtRtRt] R4t Rt ] R4t ] R 4t ] R 4t]R 4tR tR tRt] R4tRtRtRtRtRtRt] R4t] R4tRtRt] R4tRt ] R4t!Rt"] R4t#Rt$R t%R!t&R"t'R#t(R$t)R%t*R&t+R't,R(t-R)t.R*t/R+t0R,t1R-t2R.t3] R/4t4] R04t5] R14t6] R24t7R3t8R4t9R5t:R6t;R7tR:t?R;t@R<tAR=tB]C!R>R?7R@4tD]C!R>R?7RA4tE]C!R>R?7RB4tFRCtGRDtH]C!R>R?7RE4tIRFtJRGtKRORIltLRJtMRPRKltN]C!R>R?7RQRLl4tO]C!R>R?7RQRMl4tPRNtQVtRRH#)Rra 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 VPV4p^V9d V!V4pMV!V!pVP WRV4# \\3d\RT 24hi;i)Construct from a nested list.z"Input should be a list of list of )_get_flint_func ValueError TypeErrorr_new)clsrowslistshapedomain flint_matreps&&&& W/var/www/html/photoedit/myenv/lib/python3.14/site-packages/sympy/polys/matrices/_dfm.py__new__ DFM.__new__msq''/ E> U)U#CxxF++  * U%(J6(&STT Us ; Ac VPWV4\PV4pWnV;VnwVnVnW4nV#)z)Internal constructor from a flint matrix.)_checkobjectr#r!rrowscolsr)rr!rrobjs&&&& r"rDFM._new{sD 3v&nnS!).. &CHch  c NVPWPVP4#)z>Create a new DFM with the same shape and domain but a new rep.)rrr)selfr!s&&r"_new_rep DFM._new_repsyyjj$++66r,c:VP4VP43pWB8wd \R4hV\8Xd,\ V\ P 4'g \R4hV\8Xd,\ V\ P4'g \R4hVP'd<\ V\ P\ P34'g \R4hV\\39d VP'g \R4hR#R#)z(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 DFMN)nrowsncolsrr isinstancerfmpz_mat RuntimeErrorrfmpq_matis_FF fmpz_mod_matnmod_matNotImplementedError)rr!rrrepshapes&&&& r"r& DFM._checksIIK-  !"LM M R< 3 ? ?<= = r\*S%.."A"A<= = \\\*S53E3Eu~~2V"W"WRS S B8 #FLLL%&KL L-9 #r,c pV\\39;'g!VP;'d VP#)z4Return True if the given domain is supported by DFM.)rrr9 _is_flint)rrs&&r"_supports_domainDFM._supports_domains-"b!FFV\\%F%Ff6F6FFr,c aaaV\8Xd\P#V\8Xd\P#VP 'dqVP 4o\VP\P4'd\PoVV3RlpV#\PS4oV3RlpV#\R4h)z3Return the flint matrix class for the given domain.c<\V4^8Xd7\V^,\P4'dS!V^,4#S!.VOSN5!#))lenr5rr;)e_clscs*r"_func"DFM._get_flint_func.._funcs@1v{z!A$'G'G#AaDz)#{Q{{*r,c6<\P!.VOSN5!#N)rr:)rGms*r"%DFM._get_flint_func..s5#5#5#> ! r\>> ! \\\%%'A&**ejj11~~+L&&q)<L%&KL Lr,c 8VPVP4#)z5Callable to create a flint matrix of the same domain.)rrr.s&r"rJ DFM._funcs##DKK00r,c 4\VP44#)zReturn ``str(self)``.)strto_ddmrWs&r"__str__ DFM.__str__s4;;=!!r,c HR\VP44R, 2#)zReturn ``repr(self)``.r:NN)reprr[rWs&r"__repr__ DFM.__repr__s T$++-(,-..r,c \V\4'g\#VPVP8H;'dVPVP8H#)zReturn ``self == other``.)r5rNotImplementedrr!r.others&&r"__eq__ DFM.__eq__s?%%%! !{{ell*DDtxx599/DDr,c V!WV4#)r)rrrrs&&&&r" from_list DFM.from_lists8F++r,c 6VPP4#)zConvert to a nested list.)r!tolistrWs&r"to_list DFM.to_listsxx  r,c VVPVPVP44#)zReturn a copy of self.)r/rJr!rWs&r"copyDFM.copys}}TZZ122r,c v\P!VP4VPVP4#)zConvert to a DDM.)DDMrkrorrrWs&r"r[ DFM.to_ddm#}}T\\^TZZEEr,c v\P!VP4VPVP4#)zConvert to a SDM.)SDMrkrorrrWs&r"to_sdm DFM.to_sdmrwr,c V#)z Return self.rjrWs&r"to_dfm DFM.to_dfms r,c V#)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 rjrWs&r" to_dfm_or_ddmDFM.to_dfm_or_ddms  r,c lVPVP4VPVP4#)zConvert from a DDM.)rkrorr)rddms&&r"from_ddm DFM.from_ddms%}}S[[]CIIszzBBr,c VPV4pV!.VOVN5!pT!YRT4# \d\RT 24h\d\RT 24hi;i)z Inverse of :meth:`to_list_flat`.z'Incorrect number of elements for shape zInput should be a list of )rrrr)relementsrrfuncr!s&&&& r"from_list_flatDFM.from_list_flats}""6* I((x(C 3v&&  U!$KE7"ST T I!$>vh"GH H Is '!A Ac 6VPP4#)zConvert to a flat list.)r!entriesrWs&r" to_list_flatDFM.to_list_flatsxx!!r,c >VP4P4#)z$Convert to a flat list of non-zeros.)r[ to_flat_nzrWs&r"rDFM.to_flat_nzs{{}''))r,c L\P!WV4P4#)zInverse of :meth:`to_flat_nz`.)ru from_flat_nzr})rrdatars&&&&r"rDFM.from_flat_nz s 7>>@@r,c >VP4P4#)zConvert to a DOD.)r[to_dodrWs&r"r DFM.to_dod{{}##%%r,c L\P!WV4P4#)zInverse of :meth:`to_dod`.)rufrom_dodr})rdodrrs&&&&r"r DFM.from_dod||C/6688r,c >VP4P4#)zConvert to a DOK.)r[to_dokrWs&r"r DFM.to_dokrr,c L\P!WV4P4#)zInverse of :math:`to_dod`.)rufrom_dokr})rdokrrs&&&&r"r DFM.from_dokrr,c# "VPwrVPp\V4F5p\V4F#pW4V3,pV'gKW4V3,xK% K7 R#5i)z/Iterate over the non-zero values of the matrix.Nrr!ranger.rNnr!ijrepijs& r" iter_valuesDFM.iter_values"sPzzhhqA1XqD 5d)Os AA# A#c# "VPwrVPp\V4F0p\V4FpW4V3,pV'gKWE3V3xK K2 R#5i)zBIterate over indices and values of nonzero elements of the matrix.Nrrs& r" iter_itemsDFM.iter_items,sQzzhhqA1XqD 565/)s AA Ac WP8XdVP4#V\8XdPVP\8Xd;VP \ P VP4VPV4#VPV4'd.VP4PV4P4#\R4h)zConvert to a new domain.r2)rrrrrrrr8r!rrAr[ convert_tor}r<)r.rs&&r"rDFM.convert_to6s [[ 99;  r\dkkR/99U^^DHH5tzz6J J  " "6 * *;;=++F3::< <&&KL Lr,c  VPwr4V^8d W, pV^8d W$, pVPW3,# \d \RT RT RTP 24hi;i)zGet the ``(i, j)``-th entry.Invalid indices (, ) for Matrix of shape rr!r IndexError)r.rrrNrs&&& r"getitem DFM.getitemDsvzz q5 FA q5 FA ]88AD> ! ]02aS8Ntzzl[\ \ ]s A*A,c  VPwrEV^8d W, pV^8d W%, pW0PW3&R# \d \RT RT RTP 24hi;i)zSet the ``(i, j)``-th entry.rrrNr)r.rrvaluerNrs&&&& r"setitem DFM.setitemRsszz q5 FA q5 FA ]"HHQTN ]02aS8Ntzzl[\ \ ]s ?*A)c  VPpVUUu.uFqBUu.uF qSWE3,NK upNK ppp\V4\V43pVPWgVP4#uupiuuppi)z%Extract a submatrix with no checking.)r!rFrkr)r. i_indices j_indicesMrrlolrs&&& r"_extract DFM._extract`se HH5>?Y+A!$+Y?YY0~~c$++66,?sA-A( A-(A-c VPwr4.p.pVFRpV^8d Ws,pMTp^Tu;8:dV8gM\RV RVP 24hVPV4KT VFRp V ^8d W,p MT p ^T u;8:dV8gM\RV RVP 24hVPV 4KT VPWV4#)zExtract a submatrix.zInvalid row index z for Matrix of shape zInvalid column index )rrappendr) r.rcolslistrNrnew_rowsnew_colsri_posrj_poss &&& r"extract DFM.extracths zzA1u>> #5aS8Mdjj\!Z[[ OOE "A1u>> #8;PQUQ[Q[P\!]^^ OOE "}}X00r,c VPwr4\V4V,p\V4V,pVPWV4#)z Slice a DFM.)rrr)r.rowslicecolslicerNrrrs&&& r" extract_sliceDFM.extract_slices:zz!HX& !HX& }}Y22r,c :VPVP)4#zNegate a DFM matrix.r/r!rWs&r"negDFM.negs}}dhhY''r,c ZVPVPVP,4#)zAdd two DFM matrices.rres&&r"addDFM.add}}TXX 122r,c ZVPVPVP, 4#)zSubtract two DFM matrices.rres&&r"subDFM.subrr,c FVPVPV,4#)z1Multiply a DFM matrix from the right by a scalar.rres&&r"mulDFM.muls}}TXX-..r,c DVPWP,4#)z0Multiply a DFM matrix from the left by a scalar.rres&&r"rmulDFM.rmuls}}UXX-..r,c xVP4PVP44P4#)z/Elementwise multiplication of two DFM matrices.)r[mul_elementwiser}res&&r"rDFM.mul_elementwises*{{},,U\\^<CCEEr,c VPVP3pVPVPVP,W P4#)zMultiply two DFM matrices.)r(r)rr!r)r.rfrs&& r"matmul DFM.matmuls6EJJ'yyEII-ukkBBr,c "VP4#r)rrWs&r"__neg__ DFM.__neg__sxxzr,c PVPV4pVPV!V!W4#)zReturn a zero DFM matrix.)rr)rrrrs&&& r"zeros DFM.zeross)""6*xxe e44r,c J\P!W4P4#)zReturn a one DFM matrix.)ruonesr})rrrs&&&r"rDFM.onessxx&--//r,c J\P!W4P4#)z%Return the identity matrix of size n.)rueyer})rrrs&&&r"rDFM.eyeswwq!((**r,c J\P!W4P4#)zReturn a diagonal matrix.)rudiagr})rrrs&&&r"rDFM.diagsxx)0022r,c \VP4PW4P4#)z/Apply a function to each entry of a DFM matrix.)r[ applyfuncr})r.rrs&&&r"r DFM.applyfuncs"{{}&&t4;;==r,c VPVPP4VPVP3VP 4#)zTranspose a DFM matrix.)rr! transposer)r(rrWs&r"r DFM.transposes3yy++- 499/Et{{SSr,c VP4P!VUu.uFq"P4NK up!P4#uupi)zHorizontally stack matrices.)r[hstackr}r.othersos&* r"r DFM.hstack8{{}##&%A&Qhhj&%ABIIKK%AA c VP4P!VUu.uFq"P4NK up!P4#uupi)zVertically stack matrices.)r[vstackr}rs&* r"r  DFM.vstackr r c VPpVPwr#\\W#44Uu.uF qAWD3,NK up#uupi)z$Return the diagonal of a DFM matrix.)r!rrmin)r.rrNrrs& r"diagonal DFM.diagonals? HHzz!&s1y!12!1A!$!1222sAc VPp\VP4F<p\\W P44FpWV3,'gKR# K> R#)z2Return ``True`` if the matrix is upper triangular.FT)r!rr(rr)r.rrrs& r"is_upper DFM.is_uppersI HHtyy!A3q)),-T77 ."r,c VPp\VP4F;p\V^,VP4FpWV3,'gKR# K= R#)z2Return ``True`` if the matrix is lower triangular.FTr!rr(r)rs& r"is_lower DFM.is_lowersJ HHtyy!A1q5$)),T77 -"r,c RVP4;'dVP4#)z*Return ``True`` if the matrix is diagonal.)rrrWs&r" is_diagonalDFM.is_diagonals}}224==?2r,c VPp\VP4F3p\VP4FpWV3,'gKR# K5 R#)z1Return ``True`` if the matrix is the zero matrix.FTrrs& r"is_zero_matrixDFM.is_zero_matrixsD HHtyy!A499%T77 &"r,c >VP4P4#)z5Return the number of non-zero elements in the matrix.)r[nnzrWs&r"r"DFM.nnz{{}  ""r,c >VP4P4#)z7Return the strongly connected components of the matrix.)r[sccrWs&r"r&DFM.sccr$r,rrc 6VPP4#)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!detrWs&r"r)DFM.det sbxx||~r,c fVPP4P4RRR1,#)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!charpolycoeffsrWs&r"r- DFM.charpoly?s*Txx  "))+DbD11r,c xVPpVPwr#W#8wd \R4hV\8Xd\ RV,4hV\ 8XgVP 'd+VPVPP44#\RV,4h \d \R4hi;i)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 rr9r/r!invZeroDivisionErrorr r<)r.KrNrs& r"r1DFM.invksn KKzz 6()LM M 7 81 <= = "W M}}TXX\\^44 &&Ka&OP P % M01KLL Ms '(B""B9c VP4P4wrpVP4VP4V3#)z*Return the LU decomposition of the matrix.)r[lur})r.LUswapss& r"r6DFM.lus3kkm&&( exxz188:u,,r,c VP4P4wrVP4VP43#)z*Return the QR decomposition of the matrix.)r[qrr})r.QRs& r"r<DFM.qrs/{{}!xxz188:%%r,c  VPVP8Xg(\RVP: RVP: 24hVPP'g\RVP,4hVPwr#VPwrEW$8wd\ RV: RV: RV: RV: 24hW53pW#8wd<VP 4P VP 44P4#VPPVP4pTPYvTP4# \d \R4hi;i)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.) rr is_Fieldrr r[lu_solver}r!solver2r r)r.rhsrNrrk sol_shapesols&& r"rB DFM.lu_solves \{{cjj($++szz Z[ [ {{### 84;; FG Gzzyy 6QPQSTVWXY YF 6;;=))#**,7>>@ @ Q((..)Cyy55! Q,-OP P Qs =%D>>Ec ~VP\8Xd\VPRR4pVeVPP 4wr#rEVP wrgVP W&V3VP4VP W6V3VP4VP WFV3VP4VP WPP VP43#VP4P 4wrrVP4pV P4pV P4pV P4pW#WE3#)z 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) rrgetattrr!rJrrr[r}) r.rJPr7Dr8rNrddm_pddm_lddm_dddm_us & r"rJDFM.fflus ;;" 488VT2D!XX]]_ azzIIaQ5IIaQ5IIaQ5IIaT[[9  &*[[]%7%7%9"e LLN LLN LLN LLNQzr,c fVP4P4wrVP4V3#)/Return a basis for the nullspace of the matrix.)r[ nullspacer})r.r nonpivotss& r"rU DFM.nullspace5s+&002zz|Y&&r,Nc jVP4PVR7wr#VP4V3#)rT)pivots)rznullspace_from_rrefr})r.rYsdmrVs&& r"rZDFM.nullspace_from_rrefKs0::&:Izz|Y&&r,c ZVP4P4P4#)z+Return a particular solution to the system.)r[ particularr}rWs&r"r^DFM.particularQs {{}'')0022r,c RpV!V4pV!V4pRTu;8d^8gM\R4hVPwrxVPP4V8wd \ R4hVPP WW4VR7#)zACall the fmpz_mat.lll() method but check rank to avoid segfaults.c\P!V4'd0\VP4\VP4, #\V4#rM)rof_typefloat numerator denominator)xs&r"to_floatDFM._lll..to_float_s5zz!}}Q[[)E!--,@@@Qxr,g?z delta must be between 0.25 and 1z-Matrix must have full row rank for Flint LLL.) transformdeltaetar!gram)rrr!rankr lll) r.rirjrkr!rlrgrNrs &&&&&& r"_lllDFM._lllUs{ smeaAB Bzz 88==?a MN Nxx||i#UY|ZZr,c VP\8wd\RVP,4hVPVP8d \ R4hVP VR7pVPV4#)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.)rj)rrr r(r)r ror/)r.rjr!s&& r"rnDFM.lllss`, ;;"  5 CD D YY "MN Niiei$}}S!!r,c fVP\8wd\RVP,4hVPVP8d \ R4hVP RVR7wr#VPV4pVPW0PVP3VP4pWE3#)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. rrrsT)rirj) rrr r(r)r ror/r)r.rjr!TbasisT_dfms&& r" lll_transformDFM.lll_transforms2 ;;"  5 CD D YY "MN NT7 c" !ii3T[[A|r,rjrM)FgGz?gRQ?zbasisapprox)g?)S__name__ __module__ __qualname____firstlineno____doc__fmtis_DFMis_DDMr# classmethodrr/r&rArpropertyrJr\rargrkrorrr[rzr}rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrr"r&rr)r-r1r6r<rBrJrUrZr^rornry__static_attributes____classdictcell__) __classdict__s@r"rrEs D C F F ,7 M MGGMM,11"/E,,!3FF CC ' '"*AA&99&99$* M ] ]71<3(33//F C5500 ++ 33>TLL3 3##W-0.0dW-)2.)2VW-FQ.FQP- & W-H6.H6TB',' 3[<W-".":W- . r,)ru)ryN)sympy.external.gmpyrsympy.external.importtoolsrsympy.utilities.decoratorrsympy.polys.domainsrr exceptionsrr r r r r r__doctest_skip__r__all__rsympy.polys.matrices.ddmruryrjr,r"rsvT-48&7u g ''+l l ,l `)(r,