OtjˀddlmZddlmZddlmZddlmZmZddl m Z m Z m Z m Z mZmZmZedkrdgZedZd gZedg Gd d Zdd lmZdd lmZdS)) GROUND_TYPES) import_module)doctest_depends_on)ZZQQ)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>?dBZEdCZFdDZGeBd>?dEZHdFZIdGZJdSdIZKdJZLdTdOZMeBd>?dUdQZNeBd>?dUdRZOdHS)Vra& 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 W/var/www/html/CA-Chatbot/venv/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"rrowscolsr )rr"rr 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.)rrr )selfr"s r#_new_repz DFM._new_repsyydj$+666r+c||f}||krtd|tkr)t |t jstd|tkr)t |t j std|j r5t |t j t j fstd|ttfvr|j stddSdS)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)nrowsncolsr r isinstancerfmpz_mat RuntimeErrorrfmpq_matis_FF fmpz_mod_matnmod_matNotImplementedError)rr"rr repshapes r#r&z DFM._checksIIKK- u  !"LMM M R<< 3 ? ?<<== = r\\*S%."A"A\<== = \ M*S53Eu~2V"W"W MRSS S B8 # #FL #%&KLL L$ # # #r+c>|ttfvp |jo|jS)z4Return True if the given domain is supported by DFM.)rrr7 _is_flint)rr s r#_supports_domainzDFM._supports_domains""b!FV\%Ff6FFr+c^|tkr tjS|tkr tjS|jrg|t|jtj rtj fd}nt fd}|Std)z3Return the flint matrix class for the given domain.ct|dkr1t|dtjr|dSg|RS)Nrr)lenr3rr9)e_clscs r#_funcz"DFM._get_flint_func.._funcsN1vv{{z!A$'G'G{#tAaDzz)#t{Q{{{{*r+c*tjg|RSN)rr8)rBms r#z%DFM._get_flint_func..s5#5# ! r\\> ! \ M%%''A&*ej11 =~+++++++ &&q))<<<<L%&KLL Lr+c6||jS)z5Callable to create a flint matrix of the same domain.)rr r-s r#rEz DFM._funcs##DK000r+cDt|S)zReturn ``str(self)``.)strto_ddmrOs r#__str__z DFM.__str__s4;;==!!!r+cZdt|ddS)zReturn ``repr(self)``.rN)reprrRrOs r#__repr__z DFM.__repr__s).T$++--((,...r+czt|tstS|j|jko|j|jkS)zReturn ``self == other``.)r3rNotImplementedr r"r-others r#__eq__z DFM.__eq__s9%%% "! !{el*Dtx59/DDr+c||||S)r)rrrr s r# from_listz DFM.from_listss8UF+++r+c4|jS)zConvert to a nested list.)r"tolistrOs r#to_listz DFM.to_listsx   r+c\|||jS)zReturn a copy of self.)r.rEr"rOs r#copyzDFM.copys"}}TZZ11222r+cftj||j|jS)zConvert to a DDM.)DDMr_rbrr rOs r#rRz DFM.to_ddm"}T\\^^TZEEEr+cftj||j|jS)zConvert to a SDM.)SDMr_rbrr rOs r#to_sdmz DFM.to_sdmrgr+c|S)z Return self.r^rOs 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 r^rOs r# to_dfm_or_ddmzDFM.to_dfm_or_ddms  r+ch|||j|jS)zConvert from a DDM.)r_rbrr )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)relementsrr 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"entriesrOs r# to_list_flatzDFM.to_list_flatsx!!!r+cN|S)z$Convert to a flat list of non-zeros.)rR to_flat_nzrOs r#rzzDFM.to_flat_nzs{{}}'')))r+cRtj|||S)zInverse of :meth:`to_flat_nz`.)rf from_flat_nzrl)rrsdatar s r#r|zDFM.from_flat_nz s%$77>>@@@r+cN|S)zConvert to a DOD.)rRto_dodrOs r#rz DFM.to_dod{{}}##%%%r+cRtj|||S)zInverse of :meth:`to_dod`.)rffrom_dodrl)rdodrr s r#rz DFM.from_dod$|C//66888r+cN|S)zConvert to a DOK.)rRto_dokrOs r#rz DFM.to_dokrr+cRtj|||S)zInverse of :math:`to_dod`.)rffrom_dokrl)rdokrr s r#rz DFM.from_dokrr+c#K|j\}}|j}t|D],}t|D]}|||f}|r |||fV-dS)z/Iterate over the non-zero values of the matrix.Nrr"ranger-rHnr"ijrepijs r# iter_valueszDFM.iter_values"sxz1hq $ $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.Nrrs r# iter_itemszDFM.iter_items,s{z1hq * *A1XX * *AqD *q65/))) * * *r+c||jkr|S|tkrI|jtkr9|t |j|j|S| |r9| | Std)zConvert to a new domain.r0)r rdrrrrr6r"rr>rR convert_torlr:)r-r s r#rzDFM.convert_to6s T[ 99;;  r\\dkR//99U^^DH55tz6JJ J  " "6 * * M;;==++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 rr"r IndexError)r-rrrHrs r#getitemz DFM.getitemDsz1 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-rrvaluerHrs r#setitemz DFM.setitemRsz1 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 Sr^r^).0rMrs r# z+DFM._extract...ds!+++A!Q$+++r+r^)rrr j_indicess @r#rz DFM._extract..ds2???++++++++???r+)r"rAr_r )r- i_indicesrlolrrs ` @r#_extractz DFM._extract`sW 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 )rrappendr) r-rcolslistrHrnew_rowsnew_colsri_posrj_poss r#extractz DFM.extracths z1 # #A1uuA>>>>>>>> !Za!Z!Zdj!Z!Z[[[ OOE " " " " # #A1uuA>>>>>>>> !]!]!]QUQ[!]!]^^^ OOE " " " "}}Xx000r+c|j\}}t||}t||}|||S)z Slice a DFM.)rrr)r-rowslicecolslicerHrrrs r# extract_slicezDFM.extract_slicesCz1!HHX& !HHX& }}Y 222r+c8||j SzNegate a DFM matrix.r.r"rOs r#negzDFM.negs}}dhY'''r+cF||j|jzS)zAdd two DFM matrices.rrZs r#addzDFM.add}}TX 1222r+cF||j|jz S)zSubtract two DFM matrices.rrZs r#subzDFM.subrr+c<||j|zS)z1Multiply a DFM matrix from the right by a scalar.rrZs r#mulzDFM.muls}}TX-...r+c<|||jzS)z0Multiply a DFM matrix from the left by a scalar.rrZs r#rmulzDFM.rmuls}}UTX-...r+c||S)z/Elementwise multiplication of two DFM matrices.)rRmul_elementwiserlrZs r#rzDFM.mul_elementwises4{{}},,U\\^^<<CCEEEr+cp|j|jf}||j|jz||jS)zMultiply two DFM matrices.)r(r)rr"r )r-r[rs r#matmulz DFM.matmuls1EJ'yyEI-udkBBBr+c*|Sr)rrOs r#__neg__z DFM.__neg__sxxzzr+c`||}|||||S)zReturn a zero DFM matrix.)rr)rrr rts r#zerosz DFM.zeross3""6**xxe eV444r+cPtj||S)zReturn a one DFM matrix.)rfonesrl)rrr s r#rzDFM.oness"xv&&--///r+cPtj||S)z%Return the identity matrix of size n.)rfeyerl)rrr s r#rzDFM.eyes"wq&!!((***r+cPtj||S)zReturn a diagonal matrix.)rfdiagrl)rrsr s r#rzDFM.diags"x&))00222r+cv|||S)z/Apply a function to each entry of a DFM matrix.)rR applyfuncrl)r-rtr s r#rz DFM.applyfuncs,{{}}&&tV44;;===r+c||j|j|jf|jS)zTranspose a DFM matrix.)rr" transposer)r(r rOs r#rz DFM.transposes1yy++-- 49/Et{SSSr+cr|jd|DS)zHorizontally stack matrices.c6g|]}|Sr^rRros r#rzDFM.hstack.. %A%A%AQahhjj%A%A%Ar+)rRhstackrlr-otherss r#rz DFM.hstack5#t{{}}#%A%A&%A%A%ABIIKKKr+cr|jd|DS)zVertically stack matrices.c6g|]}|Sr^rrs r#rzDFM.vstack..rr+)rRvstackrlrs r#rz DFM.vstackrr+cx|j|j\}}fdtt||DS)z$Return the diagonal of a DFM matrix.c$g|] }||f Sr^r^)rrrs r#rz DFM.diagonal..s!222A!Q$222r+)r"rrmin)r-rHrrs @r#diagonalz DFM.diagonals? Hz12222s1ayy!1!12222r+c|j}t|jD]5}tt||jD]}|||frdS6dS)z2Return ``True`` if the matrix is upper triangular.FT)r"rr(rr)r-rrrs r#is_upperz DFM.is_upperso Hty!! ! !A3q$),,-- ! !QT7! 555! !tr+c|j}t|jD]+}t|dz|jD]}|||frdS,dS)z2Return ``True`` if the matrix is lower triangular.rFTr"rr(r)rs r#is_lowerz DFM.is_lowersk Hty!! ! !A1q5$),, ! !QT7! 555! !tr+cR|o|S)z*Return ``True`` if the matrix is diagonal.)rrrOs 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.)rRnnzrOs r#rzDFM.nnz{{}}  """r+cN|S)z7Return the strongly connected components of the matrix.)rRsccrOs 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"detrOs r#rzDFM.det sbx||~~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"charpolycoeffsrOs r#rz DFM.charpoly?s0Tx  ""))++DDbD11r+cd|j}|j\}}||krtd|tkrt d|z|t ks|jrJ ||j S#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 rr rr rr7r.r"invZeroDivisionErrorr r:)r-KrHrs r#rzDFM.invksn Kz1 66()LMM M 77 81 <== = "WWW M}}TX\\^^444$ M M M01KLLL M &&Ka&OPP Ps +BBc|\}}}|||fS)z*Return the LU decomposition of the matrix.)rRlurl)r-LUswapss r#rzDFM.lus>kkmm&&(( 1exxzz188::u,,r+c|\}}||fS)z*Return the QR decomposition of the matrix.)rRqrrl)r-QRs r#rzDFM.qrs:{{}}!!1xxzz188::%%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_FieldrrrRlu_solverlr"solverr r)r-rhsrHrrk sol_shapesols r#r z 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|jtkrt|jdd}||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) r rgetattrr"rrrrRrl) r-rPrDrrHrddm_pddm_lddm_dddm_us r#rzDFM.fflus ;"  48VT22D!X]]__ 1az1IIa!Q55IIa!Q55IIa!Q55IIaT[99  &*[[]]%7%7%9%9"ueU LLNN LLNN LLNN LLNN!Qzr+c|\}}||fS)/Return a basis for the nullspace of the matrix.)rR nullspacerl)r-rp nonpivotss r#rz DFM.nullspace5s4&0022Yzz||Y&&r+Nc||\}}||fS)r)pivots)rjnullspace_from_rrefrl)r-rsdmrs r#r zDFM.nullspace_from_rrefKs9::&:IIYzz||Y&&r+cr|S)z+Return a particular solution to the system.)rR particularrlrOs r#r#zDFM.particularQs({{}}''))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|SrG)rof_typefloat numerator denominator)xs r#to_floatzDFM._lll..to_float_s<z!}} Q[))E!-,@,@@@Qxxr+g?rz delta must be between 0.25 and 1z-Matrix must have full row rank for Flint LLL.) transformdeltaetar"gram)rrr"rankr lll) r-r0r1r2r"r3r/rHrs r#_lllzDFM._lllUs   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.)r1)r rr r(r)rr6r.)r-r1r"s r#r5zDFM.lllssj, ;"   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. r9r:T)r0r1) r rr r(r)rr6r.r)r-r1r"TbasisT_dfms r# lll_transformzDFM.lll_transforms2 ;"   5 CDD D Y " "MNN NT77Q c"" !di3T[AAe|r+rG)Fr$r%r&r')r7)P__name__ __module__ __qualname____doc__fmtis_DFMis_DDMr$ classmethodrr.r&r>rpropertyrErSrWr\r_rbrdrRrjrlrnrqrurxrzr|rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrr r#r6r5r?r^r+r#rrEs  D C F F , , ,[777 M M[ MGG[GMM[M,11X1"""///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.-H6TB''','''' 333[[[[<W---""".-":W---   .-   r+)rf)riN)sympy.external.gmpyrsympy.external.importtoolsrsympy.utilities.decoratorrsympy.polys.domainsrr exceptionsr r r r r rr__doctest_skip__r__all__rsympy.polys.matrices.ddmrfrir^r+r#rQsYT-,,,,,444444888888&&&&&&&&7u  g ''+++l l l l l l l ,+l `)(((((((((((((r+