U Zʹjly@sddlmZddlmZddlmZddlmZmZddl m Z m Z m Z m Z mZmZmZedkrfdgZedZd gZedgd Gd d d Zdd lmZdd lmZdS)) GROUND_TYPES) import_module)doctest_depends_onZZQQ)DMBadInputError DMDomainErrorDMNonSquareMatrixErrorDMNonInvertibleMatrixError DMRankError DMShapeError DMValueErrorflint*DFMZ ground_typesc@seZdZdZdZdZdZddZeddZ d d Z ed d Z ed dZ eddZ eddZddZddZddZeddZddZddZdd Zd!d"Zd#d$Zd%d&Zed'd(Zed)d*Zd+d,Zd-d.Zed/d0Zd1d2Zed3d4Z d5d6Z!ed7d8Z"d9d:Z#d;d<Z$d=d>Z%d?d@Z&dAdBZ'dCdDZ(dEdFZ)dGdHZ*dIdJZ+dKdLZ,dMdNZ-dOdPZ.dQdRZ/dSdTZ0dUdVZ1dWdXZ2edYdZZ3ed[d\Z4ed]d^Z5ed_d`Z6dadbZ7dcddZ8dedfZ9dgdhZ:didjZ;dkdlZdqdrZ?dsdtZ@dudvZAeBdwdxdydzZCeBdwdxd{d|ZDeBdwdxd}d~ZEddZFeBdwdxddZGddZHdddZIddZJdddZKeBdwdxdddZLeBdwdxdddZMdS)ra& 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]] ZdenseTFc Cs^||}d|krHz ||}WqPttfk rDtd|YqPXn||}||||S)Construct from a nested list.rz"Input should be a list of list of )_get_flint_func ValueError TypeErrorr _new)clsrowslistshapedomainZ flint_matreprX/var/www/html/bwave/python/venv/lib/python3.8/site-packages/sympy/polys/matrices/_dfm.py__new__ms  z DFM.__new__cCs:||||t|}||_||_\|_|_||_|S)z)Internal constructor from a flint matrix.)_checkobjectr rrrowscolsr)rrrrobjrrrr{s  zDFM._newcCs|||j|jS)z>Create a new DFM with the same shape and domain but a new rep.)rrr)selfrrrr_new_repsz DFM._new_repcCst||f}||kr td|tkr>t|tjs>tdn2|tkr\t|tj s\tdn|ttfkrpt ddS)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) ZnrowsZncolsr r isinstancerfmpz_mat RuntimeErrorrfmpq_matNotImplementedError)rrrrZrepshaperrrr!s   z DFM._checkcCs |ttfkS)z4Return True if the given domain is supported by DFM.rrrrrr_supports_domainszDFM._supports_domaincCs(|tkrtjS|tkrtjStddS)z3Return the flint matrix class for the given domain.r(N)rrr*rr,r-r.rrrrs zDFM._get_flint_funccCs ||jS)z5Callable to create a flint matrix of the same domain.)rrr&rrr_funcsz DFM._funccCs t|S)zReturn ``str(self)``.)strto_ddmr0rrr__str__sz DFM.__str__cCsdt|ddS)zReturn ``repr(self)``.rN)reprr3r0rrr__repr__sz DFM.__repr__cCs&t|tstS|j|jko$|j|jkS)zReturn ``self == other``.)r)rNotImplementedrrr&otherrrr__eq__s z DFM.__eq__cCs ||||S)rr)rrrrrrr from_listsz DFM.from_listcCs |jS)zConvert to a nested list.)rtolistr0rrrto_listsz DFM.to_listcCs|||jS)zReturn a copy of self.)r'r1rr0rrrcopyszDFM.copycCst||j|jS)zConvert to a DDM.)DDMr<r>rrr0rrrr3sz DFM.to_ddmcCst||j|jS)zConvert to a SDM.)SDMr<r>rrr0rrrto_sdmsz DFM.to_sdmcCs|S)z Return self.rr0rrrto_dfmsz DFM.to_dfmcCs|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 rr0rrr to_dfm_or_ddmszDFM.to_dfm_or_ddmcCs|||j|jS)zConvert from a DDM.)r<r>rr)rddmrrrfrom_ddmsz DFM.from_ddmcCsl||}z|||f}WnBtk r>td|Yn"tk r^td|YnX||||S)z Inverse of :meth:`to_list_flat`.z'Incorrect number of elements for shape zInput should be a list of )rrr r)relementsrrfuncrrrrfrom_list_flats zDFM.from_list_flatcCs |jS)zConvert to a flat list.)rentriesr0rrr to_list_flatszDFM.to_list_flatcCs |S)z$Convert to a flat list of non-zeros.)r3 to_flat_nzr0rrrrLszDFM.to_flat_nzcCst|||S)zInverse of :meth:`to_flat_nz`.)r@ from_flat_nzrC)rrGdatarrrrrMszDFM.from_flat_nzcCs |S)zConvert to a DOD.)r3to_dodr0rrrrOsz DFM.to_dodcCst|||S)zInverse of :meth:`to_dod`.)r@from_dodrC)rZdodrrrrrrPsz DFM.from_dodcCs |S)zConvert to a DOK.)r3to_dokr0rrrrQ sz DFM.to_dokcCst|||S)zInverse of :math:`to_dod`.)r@from_dokrC)rZdokrrrrrrRsz DFM.from_dokccsN|j\}}|j}t|D]0}t|D]"}|||f}|r$|||fVq$qdS)z0Iterater over the non-zero values of the matrix.Nrrranger&mnrijZrepijrrr iter_valuess    zDFM.iter_valuesccsN|j\}}|j}t|D]0}t|D]"}|||f}|r$||f|fVq$qdS)zBIterate over indices and values of nonzero elements of the matrix.NrSrUrrr iter_itemss    zDFM.iter_itemscCsl||jkr|S|tkr<|jtkr<|t|j|j|S|tkr`|jtkr`| | St ddS)zConvert to a new domain.r(N) rr?rrrrr,rrr3 convert_torCr-)r&rrrrr\'s zDFM.convert_toc Csp|j\}}|dkr||7}|dkr*||7}z|j||fWStk rjtd|d|d|jYnXdS)zGet the ``(i, j)``-th entry.rInvalid indices (, ) for Matrix of shape Nrrr IndexError)r&rXrYrVrWrrrgetitem5s z DFM.getitemc Csr|j\}}|dkr||7}|dkr*||7}z||j||f<Wn0tk rltd|d|d|jYnXdS)zSet the ``(i, j)``-th entry.rr]r^r_Nr`)r&rXrYvaluerVrWrrrsetitemCs z DFM.setitemcs:|jfdd|D}t|tf}||||jS)z%Extract a submatrix with no checking.cs g|]fddDqS)csg|]}|fqSrr).0rY)MrXrr Usz+DFM._extract...r)rerf j_indices)rXrrgUsz DFM._extract..)rlenr<r)r& i_indicesriZlolrrrhr_extractQsz DFM._extractc Cs|j\}}g}g}|D]P}|dkr,||}n|}d|krD|ks\ntd|d|j||q|D]P} | dkr| |} n| } d| kr|ksntd| d|j|| ql|||S)zExtract a submatrix.rzInvalid row index z for Matrix of shape zInvalid column index )rraappendrl) r&rZcolslistrVrWZnew_rowsZnew_colsrXZi_posrYZj_posrrrextractYs$     z DFM.extractcCs.|j\}}t||}t||}|||S)z Slice a DFM.)rrTrl)r&ZrowsliceZcolslicerVrWrkrirrr extract_slicews   zDFM.extract_slicecCs||j SzNegate a DFM matrix.r'rr0rrrnegszDFM.negcCs||j|jS)zAdd two DFM matrices.rqr9rrraddszDFM.addcCs||j|jS)zSubtract two DFM matrices.rqr9rrrsubszDFM.subcCs||j|S)z1Multiply a DFM matrix from the right by a scalar.rqr9rrrmulszDFM.mulcCs|||jS)z0Multiply a DFM matrix from the left by a scalar.rqr9rrrrmulszDFM.rmulcCs||S)z/Elementwise multiplication of two DFM matrices.)r3mul_elementwiserCr9rrrrwszDFM.mul_elementwisecCs$|j|jf}||j|j||jS)zMultiply two DFM matrices.)r#r$rrr)r&r:rrrrmatmuls z DFM.matmulcCs|Srp)rrr0rrr__neg__sz DFM.__neg__cCs||}|||||S)zReturn a zero DFM matrix.)rr)rrrrHrrrzeross z DFM.zeroscCst||S)zReturn a one DFM matrix.)r@onesrC)rrrrrrr{szDFM.onescCst||S)z%Return the identity matrix of size n.)r@eyerC)rrWrrrrr|szDFM.eyecCst||S)zReturn a diagonal matrix.)r@diagrC)rrGrrrrr}szDFM.diagcCs|||S)z/Apply a function to each entry of a DFM matrix.)r3 applyfuncrC)r&rHrrrrr~sz DFM.applyfunccCs||j|j|jf|jS)zTranspose a DFM matrix.)rr transposer$r#rr0rrrrsz DFM.transposecGs|jdd|DS)zHorizontally stack matrices.cSsg|] }|qSrr3reorrrrgszDFM.hstack..)r3hstackrCr&Zothersrrrrsz DFM.hstackcGs|jdd|DS)zVertically stack matrices.cSsg|] }|qSrrrrrrrgszDFM.vstack..)r3vstackrCrrrrrsz DFM.vstackcs,|j|j\}}fddtt||DS)z$Return the diagonal of a DFM matrix.csg|]}||fqSrr)rerXrfrrrgsz DFM.diagonal..)rrrTmin)r&rVrWrrrdiagonals z DFM.diagonalcCs<|j}t|jD]&}t|D]}|||frdSqqdS)z2Return ``True`` if the matrix is upper triangular.FT)rrTr#r&rfrXrYrrris_uppers    z DFM.is_uppercCsD|j}t|jD].}t|d|jD]}|||fr$dSq$qdS)z2Return ``True`` if the matrix is lower triangular.rFTrrTr#r$rrrris_lowers   z DFM.is_lowercCs|o|S)z*Return ``True`` if the matrix is diagonal.)rrr0rrr is_diagonalszDFM.is_diagonalcCs>|j}t|jD](}t|jD]}|||frdSqqdS)z1Return ``True`` if the matrix is the zero matrix.FTrrrrris_zero_matrixs   zDFM.is_zero_matrixcCs |S)z5Return the number of non-zero elements in the matrix.)r3nnzr0rrrrszDFM.nnzcCs |S)z7Return the strongly connected components of the matrix.)r3sccr0rrrrszDFM.sccrrcCs |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. )rdetr0rrrrs1zDFM.detcCs|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)rcharpolyZcoeffsr0rrrr0s*z DFM.charpolycCs|j}|j\}}||kr td|tkr6td|nF|tkrpz||jWSt k rlt dYq|Xn t d|dS)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 %sN) rrr rr rr'rinvZeroDivisionErrorr r-)r&KrVrWrrrr\s7 zDFM.invcCs$|\}}}|||fS)z*Return the LU decomposition of the matrix.)r3lurC)r&LUZswapsrrrrszDFM.lucCs|j|jks td|j|jf|jjs6td|j|j\}}|j\}}||krftd||||f||f}||kr||Sz|j |j}Wnt k rt dYnX| |||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: %s != %szField expected, got %sz(Matrix size mismatch: %s * %s vs %s * %sz Matrix det == 0; not invertible.) rr Zis_Fieldrrr3lu_solverCrZsolverr r)r&rhsrVrWrYkZ sol_shapeZsolrrrrs .   z DFM.lu_solvecCs|\}}||fS)/Return a basis for the nullspace of the matrix.)r3 nullspacerC)r&rE nonpivotsrrrrsz DFM.nullspaceNcCs |j|d\}}||fS)r)pivots)rBnullspace_from_rrefrC)r&rZsdmrrrrrszDFM.nullspace_from_rrefcCs|S)z+Return a particular solution to the system.)r3 particularrCr0rrrrszDFM.particularGz?RQ?zbasisapproxc Csldd}||}||}d|kr,dks6ntd|j\}}|j|krVtd|jj|||||dS)zACall the fmpz_mat.lll() method but check rank to avoid segfaults.cSs*t|rt|jt|jSt|SdS)N)rZof_typefloat numerator denominator)xrrrto_float*s zDFM._lll..to_floatg?rz delta must be between 0.25 and 1z-Matrix must have full row rank for Flint LLL.) transformdeltaetargram)rrrZrankr lll) r&rrrrrrrVrWrrr_lll s  zDFM._lll?cCsD|jtkrtd|jn|j|jkr.td|j|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)rrr r#r$rrr')r&rrrrrr>s    zDFM.lllcCsj|jtkrtd|jn|j|jkr.td|jd|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. rrT)rr) rrr r#r$rrr'r)r&rrTZbasisZT_dfmrrr lll_transform\s   zDFM.lll_transform)N)Frrrr)r)r)N__name__ __module__ __qualname____doc__fmtZis_DFMZis_DDMr classmethodrr'r!r/rpropertyr1r4r7r;r<r>r?r3rBrCrDrFrIrKrLrMrOrPrQrRrZr[r\rbrdrlrnrorrrsrtrurvrwrxryrzr{r|r}r~rrrrrrrrrrrrrrrrrrrrrrrrrrrEs"                       2 + H J   )r@)rAN)Zsympy.external.gmpyrZsympy.external.importtoolsrZsympy.utilities.decoratorrZsympy.polys.domainsrr exceptionsr r r r r rrZ__doctest_skip__r__all__rZsympy.polys.matrices.ddmr@rArrrr*s$   $  A