B }[>@sVddlmZmZddlmZddlmZddlmZddl m Z ddl m Z ddl mZddlmZmZmZmZdd lmZmZmZdd lmZdd lmZdd lmZmZmZdd l m!Z!m"Z"ddl#m$Z$m%Z%m&Z&ddl'm(Z(ddl)m*Z+m,Z,ddl-m.Z.m/Z/m0Z0m1Z1ddl2m3Z3m4Z4ddl-m5Z5m6Z6m7Z7m8Z8ddl9m:Z:ddl;mZ>m?Z?m@Z@mAZAmBZBddlCmDZDddZEddZFGdddee8ZGGdd d eBZHGd!d"d"eHZIGd#d$d$eIZJGd%d&d&eJZKGd'd(d(eBZLGd)d*d*eBZMGd+d,d,eMeLeKeBZNeDd-d.d/d0d1d2ZOeDd-d/d3d4deEe+fd8d9ZPeEd5fd:d;ZQd5S)=)print_functiondivision) prec_to_dps)Add)Basic)Expr) expand_mul)Pow)SymbolDummysymbols_uniquely_named_symbol)Integer mod_inverseFloat)S)sympify)sqrtMaxMin)exp factorial)PurePolyrootscancel)sstr)simplify nsimplify)reduceas_int string_typesCallable)flattennumbered_symbols) is_sequencedefault_sort_keyrange NotIterable)SymPyDeprecationWarning) FunctionType)a2idx MatrixError ShapeErrorNonSquareMatrixError MatrixCommon) deprecatedcCs y|jStk rdSXdS)zReturns True if x is zero.N)is_zeroAttributeError)xr46lib/python3.7/site-packages/sympy/matrices/matrices.py_iszero$sr6cCs t|dkS)zNTests by expand_mul only, suitable for polynomials and rational functions.r)r)r3r4r4r5_is_zero_after_expand_mul,sr7c@s(eZdZdZddZddZddZdS) DeferredVectora4A vector whose components are deferred (e.g. for use with lambdify) Examples ======== >>> from sympy import DeferredVector, lambdify >>> X = DeferredVector( 'X' ) >>> X X >>> expr = (X[0] + 2, X[2] + 3) >>> func = lambdify( X, expr) >>> func( [1, 2, 3] ) (3, 6) cCs2|dkr d}|dkrtdd|j|f}t|S)Nrz!DeferredVector index out of rangez%s[%d]) IndexErrornamer )selfiZcomponent_namer4r4r5 __getitem__Bs zDeferredVector.__getitem__cCst|S)N)r)r;r4r4r5__str__JszDeferredVector.__str__cCs d|jS)NzDeferredVector('%s'))r:)r;r4r4r5__repr__MszDeferredVector.__repr__N)__name__ __module__ __qualname____doc__r=r>r?r4r4r4r5r82sr8c@seZdZdZddZddZddZdd Zed fd d Z d dZ d ddZ de fddZ d!ddZd"ddZd#ddZd$ddZddZd S)%MatrixDeterminantzVProvides basic matrix determinant operations. Should not be instantiated directly.cs|jdkr&|jdkr&|ddtjgS|d|dddf}|dddf|ddddf}}|gx(t|jdD]}||q|WfddDtj| gfdd }||jd|j|}||fS) zReturn (A,T) where T the Toeplitz matrix used in the Berkowitz algorithm corresponding to `self` and A is the first principal submatrix.rr*)rrNcsg|]} |dqS))rrr4).0d)Rr4r5 vszEMatrixDeterminant._eval_berkowitz_toeplitz_matrix..cs||krtjS||S)N)rZero)r<j)diagsr4r5entryysz@MatrixDeterminant._eval_berkowitz_toeplitz_matrix..entry)rowscols_newrOner&append)r;aCAr<rMtoeplitzr4)rHrLr5_eval_berkowitz_toeplitz_matrixUs& z1MatrixDeterminant._eval_berkowitz_toeplitz_matrixcCsl|jdkr&|jdkr&|ddtjgS|jdkrT|jdkrT|ddtj|d gS|\}}||S)a Run the Berkowitz algorithm and return a vector whose entries are the coefficients of the characteristic polynomial of `self`. Given N x N matrix, efficiently compute coefficients of characteristic polynomials of 'self' without division in the ground domain. This method is particularly useful for computing determinant, principal minors and characteristic polynomial when 'self' has complicated coefficients e.g. polynomials. Semi-direct usage of this algorithm is also important in computing efficiently sub-resultant PRS. Assuming that M is a square matrix of dimension N x N and I is N x N identity matrix, then the Berkowitz vector is an N x 1 vector whose entries are coefficients of the polynomial charpoly(M) = det(t*I - M) As a consequence, all polynomials generated by Berkowitz algorithm are monic. For more information on the implemented algorithm refer to: [1] S.J. Berkowitz, On computing the determinant in small parallel time using a small number of processors, ACM, Information Processing Letters 18, 1984, pp. 147-150 [2] M. Keber, Division-Free computation of sub-resultants using Bezout matrices, Tech. Report MPI-I-2006-1-006, Saarbrucken, 2006 rr*rE)rr)rNrOrPrrQrW_eval_berkowitz_vector)r;ZsubmatrVr4r4r5rXs $ z(MatrixDeterminant._eval_berkowitz_vectorcsdfdd tS)aCompute matrix determinant using Bareiss' fraction-free algorithm which is an extension of the well known Gaussian elimination method. This approach is best suited for dense symbolic matrices and will result in a determinant with minimal number of fractions. It means that less term rewriting is needed on resulting formulae. TODO: Implement algorithm for sparse matrices (SFF), http://www.eecis.udel.edu/~saunders/papers/sffge/it5.ps. r*csjdkrtjSjdkr"dStdddftd\}}dkrPtjSdd}tfddtjD}ttj} ||fd d }| jdjd|S) Nrr*)rr) iszerofuncrEc3s|]}|kr|VqdS)Nr4)rFr<) pivot_posr4r5 szGMatrixDeterminant._eval_det_bareiss..bareiss..csF||df|df|df}|jsBt||S)Nr*r)Zis_Atomr)r<rKret)cummmatr[ pivot_valtmp_matr4r5rMs4zCMatrixDeterminant._eval_det_bareiss..bareiss..entry) rNrrQ_find_reasonable_pivotr7rJlistr&rOextractrP)r_r^_signrNrOrM)bareissr;)r^r_r[r`rar5rgs    z4MatrixDeterminant._eval_det_bareiss..bareiss)r*)r)r;r4)rgr;r5_eval_det_bareisss z#MatrixDeterminant._eval_det_bareisscCs |}dt|d|dS)z8 Use the Berkowitz algorithm to compute the determinant.rZr*)rXlen)r; berk_vectorr4r4r5_eval_det_berkowitzsz%MatrixDeterminant._eval_det_berkowitzNcCs|jdkrtjS|j|dd\}}|||jd|jdfrDtjSt|drXtj ntj}x"t|jD]}||||f9}qjW|S)a Computes the determinant of a matrix from its LU decomposition. This function uses the LU decomposition computed by LUDecomposition_Simple(). The keyword arguments iszerofunc and simpfunc are passed to LUDecomposition_Simple(). iszerofunc is a callable that returns a boolean indicating if its input is zero, or None if it cannot make the determination. simpfunc is a callable that simplifies its input. The default is simpfunc=None, which indicate that the pivot search algorithm should not attempt to simplify any candidate pivots. If simpfunc fails to simplify its input, then it must return its input instead of a copy.rN)rYsimpfuncr*rE)rNrrQLUdecomposition_SimplerJrir&)r;rYrllu row_swapsdetkr4r4r5 _eval_det_lus  zMatrixDeterminant._eval_det_lucCs|S)zuAssumed to exist by matrix expressions; If we subclass MatrixDeterminant, we can fully evaluate determinants.)rp)r;r4r4r5_eval_determinantsz#MatrixDeterminant._eval_determinant berkowitzcCs||S)zReturns the adjugate, or classical adjoint, of a matrix. That is, the transpose of the matrix of cofactors. http://en.wikipedia.org/wiki/Adjugate See Also ======== cofactor_matrix transpose )cofactor_matrix transpose)r;methodr4r4r5adjugates zMatrixDeterminant.adjugatelambdacs<|j|jkrt|}t||}tfdd|D|S)aComputes characteristic polynomial det(x*I - self) where I is the identity matrix. A PurePoly is returned, so using different variables for ``x`` does not affect the comparison or the polynomials: Examples ======== >>> from sympy import Matrix >>> from sympy.abc import x, y >>> A = Matrix([[1, 3], [2, 0]]) >>> A.charpoly(x) == A.charpoly(y) True Specifying ``x`` is optional; a symbol named ``lambda`` is used by default (which looks good when pretty-printed in unicode): >>> A.charpoly().as_expr() lambda**2 - lambda - 6 And if ``x`` clashes with an existing symbol, underscores will be preppended to the name to make it unique: >>> A = Matrix([[1, 2], [x, 0]]) >>> A.charpoly(x).as_expr() _x**2 - _x - 2*x Whether you pass a symbol or not, the generator can be obtained with the gen attribute since it may not be the same as the symbol that was passed: >>> A.charpoly(x).gen _x >>> A.charpoly(x).gen == x False Notes ===== The Samuelson-Berkowitz algorithm is used to compute the characteristic polynomial efficiently and without any division operations. Thus the characteristic polynomial over any commutative ring without zero divisors can be computed. See Also ======== det csg|] }|qSr4r4)rFrS)rr4r5rI^sz.MatrixDeterminant.charpoly..)rNrOr.rXr r)r;r3rrjr4)rr5charpoly%s 4  zMatrixDeterminant.charpolycCs:|j|jks|jdkrtd||d||||S)zCalculate the cofactor of an element. See Also ======== cofactor_matrix minor minor_submatrix r*rZrE)rNrOr.minor)r;r<rKrwr4r4r5cofactor`s zMatrixDeterminant.cofactorcs8jjksjdkrtjjfddS)zReturn a matrix containing the cofactor of each element. See Also ======== cofactor minor minor_submatrix adjugate r*cs||S)N)r|)r<rK)rwr;r4r5sz3MatrixDeterminant.cofactor_matrix..)rNrOr.rP)r;rwr4)rwr;r5rups  z!MatrixDeterminant.cofactor_matrixrgcCsf|}|dkrd}|dkr d}|dkr4td||j|jkrFt|j}|dkrZtjS|dkrj|d S|d kr|d |d |d |d S|dkr,|d |d |d|d |d|d|d|d |d|d|d |d|d |d|d|d |d |dS|dkr>|S|dkrP|S|dkrb| SdS)a Computes the determinant of a matrix. If the matrix is at most 3x3, a hard-coded formula is used. Otherwise, the determinant using the method `method`. Possible values for "method": bareis berkowitz lu ZbareisrgZdet_lurn)rgrtrnz$Determinant method '%s' unrecognizedrr*)rrrE)r*r*)rr*)r*r)rErE)r*rE)rEr)rrE)rEr*rtN) lower ValueErrorrNrOr.rrQrhrkrr)r;rwnr4r4r5rps0        zMatrixDeterminant.detcCs0|j|jks|jdkrt|||j|dS)aReturn the (i,j) minor of `self`. That is, return the determinant of the matrix obtained by deleting the `i`th row and `j`th column from `self`. See Also ======== minor_submatrix cofactor det r*)rw)rNrOr.minor_submatrixrp)r;r<rKrwr4r4r5r{s zMatrixDeterminant.minorcsdkr|j7dkr$|j7dkr:|jkrVnndkrT|jksnntd|jd|jfddt|jD}fddt|jD}|||S)zReturn the submatrix obtained by removing the `i`th row and `j`th column from `self`. See Also ======== minor cofactor rz2`i` and `j` must satisfy 0 <= i < `self.rows` (%d)zand 0 <= j < `self.cols` (%d).csg|]}|kr|qSr4r4)rFrS)r<r4r5rIsz5MatrixDeterminant.minor_submatrix..csg|]}|kr|qSr4r4)rFrS)rKr4r5rIs)rNrOrr&rd)r;r<rKrNrOr4)r<rKr5rs   2z!MatrixDeterminant.minor_submatrix)rt)rt)rt)rg)rt)r@rArBrCrWrXrhrkr6rrrsrx _simplifyrzr|rurpr{rr4r4r4r5rDQs,,0/ ;   1 rDc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ d+ddZ d,ddZ ddZd-ddZeddfddZd.d!d"Zd/d#d$Zeefd%d&Zedfd'd(Zedddfd)d*Zd S)0MatrixReductionszUProvides basic matrix row/column operations. Should not be instantiated directly.cs"fdd}jj|S)Ncs4|kr|fS|kr(|fS||fS)Nr4)r<rK)col1col2r;r4r5rMs   z1MatrixReductions._eval_col_op_swap..entry)rPrNrO)r;rrrMr4)rrr;r5_eval_col_op_swapsz"MatrixReductions._eval_col_op_swapcs"fdd}jj|S)Ncs$|kr||fS||fS)Nr4)r<rK)colrqr;r4r5rMszBMatrixReductions._eval_col_op_multiply_col_by_const..entry)rPrNrO)r;rrqrMr4)rrqr;r5"_eval_col_op_multiply_col_by_constsz3MatrixReductions._eval_col_op_multiply_col_by_constcs$fdd}jj|S)Ncs0|kr$||f|fS||fS)Nr4)r<rK)rrrqr;r4r5rMszFMatrixReductions._eval_col_op_add_multiple_to_other_col..entry)rPrNrO)r;rrqrrMr4)rrrqr;r5&_eval_col_op_add_multiple_to_other_colsz7MatrixReductions._eval_col_op_add_multiple_to_other_colcs"fdd}jj|S)Ncs4|kr|fS|kr(|fS||fS)Nr4)r<rK)row1row2r;r4r5rMs   z1MatrixReductions._eval_row_op_swap..entry)rPrNrO)r;rrrMr4)rrr;r5_eval_row_op_swapsz"MatrixReductions._eval_row_op_swapcs"fdd}jj|S)Ncs$|kr||fS||fS)Nr4)r<rK)rqrowr;r4r5rMszBMatrixReductions._eval_row_op_multiply_row_by_const..entry)rPrNrO)r;rrqrMr4)rqrr;r5"_eval_row_op_multiply_row_by_constsz3MatrixReductions._eval_row_op_multiply_row_by_constcs$fdd}jj|S)Ncs0|kr$||f|fS||fS)Nr4)r<rK)rqrrr;r4r5rM szFMatrixReductions._eval_row_op_add_multiple_to_other_row..entry)rPrNrO)r;rrqrrMr4)rqrrr;r5&_eval_row_op_add_multiple_to_other_row sz7MatrixReductions._eval_row_op_add_multiple_to_other_rowcCs$|j||dddd\}}}|||fS)zReturns (mat, swaps) where `mat` is a row-equivalent matrix in echelon form and `swaps` is a list of row-swaps performed.TF)normalize_last normalize zero_above) _row_reduce)r;rYrlreduced pivot_colsswapsr4r4r5_eval_echelon_forms z#MatrixReductions._eval_echelon_formcs|jdks|jdkrdStfdd|dddfD}|drd|ob|ddddfS|o|ddddfS)NrTc3s|]}|VqdS)Nr4)rFt)rYr4r5r\sz4MatrixReductions._eval_is_echelon..r*)rr)rNrOall_eval_is_echelon)r;rYZ zeros_belowr4)rYr5rs " z!MatrixReductions._eval_is_echelonTcCs"|j|||ddd\}}}||fS)NT)rr)r)r;rYrlrrrrr4r4r5 _eval_rref!szMatrixReductions._eval_rrefrcCs |dkrtd|||dkrv|dk r,|n|}|dks@|dkrNtd|d|krd|jksvntd|||dkr2t||||fdg}t|d krt|||fdg}t|d krtd ||\}}d|kr|jksntd||d|kr |jks2ntd|||d kr|dkrJ|n|}|dkr\|n|}|dks~|dks~|dkrtd |||krtd |d|kr|jksntd||d|kr|jksntd|||||||fS)zValidate the arguments for a row/column operation. `error_str` can be one of "row" or "col" depending on the arguments being parsed.)zn->knzn<->mzn->n+kmzOUnknown {} operation '{}'. Valid col operations are 'n->kn', 'n<->m', 'n->n+km'zn->knNzEFor a {0} operation 'n->kn' you must provide the kwargs `{0}` and `k`rz"This matrix doesn't have a {} '{}'zn<->mrEzIFor a {0} operation 'n<->m' you must provide the kwargs `{0}1` and `{0}2`zn->n+kmzPFor a {0} operation 'n->n+km' you must provide the kwargs `{0}`, `k`, and `{0}2`zAFor a {0} operation 'n->n+km' `{0}` and `{0}2` must be different.)rformatrOset differenceri)r;oprrqrrZ error_strrOr4r4r5_normalize_op_args'sH      z#MatrixReductions._normalize_op_argscsJfddfddtjD}ddt|D}j|dd|fS)a~Permute columns with complicated elements as far right as they can go. Since the `sympy` row reduction algorithms start on the left, having complexity right-shifted speeds things up. Returns a tuple (mat, perm) where perm is a permutation of the columns to perform to shift the complex columns right, and mat is the permuted matrix.cs"tfdddd|fDS)Nc3s"|]}|dkrdndVqdS)Nr*rr4)rFe)rYr4r5r\eszQMatrixReductions._permute_complexity_right..complexity..)sum)r<)rYr;r4r5 complexitybsz>MatrixReductions._permute_complexity_right..complexitycsg|]}||fqSr4r4)rFr<)rr4r5rIfsz>MatrixReductions._permute_complexity_right..cSsg|] \}}|qSr4r4)rFr<rKr4r4r5rIgsrO)Z orientation)r&rOsortedZpermute)r;rYcomplexpermr4)rrYr;r5_permute_complexity_rightXs z*MatrixReductions._permute_complexity_rightcsv|j|j}t|fdd}fdd}fdd} d\} } g} g} xz| kr| |krt|| | d||\}}}}x(|D] \}}|| 7}||| <qW|dkr| d 7} qT| | |d kr|| || | | || f|d kr\| | }}tj||<x8t||d |d D]}|||<q.get_colcs^||d||d||d<||d<dS)Nr*r4)r<rK)rOr_r4r5row_swapsz.MatrixReductions._row_reduce..row_swapcsP||}x>t||dD]$}||||||<q$WdS)z,Does the row op row[i] = a*row[i] - b*row[j]r*N)r&)rSr<brKqp)rOr_r4r5 cross_cancels z2MatrixReductions._row_reduce..cross_cancel)rrNr*rFT) rNrOrcrbrRrrQr& enumeraterPtuple)r;rYrlrrrrNrrrpiv_rowpiv_colrrZ pivot_offsetr`Zassumed_nonzeronewly_determinedoffsetvalr<rKrrZpiv_iZpiv_jr4)rOr_r5rksX   $   $zMatrixReductions._row_reduceFcCs4t|tr|nt}|||\}}}|r0||fS|S)zReturns a matrix row-equivalent to `self` that is in echelon form. Note that echelon form of a matrix is *not* unique, however, properties like the row space and the null space are preserved.) isinstancer)rr)r;rYr with_pivotsrlr_pivotsrr4r4r5 echelon_forms zMatrixReductions.echelon_formn->knNcCs`||||||d\}}}}}|dkr2|||S|dkrF|||S|dkr\||||SdS)aWPerforms the elementary column operation `op`. `op` may be one of * "n->kn" (column n goes to k*n) * "n<->m" (swap column n and column m) * "n->n+km" (column n goes to column n + k*column m) Parameters ========= op : string; the elementary row operation col : the column to apply the column operation k : the multiple to apply in the column operation col1 : one column of a column swap col2 : second column of a column swap or column "m" in the column operation "n->n+km" rzn->knzn<->mzn->n+kmN)rrrr)r;rrrqrrr4r4r5elementary_col_ops  z"MatrixReductions.elementary_col_opcCs`||||||d\}}}}}|dkr2|||S|dkrF|||S|dkr\||||SdS)a(Performs the elementary row operation `op`. `op` may be one of * "n->kn" (row n goes to k*n) * "n<->m" (swap row n and row m) * "n->n+km" (row n goes to row n + k*row m) Parameters ========== op : string; the elementary row operation row : the row to apply the row operation k : the multiple to apply in the row operation row1 : one row of a row swap row2 : second row of a row swap or row "m" in the row operation "n->n+km" rzn->knzn<->mzn->n+kmN)rrrr)r;rrrqrrr4r4r5elementary_row_ops  z"MatrixReductions.elementary_row_opcCs ||S)zReturns `True` if the matrix is in echelon form. That is, all rows of zeros are at the bottom, and below each leading non-zero in a row are exclusively zeros.)r)r;rYr4r4r5 is_echelonszMatrixReductions.is_echelonc st|tr|nt}|jdks&|jdkr*dS|jdks>|jdkr\fdd|D}d|kr\dS|jdkr|jdkr‡fdd|D}d|krd|krdS|}|rd|krdS|dkrdS|jd \}}|j|d \}} } t| S) a Returns the rank of a matrix >>> from sympy import Matrix >>> from sympy.abc import x >>> m = Matrix([[1, 2], [x, 1 - 1/x]]) >>> m.rank() 2 >>> n = Matrix(3, 3, range(1, 10)) >>> n.rank() 2 rr*csg|] }|qSr4r4)rFr3)rYr4r5rI4sz)MatrixReductions.rank..FrEcsg|] }|qSr4r4)rFr3)rYr4r5rI8sN)rY)rYrl) rr)rrNrOrprrri) r;rYrrlzerosrpr_rerrrr4)rYr5ranks(  zMatrixReductions.rankcCs6t|tr|nt}|j|||d\}}|r2||f}|S)aReturn reduced row-echelon form of matrix and indices of pivot vars. Parameters ========== iszerofunc : Function A function used for detecting whether an element can act as a pivot. `lambda x: x.is_zero` is used by default. simplify : Function A function used to simplify elements when looking for a pivot. By default SymPy's `simplify`is used. pivots : True or False If `True`, a tuple containing the row-reduced matrix and a tuple of pivot columns is returned. If `False` just the row-reduced matrix is returned. normalize_last : True or False If `True`, no pivots are normalized to `1` until after all entries above and below each pivot are zeroed. This means the row reduction algorithm is fraction free until the very last step. If `False`, the naive row reduction procedure is used where each pivot is normalized to be `1` before row operations are used to zero above and below the pivot. Notes ===== The default value of `normalize_last=True` can provide significant speedup to row reduction, especially on matrices with symbols. However, if you depend on the form row reduction algorithm leaves entries of the matrix, set `noramlize_last=False` Examples ======== >>> from sympy import Matrix >>> from sympy.abc import x >>> m = Matrix([[1, 2], [x, 1 - 1/x]]) >>> m.rref() (Matrix([ [1, 0], [0, 1]]), (0, 1)) >>> rref_matrix, rref_pivots = m.rref() >>> rref_matrix Matrix([ [1, 0], [0, 1]]) >>> rref_pivots (0, 1) )rYrlr)rr)rr)r;rYrrrrlr]rr4r4r5rrefEs3 zMatrixReductions.rref)T)r)TTT)rNNNN)rNNNN)r@rArBrCrrrrrrrrrrrrr6rrrpropertyrrrr4r4r4r5rs*     1 a  'rc@s>eZdZdZd ddZdefddZd ddZed d Z d S)MatrixSubspaceszmProvides methods relating to the fundamental subspaces of a matrix. Should not be instantiated directly.Fcs$j|dd\}}fdd|DS)aReturns a list of vectors (Matrix objects) that span columnspace of self Examples ======== >>> from sympy.matrices import Matrix >>> m = Matrix(3, 3, [1, 3, 0, -2, -6, 0, 3, 9, 6]) >>> m Matrix([ [ 1, 3, 0], [-2, -6, 0], [ 3, 9, 6]]) >>> m.columnspace() [Matrix([ [ 1], [-2], [ 3]]), Matrix([ [0], [0], [6]])] See Also ======== nullspace rowspace T)rrcsg|]}|qSr4)r)rFr<)r;r4r5rIsz/MatrixSubspaces.columnspace..)r)r;rrrr4)r;r5 columnspaceszMatrixSubspaces.columnspacec sj||d\}fddtjD}g}x\|D]T}tjgj}tj||<x,tD] \}} || |||f8<qZW||q4Wfdd|DS)aReturns list of vectors (Matrix objects) that span nullspace of self Examples ======== >>> from sympy.matrices import Matrix >>> m = Matrix(3, 3, [1, 3, 0, -2, -6, 0, 3, 9, 6]) >>> m Matrix([ [ 1, 3, 0], [-2, -6, 0], [ 3, 9, 6]]) >>> m.nullspace() [Matrix([ [-3], [ 1], [ 0]])] See Also ======== columnspace rowspace )rYrcsg|]}|kr|qSr4r4)rFr<)rr4r5rIsz-MatrixSubspaces.nullspace..csg|]}jd|qS)r*)rPrO)rFr)r;r4r5rIs)rr&rOrrJrQrrR) r;rrYrZ free_varsbasisZfree_varvecrrr4)rr;r5 nullspaces  zMatrixSubspaces.nullspacecs,|j|dd\}fddtt|DS)z:Returns a list of vectors that span the row space of self.T)rrcsg|]}|qSr4)r)rFr<)rr4r5rIsz,MatrixSubspaces.rowspace..)rr&ri)r;rrr4)rr5rowspaceszMatrixSubspaces.rowspacecs|dd}ddfdd}g}x t|dkrD|djrD|d=q&Wx&|D]}|||}|jsL||qLW|rdd |D}|S) a+Apply the Gram-Schmidt orthogonalization procedure to vectors supplied in `vecs`. Arguments ========= vecs : vectors to be made orthogonal normalize : bool. Whether the returned vectors should be renormalized to be unit vectors. rFcSs|||||S)N)dot)rSrr4r4r5projectsz.MatrixSubspaces.orthogonalize..projectcs6fdd|D}t|dkr$Stdd|S)zPprojects vec onto the subspace given by the orthogonal basis `basis`csg|]}|qSr4r4)rFr)rrr4r5rIszKMatrixSubspaces.orthogonalize..perp_to_subspace..rcSs||S)Nr4)rSrr4r4r5r}szIMatrixSubspaces.orthogonalize..perp_to_subspace..)rir)rrZ components)r)rr5perp_to_subspaces z7MatrixSubspaces.orthogonalize..perp_to_subspacercSsg|]}||qSr4)norm)rFrr4r4r5rIsz1MatrixSubspaces.orthogonalize..)getrir1rR)clsZvecskwargsrrr]rZperpr4)rr5 orthogonalizes     zMatrixSubspaces.orthogonalizeN)F)F) r@rArBrCrr6rr classmethodrr4r4r4r5rs  * rc@s^eZdZdZdZdZdddZdddZdefd d Z dd d Z dd dZ ddZ ddZ dS) MatrixEigenz\Provides basic matrix eigenvalue/vector operations. Should not be instantiated directly.NFc Cs|js t|j|dds"td|j}|dkr<|jdd}|rLt|td}gg}}x(|D] \}}} ||g|7}|| 7}q\W|rdd |D}|j||j |fS) a> Return (P, D), where D is diagonal and D = P^-1 * M * P where M is current matrix. Parameters ========== reals_only : bool. Whether to throw an error if complex numbers are need to diagonalize. (Default: False) sort : bool. Sort the eigenvalues along the diagonal. (Default: False) normalize : bool. If True, normalize the columns of P. (Default: False) Examples ======== >>> from sympy import Matrix >>> m = Matrix(3, 3, [1, 2, 0, 0, 3, 0, 2, -4, 2]) >>> m Matrix([ [1, 2, 0], [0, 3, 0], [2, -4, 2]]) >>> (P, D) = m.diagonalize() >>> D Matrix([ [1, 0, 0], [0, 2, 0], [0, 0, 3]]) >>> P Matrix([ [-1, 0, -1], [ 0, 0, -1], [ 2, 1, 2]]) >>> P.inv() * m * P Matrix([ [1, 0, 0], [0, 2, 0], [0, 0, 3]]) See Also ======== is_diagonal is_diagonalizable F) reals_only clear_cachezMatrix is not diagonalizableNT)r)keycSsg|]}||qSr4)r)rFvr4r4r5rINsz+MatrixEigen.diagonalize..) is_squarer.is_diagonalizabler,_cache_eigenvects eigenvectsrr%hstackdiag) r;rsortrZ eigenvecsZp_colsrrmultrr4r4r5 diagonalize s 2    zMatrixEigen.diagonalizeTc s|dd|dd}|s$iS|ddrPtddDrPdd js\jr|jshtfd d tj D}|r|}n2i}xx|D]$}||krd ||<||d 7<qWnJ|ddt t rt j tddf|}nt j tddf|}|rDt |tr&t|nt||jkrDtd|sN|St t s^t|szfdd|DSfdd |DSdS)aReturn eigenvalues using the Berkowitz agorithm to compute the characteristic polynomial. Parameters ========== error_when_incomplete : bool Raise an error when not all eigenvalues are computed. This is caused by ``roots`` not returning a full list of eigenvalues. simplify : bool or function If simplify is set to True, it attempts to return the most simplified form of expressions returned by applying default simplification method in every routine. If simplify is set to False, it will skip simplification in this particular routine to save computation resources. If you pass a function to simplify, it will attempt to apply the particular function as simplification method. Since the roots routine doesn't always work well with Floats, they will be replaced with Rationals before calling that routine. If this is not desired, set flag ``rational`` to False. rFmultiplerationalTcss|]}|tVqdS)N)hasr)rFrr4r4r5r\qsz(MatrixEigen.eigenvals..cSs t|ddS)NT)r)r)r3r4r4r5r}rsz'MatrixEigen.eigenvals..csg|]}||fqSr4r4)rFr<)r_r4r5rIxsz)MatrixEigen.eigenvals..rr*Nr3)r3r)r3z$Could not compute eigenvalues for {}csi|]\}}||qSr4r4)rFrvalue)rr4r5 sz)MatrixEigen.eigenvals..csg|] }|qSr4r4)rFr)rr4r5rIs)rpopany applyfuncis_upperis_lowerrr.r&rNrr)rrzr dictrvaluesrirOr,rritems)r;error_when_incompleteflagsrZdiagonal_entrieseigsZdiagonal_entryr4)r_rr5 eigenvalsRsB       ( zMatrixEigen.eigenvalsc  sddlm}|ddtts2r*tndd|dd}|dd|d d td d D}|r~d dfddj fd|d|}fddt | t dD}|rfddfdd|D}|rfdd|D}|S)aReturn list of triples (eigenval, multiplicity, basis). The flag ``simplify`` has two effects: 1) if bool(simplify) is True, as_content_primitive() will be used to tidy up normalization artifacts; 2) if nullspace needs simplification to compute the basis, the simplify flag will be passed on to the nullspace routine which will interpret it there. Parameters ========== error_when_incomplete : bool Raise an error when not all eigenvalues are computed. This is caused by ``roots`` not returning a full list of eigenvalues. If the matrix contains any Floats, they will be changed to Rationals for computation purposes, but the answers will be returned after being evaluated with evalf. If it is desired to removed small imaginary portions during the evalf step, pass a value for the ``chop`` flag. r)eyerTcSs|S)Nr4)r3r4r4r5r}sz(MatrixEigen.eigenvects..FchoprNcss|]}|tVqdS)N)rr)rFrr4r4r5r\sz)MatrixEigen.eigenvects..cSs t|ddS)NT)r)r)r3r4r4r5r}scsZj|}|jd}t|dkr>r>|jdd}t|dkrVtd||S)z:Get a basis for the eigenspace for a particular eigenvalue)rYrT)rYrz,Can't evaluate eigenvector for eigenvalue %s)rrNrriNotImplementedError)eigenvalmr])rYr_r;rr4r5 eigenspaces   z*MatrixEigen.eigenvects..eigenspace)rrcsg|]\}}|||fqSr4r4)rFrr)rr4r5rIsz*MatrixEigen.eigenvects..)rcs ddlmfdd|DS)Nr)gcdcs"g|]}|t|qSr4)rcr)rFr)rrlr4r5rIsz?MatrixEigen.eigenvects..denom_clean..)sympyr)l)rl)rr5 denom_cleans z+MatrixEigen.eigenvects..denom_cleancs g|]\}}}|||fqSr4r4)rFrres)rr4r5rIscs2g|]*\}}}|jd|fdd|DfqS))rcsg|]}|jdqS))r)evalf)rFr)rr4r5rIsz5MatrixEigen.eigenvects...)r)rFrrr)rr4r5rIs) sympy.matricesrrrr)rrrrrrrr%) r;rrYrrZ primitive has_floatsrr]r4)rrrrYr_r;rlrr5rs.        zMatrixEigen.eigenvectsc s|ddd|kr|dfdd}js<|dSjdk rVj}||Stdd Drrd_|dSjdd _d}x2jD](\}}}|r|jsd}|t|krd}qW||S) alReturns true if a matrix is diagonalizable. Parameters ========== reals_only : bool. If reals_only=True, determine whether the matrix can be diagonalized without complex numbers. (Default: False) kwargs ====== clear_cache : bool. If True, clear the result of any computations when finished. (Default: True) Examples ======== >>> from sympy import Matrix >>> m = Matrix(3, 3, [1, 2, 0, 0, 3, 0, 2, -4, 2]) >>> m Matrix([ [1, 2, 0], [0, 3, 0], [2, -4, 2]]) >>> m.is_diagonalizable() True >>> m = Matrix(2, 2, [0, 1, 0, 0]) >>> m Matrix([ [0, 1], [0, 0]]) >>> m.is_diagonalizable() False >>> m = Matrix(2, 2, [0, 1, -1, 0]) >>> m Matrix([ [ 0, 1], [-1, 0]]) >>> m.is_diagonalizable() True >>> m.is_diagonalizable(reals_only=True) False See Also ======== is_diagonal diagonalize rTZclear_subproductscsrd_d_dS)z%Clears any cached values if requestedN)r_cache_is_diagonalizabler4)rr;r4r5cleanupsz.MatrixEigen.is_diagonalizable..cleanupFNcss|] }|jVqdS)N)is_real)rFrr4r4r5r\(sz0MatrixEigen.is_diagonalizable..)r) rrrr is_symmetricrrrri)r;rrrr]rrrr4)rr;r5rs03     zMatrixEigen.is_diagonalizablec sjstd|ddtddDrtytddjD}Wntk rdd}YnXtt|dfd d }ifd d fd d}dd}fdd}r̈dd }t dd| Dj krt dt|j krdtt|td} j| } |s>|| Sfdd| D} j| } || | Sg} x\t|tdD]H|}||}ddt|D}|| fdd|DqzWfdd| D} j| } |s|| Sg} xt|tdD]g}x| D]x\}}|kr*q|}|d}||||fddt|D}||| t|qWqWj| } || | S)a{Return `(P, J)` where `J` is a Jordan block matrix and `P` is a matrix such that `self == P*J*P**-1` Parameters ========== calc_transform : bool If ``False``, then only `J` is returned. chop : bool All matrices are convered to exact types when computing eigenvalues and eigenvectors. As a result, there may be approximation errors. If ``chop==True``, these errors will be truncated. Examples ======== >>> from sympy import Matrix >>> m = Matrix([[ 6, 5, -2, -3], [-3, -1, 3, 3], [ 2, 1, -2, -3], [-1, 1, 5, 5]]) >>> P, J = m.jordan_form() >>> J Matrix([ [2, 1, 0, 0], [0, 2, 0, 0], [0, 0, 2, 1], [0, 0, 0, 2]]) See Also ======== jordan_block z&Only square matrices have Jordan formsrFcss|]}|tVqdS)N)rr)rFrr4r4r5r\csz*MatrixEigen.jordan_form..css|]}t|tr|jVqdS)N)rrZ_prec)rFZtermr4r4r5r\gs5cs0rfdd|D}t|dkr,|dS|S)zMIf `has_floats` is `True`, cast all `args` as matrices of floats.csg|]}|jdqS))Zprecr)r)rFr)rmax_dpsr4r5rItszCMatrixEigen.jordan_form..restore_floats..r*r)ri)args)rrrr4r5restore_floatsps  z/MatrixEigen.jordan_form..restore_floatscsz||fkr||fS||dfkrN||df|df||f<n |j|||f<||fS)zICache computations of (self - val*I)**pow for quick retrievalr*)rrN)rpow)r_ mat_cacher;r4r5eig_mat{s   & z(MatrixEigen.jordan_form..eig_matcs\j}dg}||d}d}x4||dkrV|||||}|d7}q$W|S)zuCalculate the sequence [0, nullity(E), nullity(E**2), ...] until it is constant where `E = self - val*I`rr*rErZ)rOrrR)rrOr]Znullityr<)r r;r4r5 nullity_chains  z.MatrixEigen.jordan_form..nullity_chaincsPfddtdtdD}tdkr>ddgndg}||S)zReturn a list of the size of each Jordan block. If d_n is the nullity of E**n, then the number of Jordan blocks of size n is 2*d_n - d_(n-1) - d_(n+1)cs0g|](}d||d|dqS)rEr*r4)rFr)rGr4r5rIszNMatrixEigen.jordan_form..blocks_from_nullity_chain..r*rZr)r&ri)rGZmidendr4)rGr5blocks_from_nullity_chains (z:MatrixEigen.jordan_form..blocks_from_nullity_chaincsVt|dkr|dSx<|D]4}j||gjdd\}}|dt|kr|SqWdS)z[Picks a vector from big_basis that isn't in the subspace spanned by small_basisrT)rrZN)rirr)Z small_basisZ big_basisrrer)r;r4r5pick_vecs   z)MatrixEigen.jordan_form..pick_veccSs t|ddS)NT)r)r)r3r4r4r5r}sz)MatrixEigen.jordan_form..css|] }|VqdS)Nr4)rFrr4r4r5r\sz$Could not compute eigenvalues for {})rcsg|]}|ddqS)r*r)r)rFeig)r r4r5rIsz+MatrixEigen.jordan_form..cSsg|]\}}|d|fqS)r*r4)rFr<numr4r4r5rIsc3s(|] \}}t|D]}|fVqqdS)N)r&)rFsizerre)rr4r5r\sc3s |]\}}j||dVqdS))r eigenvalueN) jordan_block)rFrr)r_r4r5r\sr*csg|]}|qSr4r4)rFr<)rr rr4r5rIs)rr.rrmax_matrrrrrrrOr,rrikeysrcrr%rrrreverseextendrr&reversed)r;Zcalc_transformrZmax_precrr r rrblocksZ jordan_matZ jordan_basisZ basis_matZblock_structurechainZ block_sizesZ size_numsZ eig_basisZ block_eigrZnull_bigZ null_smallZnew_vecsr4) rrr rr_rrr;rr5 jordan_form:sp$             zMatrixEigen.jordan_formcKs|jf|}dd|DS)a#Returns left eigenvectors and eigenvalues. This function returns the list of triples (eigenval, multiplicity, basis) for the left eigenvectors. Options are the same as for eigenvects(), i.e. the ``**flags`` arguments gets passed directly to eigenvects(). Examples ======== >>> from sympy import Matrix >>> M = Matrix([[0, 1, 1], [1, 0, 0], [1, 1, 1]]) >>> M.eigenvects() [(-1, 1, [Matrix([ [-1], [ 1], [ 0]])]), (0, 1, [Matrix([ [ 0], [-1], [ 1]])]), (2, 1, [Matrix([ [2/3], [1/3], [ 1]])])] >>> M.left_eigenvects() [(-1, 1, [Matrix([[-2, 1, 1]])]), (0, 1, [Matrix([[-1, -1, 1]])]), (2, 1, [Matrix([[1, 1, 1]])])] cSs&g|]\}}}||dd|DfqS)cSsg|] }|qSr4)rv)rFrr4r4r5rIsz:MatrixEigen.left_eigenvects...r4)rFrrrr4r4r5rIsz/MatrixEigen.left_eigenvects..)rvr)r;rrr4r4r5left_eigenvectsszMatrixEigen.left_eigenvectscCsP|}|j|}g}x&|D]\}}|t|g|7}q W|jdtd|S)a_Compute the singular values of a Matrix Examples ======== >>> from sympy import Matrix, Symbol >>> x = Symbol('x', real=True) >>> A = Matrix([[0, 1, 0], [0, x, 0], [-1, 0, 0]]) >>> A.singular_values() [sqrt(x**2 + 1), 1, 0] See Also ======== condition_number T)rr)Hrrrrr%)r;r_Z valmultpairsvalsrqrr4r4r5singular_valuesszMatrixEigen.singular_values)FFF)T)F)T)r@rArBrCrrrrr6rrrrr r4r4r4r5rs I JE Y A!rc@sPeZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ dS)MatrixCalculusz,Provides calculus-related matrix operations.cGs ddlm}||f|ddiS)aCalculate the derivative of each element in the matrix. ``args`` will be passed to the ``integrate`` function. Examples ======== >>> from sympy.matrices import Matrix >>> from sympy.abc import x, y >>> M = Matrix([[x, y], [1, 0]]) >>> M.diff(x) Matrix([ [1, 0], [0, 0]]) See Also ======== integrate limit r) DerivativeZevaluateT)rr")r;rr"r4r4r5diff>s zMatrixCalculus.diffcs|fddS)Ncs |S)N)r#)r3)argr4r5r}Wsz1MatrixCalculus._eval_derivative..)r)r;r$r4)r$r5_eval_derivativeVszMatrixCalculus._eval_derivativecCs ||S)N)_visit_eval_derivative_array)r;sr4r4r5_accept_eval_derivativeYsz&MatrixCalculus._accept_eval_derivativecs|fddS)Ncs |S)N)r#)r3)baser4r5r}^sz>MatrixCalculus._visit_eval_derivative_scalar..)r)r;r)r4)r)r5_visit_eval_derivative_scalar\sz,MatrixCalculus._visit_eval_derivative_scalarcCsddlm}|||S)Nr)derive_by_array)rr+)r;r)r+r4r4r5r&`s z+MatrixCalculus._visit_eval_derivative_arraycs|fddS)aIntegrate each element of the matrix. ``args`` will be passed to the ``integrate`` function. Examples ======== >>> from sympy.matrices import Matrix >>> from sympy.abc import x, y >>> M = Matrix([[x, y], [1, 0]]) >>> M.integrate((x, )) Matrix([ [x**2/2, x*y], [ x, 0]]) >>> M.integrate((x, 0, 2)) Matrix([ [2, 2*y], [2, 0]]) See Also ======== limit diff cs |jS)N) integrate)r3)rr4r5r}~sz*MatrixCalculus.integrate..)r)r;rr4)rr5r,eszMatrixCalculus.integratecsttsjddkr.jd}n"jddkrHjd}ntdjddkrjjd}n"jddkrjd}ntd||fddS)aCalculates the Jacobian matrix (derivative of a vector-valued function). Parameters ========== self : vector of expressions representing functions f_i(x_1, ..., x_n). X : set of x_i's in order, it can be a list or a Matrix Both self and X can be a row or a column matrix in any order (i.e., jacobian() should always work). Examples ======== >>> from sympy import sin, cos, Matrix >>> from sympy.abc import rho, phi >>> X = Matrix([rho*cos(phi), rho*sin(phi), rho**2]) >>> Y = Matrix([rho, phi]) >>> X.jacobian(Y) Matrix([ [cos(phi), -rho*sin(phi)], [sin(phi), rho*cos(phi)], [ 2*rho, 0]]) >>> X = Matrix([rho*cos(phi), rho*sin(phi)]) >>> X.jacobian(Y) Matrix([ [cos(phi), -rho*sin(phi)], [sin(phi), rho*cos(phi)]]) See Also ======== hessian wronskian rr*z%self must be a row or a column matrixz"X must be a row or a column matrixcs||S)N)r#)rKr<)Xr;r4r5r}sz)MatrixCalculus.jacobian..)r MatrixBaserPshape TypeError)r;r-rrr4)r-r;r5jacobians$      zMatrixCalculus.jacobiancs|fddS)aCalculate the limit of each element in the matrix. ``args`` will be passed to the ``limit`` function. Examples ======== >>> from sympy.matrices import Matrix >>> from sympy.abc import x, y >>> M = Matrix([[x, y], [1, 0]]) >>> M.limit(x, 2) Matrix([ [2, y], [1, 0]]) See Also ======== integrate diff cs |jS)N)limit)r3)rr4r5r}sz&MatrixCalculus.limit..)r)r;rr4)rr5r2szMatrixCalculus.limitN) r@rArBrCr#r%r(r*r&r,r1r2r4r4r4r5r!;s9r!c@seZdZdZddZedefddZddZd d Z d d Z d dZ d&ddZ ddZ ddZddZddZd'ddZd(ddZdd Zd!d"Zd#d$Zd%S))MatrixDeprecatedz+A class to house deprecated matrix methods.cCsddlm}t|tsnt|r^t||jkrPt||jkrPtd|j t|f| ||St dt ||}|j|jkr|jdkr|j }|j }t||}|S|j|jkr| |j S|j|jkr|j |Std|j |j fdS)zQCompatibility function for deprecated behavior of ``matrix.dot(vector)`` r*)Matrixz,Dimensions incorrect for dot product: %s, %sz2`b` must be an ordered iterable or Matrix, not %s.N)denser4rr.r$rirOrNr-r/rr0typeTr"tolist)r;rr4r_Zprodr4r4r5_legacy_array_dots0         z"MatrixDeprecated._legacy_array_dotrycCs |j|dS)N)r3)rz)r;r3rr4r4r5berkowitz_charpolysz#MatrixDeprecated.berkowitz_charpolycCs |jddS)zwComputes determinant using Berkowitz method. See Also ======== det berkowitz rt)rw)rp)r;r4r4r5 berkowitz_dets zMatrixDeprecated.berkowitz_detcKs |jf|S)zwComputes eigenvalues of a Matrix using Berkowitz method. See Also ======== berkowitz )r)r;rr4r4r5berkowitz_eigenvalssz$MatrixDeprecated.berkowitz_eigenvalscCs>tjg}}x(|D]}|||d| }qWt|S)zpComputes principal minors using Berkowitz method. See Also ======== berkowitz rZ)rrQrtrRr)r;rfZminorsZpolyr4r4r5berkowitz_minors s   z!MatrixDeprecated.berkowitz_minorscCsddlm}d}|s|S|js$t||j}}dg|d}xt|ddD]}||d||d}}||d|f |d||f} } |d|d|f|||f }} | g} x(td|dD]} | || | qWx$t| D]\} }| |d| | <qWtj | g| } x2t|D]&} | d|| d|| d| f<q"W|||d<qNW| tj |d gg}x(t|D]\} }|||| q~W|t t t |S)Nr)r))r*r*rZrE)rr) rrrr.rNr&rRrrrQrPrmap)r;rZberkrUNZ transformsrr7rqrHrTrSrr<BZpolysr4r4r5rts2  $$&zMatrixDeprecated.berkowitzrtcCs |j|dS)N)rw)ru)r;rwr4r4r5cofactorMatrixEszMatrixDeprecated.cofactorMatrixcCs |jddS)Nrg)rw)rp)r;r4r4r5 det_bareisHszMatrixDeprecated.det_bareiscCs |jddS)a;Compute matrix determinant using Bareiss' fraction-free algorithm which is an extension of the well known Gaussian elimination method. This approach is best suited for dense symbolic matrices and will result in a determinant with minimal number of fractions. It means that less term rewriting is needed on resulting formulae. TODO: Implement algorithm for sparse matrices (SFF), http://www.eecis.udel.edu/~saunders/papers/sffge/it5.ps. See Also ======== det berkowitz_det rg)rw)rp)r;r4r4r5 det_bareissKszMatrixDeprecated.det_bareisscCs |jddS)aCompute matrix determinant using LU decomposition Note that this method fails if the LU decomposition itself fails. In particular, if the matrix has no inverse this method will fail. TODO: Implement algorithm for sparse matrices (SFF), http://www.eecis.udel.edu/~saunders/papers/sffge/it5.ps. See Also ======== det det_bareiss berkowitz_det rn)rw)rp)r;r4r4r5det_LU_decomposition^sz%MatrixDeprecated.det_LU_decompositioncCs|j||dS)N)rr)r)r;rrr4r4r5 jordan_cellsszMatrixDeprecated.jordan_cellTcCs|\}}||fS)N)rget_diag_blocks)r;Zcalc_transformationPJr4r4r5 jordan_cellsvs zMatrixDeprecated.jordan_cellscCs|j|||dS)N)rw)r{)r;r<rKrwr4r4r5 minorEntryzszMatrixDeprecated.minorEntrycCs |||S)N)r)r;r<rKr4r4r5 minorMatrix}szMatrixDeprecated.minorMatrixcCs|j|ddS)zEPermute the rows of the matrix with the given permutation in reverse.Zbackward) direction) permute_rows)r;rr4r4r5 permuteBkwdszMatrixDeprecated.permuteBkwdcCs|j|ddS)z:Permute the rows of the matrix with the given permutation.Zforward)rL)rM)r;rr4r4r5 permuteFwdszMatrixDeprecated.permuteFwdN)rt)T)rt)r@rArBrCr9r rr:r;r<r=rtrArBrCrDrErIrJrKrNrOr4r4r4r5r3s"!  (   r3c@seZdZdZdZdZdZeeZ dZ e fddZ dd Z d d Zd d ZddZddZddZddZddZdyddZeddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zed*d+Z d,d-Z!d.d/Z"d0d1Z#d2d3Z$dzd5d6Z%d7d8Z&e'fd9d:Z(e'fd;d<Z)e'fd=d>Z*d{d?d@Z+dAdBZ,dCdDZ-dEdFZ.dGdHZ/dIdJZ0dKdLZ1e'dd4fdMdNZ2e'dd4fdOdPZ3dQdRZ4e'fdSdTZ5dUdVZ6dWdXZ7d|dYdZZ8d}d[d\Z9d]d^Z:d~d`daZ;dbdcZddidjZ?ddldmZ@ddsdtZAdudvZBddwdxZCdS)r.zBase class for matrix objects. Tr~NcCsddlm}|||dS)Nr*) matrix2numpy)dtype)r5rQ)r;rRrQr4r4r5 __array__s zMatrixBase.__array__cs2dkrfdd}|StdjjfdS)N)r#r,r2csfdd}|S)Ncst|S)N)getattr)item)rattrr4r5r}sz6MatrixBase.__getattr__..doit..)r)rZ item_doit)rVr;)rr5doitsz$MatrixBase.__getattr__..doitz%s has no attribute %s.)r2 __class__r@)r;rVrWr4)rVr;r5 __getattr__s zMatrixBase.__getattr__cCs |j|jS)zgReturn the number of elements of self. Implemented mainly so bool(Matrix()) == False. )rNrO)r;r4r4r5__len__szMatrixBase.__len__cCs\d}xJt|jD]<}|d7}x&t|jD]}||||f7}q(W|d7}qWd|dS)Nz z zz )r&rNrO __mathml__)r;Zmmlr<rKr4r4r5r\s zMatrixBase.__mathml__cCs ||k S)Nr4)r;otherr4r4r5__ne__szMatrixBase.__ne__csddlm}mddlmfdd}|\}}|}fdd|D}x|D]}|||qTW|||||S)Nr)r MutableMatrix)binomialcs|jd}|d}|dkr4||dkdkr4tdn$|dkrX|dkrX|ddkrXtdx^t|D]R}xLt||D]<}||}t|r|}||||||||f<qtWqbWdS)Nr)rrr*FzMatrix det == 0; not invertiblez%Non-integer power cannot be evaluated)r/rr&rZ_eval_expand_func)Zjcrr?rr<rKZbn)r`r4r5jordan_cell_powers    zBMatrixBase._matrix_pow_by_jordan_blocks..jordan_cell_powercsg|] }|qSr4r4)rFrK)r_r4r5rIsz;MatrixBase._matrix_pow_by_jordan_blocks..) rrr_rr`rrFrPinv)r;rrrarGrHrIrKr4)r_r`r5_matrix_pow_by_jordan_blockss    z'MatrixBase._matrix_pow_by_jordan_blockscCst|S)N)r)r;r4r4r5r?szMatrixBase.__repr__cCs4|jdks|jdkr$d|j|jfSdt|S)NrzMatrix(%s, %s, [])z Matrix(%s))rNrOstrr8)r;r4r4r5r>szMatrixBase.__str__cCs|`|`|`dS)N)Z _is_symbolicZ _is_symmetricZ _eigenvects)r;r4r4r5_diagonalize_clear_subproductssz)MatrixBase._diagonalize_clear_subproductscCsh|sddlm}|}|jdks*|jdkr:d|j|jfS|jdkrVd|j|ddSd|j|ddS) Nr) StrPrinterzMatrix(%s, %s, [])r*z Matrix([%s])z, )rowsepz Matrix([ %s]))Zsympy.printing.strrfrNrOtable)r;printerrfr4r4r5 _format_strs  zMatrixBase._format_strc s$ddlm}d}t|dkrt|d|rN|dj|djt|dfSt|dtrx|dj|dj|dj fSt|dt r|dj r|dj|dj|d j fSt |ddr~|d}t|jdkr|jd|jd}}fdd|D}|||fSt|jdkrr|jdd}}tjg|}x(tt|D]||<qLW|||fStd qt|drt|dtsg}t} x|dD]|} t| tr|| | js| jr*| | jn>|| y| t| Wn tk r(| dYnXqWt| dkrRtd tt| | r`| nd}|rrt|nd}|rt|dsd}fd d|D}|||fSg}x>t|D]2} x*t|D]||| qWqWnt|d krt!|d}t!|d}|dks,|dkr>> from sympy import Matrix, I Matrix can be constructed as follows: * from a nested list of iterables >>> Matrix( ((1, 2+I), (3, 4)) ) Matrix([ [1, 2 + I], [3, 4]]) * from un-nested iterable (interpreted as a column) >>> Matrix( [1, 2] ) Matrix([ [1], [2]]) * from un-nested iterable with dimensions >>> Matrix(1, 2, [1, 2] ) Matrix([[1, 2]]) * from no arguments (a 0 x 0 matrix) >>> Matrix() Matrix(0, 0, []) * from a rule >>> Matrix(2, 2, lambda i, j: i/(j + 1) ) Matrix([ [0, 0], [1, 1/2]]) r) SparseMatrixNr*rSrEcsg|]}|qSr4)_sympify)rFr<)rr4r5rI0sz6MatrixBase._handle_creation_inputs..z&SymPy supports just 1D and 2D matricesz Got rows of variable lengths: %scsg|]}|qSr4)rl)rFr<)rr4r5rITsr~z@Cannot create a {} x {} matrix. Both dimensions must be positivec s(g|] }|qSr4)rl)rFrK)rr<rr4r5rIisz+List length should be equal to rows*columnscsg|]}|qSr4)rl)rFr<)rr4r5rIrszData type not understood)$Zsympy.matrices.sparserkrirrNrOr"r8r.rr is_MatrixZ as_explicithasattrrSr/ZravelrrJr&rlrr$r8rraddrRr0rrrcrrrr!) rrrrkZ flat_listZarrrNrOZin_matZncolrrKr4)rr<rr5_handle_creation_inputss+ "         (    z"MatrixBase._handle_creation_inputscCs"ddlm}t|t}||\}}}t|t}t|tksJt|tkr|r^|||dSt|tst |r| ||dSt d|n|st|t st |r||}d}|r |rtt ||jtt ||jf}n t|||jt|||jf}|||n||||fSdSdS)amHelper to set value at location given by key. Examples ======== >>> from sympy import Matrix, I, zeros, ones >>> m = Matrix(((1, 2+I), (3, 4))) >>> m Matrix([ [1, 2 + I], [3, 4]]) >>> m[1, 0] = 9 >>> m Matrix([ [1, 2 + I], [9, 4]]) >>> m[1, 0] = [[0, 1]] To replace row r you assign to position r*m where m is the number of columns: >>> M = zeros(4) >>> m = M.cols >>> M[3*m] = ones(1, m)*2; M Matrix([ [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [2, 2, 2, 2]]) And to replace column c you can assign to position c: >>> M[2] = ones(m, 1)*4; M Matrix([ [0, 0, 4, 0], [0, 0, 4, 0], [0, 0, 4, 0], [2, 2, 4, 2]]) r*)r4Nzunexpected value: %sT)r5r4rslicekey2ijr.r6Z copyin_matrixrr$Z copyin_listrrdivmodrOrNrl)r;rrr4Zis_slicer<rKZis_matr4r4r5_setitems2(     zMatrixBase._setitemcCs||S)zReturn self + b r4)r;rr4r4r5roszMatrixBase.addcCsT|jr|}n.|j|jkr6|j|}|j|}ntd||}|j|S)aSolves Ax = B using Cholesky decomposition, for a general square non-singular matrix. For a non-square matrix with rows > cols, the least squares solution is returned. See Also ======== lower_triangular_solve upper_triangular_solve gauss_jordan_solve diagonal_solve LDLsolve LUsolve QRsolve pinv_solve z6Under-determined System. Try M.gauss_jordan_solve(rhs)) is_hermitian _choleskyrNrOrr_lower_triangular_solve_upper_triangular_solve)r;rhsLYr4r4r5cholesky_solves    zMatrixBase.cholesky_solvecCs$|jstd|jstd|S)aReturns the Cholesky decomposition L of a matrix A such that L * L.H = A A must be a Hermitian positive-definite matrix. Examples ======== >>> from sympy.matrices import Matrix >>> A = Matrix(((25, 15, -5), (15, 18, 0), (-5, 0, 11))) >>> A.cholesky() Matrix([ [ 5, 0, 0], [ 3, 3, 0], [-1, 1, 3]]) >>> A.cholesky() * A.cholesky().T Matrix([ [25, 15, -5], [15, 18, 0], [-5, 0, 11]]) The matrix can have complex entries: >>> from sympy import I >>> A = Matrix(((9, 3*I), (-3*I, 5))) >>> A.cholesky() Matrix([ [ 3, 0], [-I, 2]]) >>> A.cholesky() * A.cholesky().H Matrix([ [ 9, 3*I], [-3*I, 5]]) See Also ======== LDLdecomposition LUdecomposition QRdecomposition zMatrix must be square.zMatrix must be Hermitian.)rr.rurrv)r;r4r4r5choleskys +zMatrixBase.choleskycCs"|s tjS|}t|t|S)a{Returns the condition number of a matrix. This is the maximum singular value divided by the minimum singular value Examples ======== >>> from sympy import Matrix, S >>> A = Matrix([[1, 0, 0], [0, 10, 0], [0, 0, S.One/10]]) >>> A.condition_number() 100 See Also ======== singular_values )rrJr rr)r;Zsingularvaluesr4r4r5condition_number szMatrixBase.condition_numbercCs||j|j|jS)z Returns the copy of a matrix. Examples ======== >>> from sympy import Matrix >>> A = Matrix(2, 2, [1, 2, 3, 4]) >>> A.copy() Matrix([ [1, 2], [3, 4]]) )rPrNrOr)r;r4r4r5copy/ szMatrixBase.copyc Cst|stdt||j|j|j|jkr>> from sympy import Matrix, I, eye >>> m = Matrix((0, 1 + I, 2, 3)) >>> m.D Matrix([[0, 1 - I, -2, -3]]) >>> m = (eye(4) + I*eye(4)) >>> m[0, 3] = 2 >>> m.D Matrix([ [1 - I, 0, 0, 0], [ 0, 1 - I, 0, 0], [ 0, 0, -1 + I, 0], [ 2, 0, 0, -1 + I]]) If the matrix does not have 4 rows an AttributeError will be raised because this property is only defined for matrices with 4 rows. >>> Matrix(eye(2)).D Traceback (most recent call last): ... AttributeError: Matrix has no attribute D. See Also ======== conjugate: By-element conjugation H: Hermite conjugation r)mgamma)Zsympy.physics.matricesrrNr2r)r;rr4r4r5D` s"  z MatrixBase.DcCs,|jstd|j|jkr"td||S)aSolves Ax = B efficiently, where A is a diagonal Matrix, with non-zero diagonal entries. Examples ======== >>> from sympy.matrices import Matrix, eye >>> A = eye(2)*2 >>> B = Matrix([[1, 2], [3, 4]]) >>> A.diagonal_solve(B) == B/2 True See Also ======== lower_triangular_solve upper_triangular_solve gauss_jordan_solve cholesky_solve LDLsolve LUsolve QRsolve pinv_solve zMatrix should be diagonalzSize mis-match)Z is_diagonalr0rN_diagonal_solve)r;ryr4r4r5diagonal_solve s  zMatrixBase.diagonal_solvecCsddlm}t|tsnt|r^t||jkrPt||jkrPtd|j t|f| ||St dt ||}d|j ksd|j krt ddddd ||St|t|krtd|j |j ft|}|j d|fkr|d|}|j |dfkr||d}||d S) aReturn the dot product of two vectors of equal length. ``self`` must be a ``Matrix`` of size 1 x n or n x 1, and ``b`` must be either a matrix of size 1 x n, n x 1, or a list/tuple of length n. A scalar is returned. Examples ======== >>> from sympy import Matrix >>> M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> v = Matrix([1, 1, 1]) >>> M.row(0).dot(v) 6 >>> M.col(0).dot(v) 12 >>> v = [3, 2, 1] >>> M.row(0).dot(v) 10 See Also ======== cross multiply multiply_elementwise r*)r4z,Dimensions incorrect for dot product: %s, %sz2`b` must be an ordered iterable or Matrix, not %s.z%Dot product of non row/column vectorsi5z1.2z* to take matrix products)Zfeatureissuedeprecated_since_version useinsteadr)r5r4rr.r$rirOrNr-r/rr0r6r(warnr9reshape)r;rr4r_rr4r4r5r s6       zMatrixBase.dotc CsDddlm}ddlm}|ddddf|j}}||}|rH|Sxvtd|D]h}xbtd|D]T}d}x0td|D]"} ||||d| |d| f7}qxW||||f<| |||f<qdWqTWx~td|D]p} d}xDtd|D]6} x0td|D]"} ||d| | | || | f7}qWqW|d}| |d| f<||| df<qW|S)aReturns the dual of a matrix, which is: `(1/2)*levicivita(i, j, k, l)*M(k, l)` summed over indices `k` and `l` Since the levicivita method is anti_symmetric for any pairwise exchange of indices, the dual of a symmetric matrix is the zero matrix. Strictly speaking the dual defined here assumes that the 'matrix' `M` is a contravariant anti_symmetric second rank tensor, so that the dual is a covariant second rank tensor. r) LeviCivita)rNr*rE)rrrrrNrr&) r;rrMrZworkr<rKZacumrqrrSrr4r4r5dual s,  " &zMatrixBase.dualc Cs|jstdy|\}}|}Wntk rBtdYnXdd}tt||}ddlm }ddl m }||}||| } t dd |Drt||| St|| Sd S) z-Return the exponentiation of a square matrix.z0Exponentiation is valid only for square matricesz`Exponentiation is implemented only for matrices for which the Jordan normal form can be computedc Ss|j}|d}|dkr t|}ndddlm}|d||}||}||}x&td|D]}|||t|}qXWt|d|}|S)N)rrr*r)r)rNrrrr&r) rZnrrresrrGrZnexr<r4r4r5_jblock_exponential s  z+MatrixBase.exp.._jblock_exponentialr)r)recss|] }|jVqdS)N)r)rFrr4r4r5r\1 sz!MatrixBase.exp..N)rr.rrFr,rrcr>rrrrrbrrr6) r;rGrHZcellsrrrrZeJr]r4r4r5r s$     zMatrixBase.expFcsddlm}m}|||}|ddddfj\}|jdd\}}|ddddf|dddf}} ttfdd|}t |} |t j } | || }x t |D]\} } || | qW|ddddf|dddf}} | | ddfjstd | t |d}td |d dd j}t||fd dt | D| d}|d| | df}| d| df}| ||||}|d}x&t |D]\}} | || |df<qW|r|||fS||fSdS)a: Solves Ax = b using Gauss Jordan elimination. There may be zero, one, or infinite solutions. If one solution exists, it will be returned. If infinite solutions exist, it will be returned parametrically. If no solutions exist, It will throw ValueError. Parameters ========== b : Matrix The right hand side of the equation to be solved for. Must have the same number of rows as matrix A. freevar : List If the system is underdetermined (e.g. A has more columns than rows), infinite solutions are possible, in terms of arbitrary values of free variables. Then the index of the free variables in the solutions (column Matrix) will be returned by freevar, if the flag `freevar` is set to `True`. Returns ======= x : Matrix The matrix that will satisfy Ax = B. Will have as many rows as matrix A has columns, and as many columns as matrix B. params : Matrix If the system is underdetermined (e.g. A has more columns than rows), infinite solutions are possible, in terms of arbitrary parameters. These arbitrary parameters are returned as params Matrix. Examples ======== >>> from sympy import Matrix >>> A = Matrix([[1, 2, 1, 1], [1, 2, 2, -1], [2, 4, 0, 6]]) >>> b = Matrix([7, 12, 4]) >>> sol, params = A.gauss_jordan_solve(b) >>> sol Matrix([ [-2*tau0 - 3*tau1 + 2], [ tau0], [ 2*tau1 + 5], [ tau1]]) >>> params Matrix([ [tau0], [tau1]]) >>> A = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 10]]) >>> b = Matrix([3, 6, 9]) >>> sol, params = A.gauss_jordan_solve(b) >>> sol Matrix([ [-1], [ 2], [ 0]]) >>> params Matrix(0, 1, []) See Also ======== lower_triangular_solve upper_triangular_solve cholesky_solve diagonal_solve LDLsolve LUsolve QRsolve pinv References ========== .. [1] http://en.wikipedia.org/wiki/Gaussian_elimination r)r4rNrZT)rcs|kS)Nr4)r)rr4r5r} sz/MatrixBase.gauss_jordan_solve..zLinear system has no solutiontaucSst|dS)NZ 1234567890)rdrstrip)r<r4r4r5r} s)Zcomparecsg|] }tqSr4)next)rFrq)genr4r5rI sz1MatrixBase.gauss_jordan_solve..r*)rr4rrrr/rrcfilterrir&r7ZvstackrZcol_swapr1rr r:r#r)r;rZfreevarr4rZaugrrUrrrZ permutationr<cZfree_var_indexr:rVZvtZfree_solZsolrqr4)rrr5gauss_jordan_solve6 s:S& &*  zMatrixBase.gauss_jordan_solvecs|js t|j|}dyt|Wn tk rLtdYnX||fddtD}|S)at Returns the inverse of the matrix `K` (mod `m`), if it exists. Method to find the matrix inverse of `K` (mod `m`) implemented in this function: * Compute `\mathrm{adj}(K) = \mathrm{cof}(K)^t`, the adjoint matrix of `K`. * Compute `r = 1/\mathrm{det}(K) \pmod m`. * `K^{-1} = r\cdot \mathrm{adj}(K) \pmod m`. Examples ======== >>> from sympy import Matrix >>> A = Matrix(2, 2, [1, 2, 3, 4]) >>> A.inv_mod(5) Matrix([ [3, 1], [4, 2]]) >>> A.inv_mod(3) Matrix([ [1, 1], [0, 1]]) Nz!Matrix is not invertible (mod %d)cs.g|]&}tD]}||fqqSr4)r&)rFr<rK)K_adjr?det_invrr4r5rI sz&MatrixBase.inv_mod..) rr.rOrprrrxrXr&)r;rZdet_KZK_invr4)rr?rrr5inv_mod szMatrixBase.inv_modcsr|jstd|jdd}|d}|dkrZ|jdddtfdd tjD}|rftd | |S) zCalculates the inverse using the adjugate matrix and a determinant. See Also ======== inv inverse_LU inverse_GE z"A Matrix must be square to invert.rt)rwrNT)rc3s|]}||fVqdS)Nr4)rFrK)rYokr4r5r\ sz)MatrixBase.inverse_ADJ..z Matrix det == 0; not invertible.) rr.rpequalsrrr&rNrrx)r;rYrGZzeror4)rYrr5 inverse_ADJ s   zMatrixBase.inverse_ADJcsddlm}|jstd||||j}|jdddt fddt jDrjt d | d d |jd fS) zCalculates the inverse using Gaussian elimination. See Also ======== inv inverse_LU inverse_ADJ r*)r4z"A Matrix must be square to invert.T)rYrrc3s|]}||fVqdS)Nr4)rFrK)rYredr4r5r\ sz(MatrixBase.inverse_GE..z Matrix det == 0; not invertible.N) r5r4rr.r as_mutablerrNrrr&rrP)r;rYr4Zbigr4)rYrr5 inverse_GE s zMatrixBase.inverse_GEcsX|js t|jdddtfddtjDrBtd|j||jt dS)zCalculates the inverse using LU decomposition. See Also ======== inv inverse_GE inverse_ADJ T)rrc3s|]}||fVqdS)Nr4)rFrK)rYrr4r5r\# sz(MatrixBase.inverse_LU..z Matrix det == 0; not invertible.)rY) rr.rrr&rNrLUsolverr6)r;rYr4)rYrr5 inverse_LU s zMatrixBase.inverse_LUcKs(|js t|dk r||d<|jf|S)a Return the inverse of a matrix. CASE 1: If the matrix is a dense matrix. Return the matrix inverse using the method indicated (default is Gauss elimination). Parameters ========== method : ('GE', 'LU', or 'ADJ') Notes ===== According to the ``method`` keyword, it calls the appropriate method: GE .... inverse_GE(); default LU .... inverse_LU() ADJ ... inverse_ADJ() See Also ======== inverse_LU inverse_GE inverse_ADJ Raises ------ ValueError If the determinant of the matrix is zero. CASE 2: If the matrix is a sparse matrix. Return the matrix inverse using Cholesky or LDL (default). kwargs ====== method : ('CH', 'LDL') Notes ===== According to the ``method`` keyword, it calls the appropriate method: LDL ... inverse_LDL(); default CH .... inverse_CH() Raises ------ ValueError If the determinant of the matrix is zero. Nrw)rr.Z _eval_inverse)r;rwrr4r4r5rb( s :zMatrixBase.invcCsF|sdS|jstdtd|}||}|jd||jkrBdSdS)aChecks if a matrix is nilpotent. A matrix B is nilpotent if for some integer k, B**k is a zero matrix. Examples ======== >>> from sympy import Matrix >>> a = Matrix([[0, 0, 0], [1, 0, 0], [1, 1, 0]]) >>> a.is_nilpotent() True >>> a = Matrix([[1, 0, 1], [1, 0, 0], [1, 1, 0]]) >>> a.is_nilpotent() False Tz,Nilpotency is valid only for square matricesr3rF)rr.r rzrrN)r;r3rr4r4r5 is_nilpotenth s  zMatrixBase.is_nilpotentc Csddlm}dd|D\}}|rP|js2d}}qh|d|jdd\}}n||d|j}|d}|r|js|d}}q|d|jdd\}}n||d|j}|d}||||fS)zConverts a key with potentially mixed types of keys (integer and slice) into a tuple of ranges and raises an error if any index is out of self's range. See Also ======== key2ij r)r+cSsg|]}t|tqSr4)rrq)rFrqr4r4r5rI sz)MatrixBase.key2bounds..NrEr*)sympy.matrices.commonr+rNindicesrO) r;ra2idx_isliceZjsliceZrloZrhiZcloZchir4r4r5 key2bounds s   zMatrixBase.key2boundscs|ddlmt|rBt|dks(tdfddt||jDSt|trb| t|ddSt |t||j SdS)zConverts key into canonical form, converting integers or indexable items into valid integers for self's range or returning slices unchanged. See Also ======== key2bounds r)r+rEz"key must be a sequence of length 2cs(g|] \}}t|ts ||n|qSr4)rrq)rFr<r)rr4r5rI sz%MatrixBase.key2ij..N) rr+r$rir0zipr/rrqrrsrO)r;rr4)rr5rr s    zMatrixBase.key2ijcCs$|jstd|jstd|S)aReturns the LDL Decomposition (L, D) of matrix A, such that L * D * L.H == A This method eliminates the use of square root. Further this ensures that all the diagonal entries of L are 1. A must be a Hermitian positive-definite matrix. Examples ======== >>> from sympy.matrices import Matrix, eye >>> A = Matrix(((25, 15, -5), (15, 18, 0), (-5, 0, 11))) >>> L, D = A.LDLdecomposition() >>> L Matrix([ [ 1, 0, 0], [ 3/5, 1, 0], [-1/5, 1/3, 1]]) >>> D Matrix([ [25, 0, 0], [ 0, 9, 0], [ 0, 0, 9]]) >>> L * D * L.T * A.inv() == eye(A.rows) True The matrix can have complex entries: >>> from sympy import I >>> A = Matrix(((9, 3*I), (-3*I, 5))) >>> L, D = A.LDLdecomposition() >>> L Matrix([ [ 1, 0], [-I/3, 1]]) >>> D Matrix([ [9, 0], [0, 4]]) >>> L*D*L.H == A True See Also ======== cholesky LUdecomposition QRdecomposition zMatrix must be square.zMatrix must be Hermitian.)rr.rurZ_LDLdecomposition)r;r4r4r5LDLdecomposition s 1zMatrixBase.LDLdecompositioncCsf|jr|\}}n2|j|jkr>|j|\}}|j|}ntd||}||}|j|S)aSolves Ax = B using LDL decomposition, for a general square and non-singular matrix. For a non-square matrix with rows > cols, the least squares solution is returned. Examples ======== >>> from sympy.matrices import Matrix, eye >>> A = eye(2)*2 >>> B = Matrix([[1, 2], [3, 4]]) >>> A.LDLsolve(B) == B/2 True See Also ======== LDLdecomposition lower_triangular_solve upper_triangular_solve gauss_jordan_solve cholesky_solve diagonal_solve LUsolve QRsolve pinv_solve z6Under-determined System. Try M.gauss_jordan_solve(rhs)) rurrNrOrrrwrrx)r;ryrzrr{Zr4r4r5LDLsolve s    zMatrixBase.LDLsolvecCs:|jstd|j|jkr"td|js0td||S)a Solves Ax = B, where A is a lower triangular matrix. See Also ======== upper_triangular_solve gauss_jordan_solve cholesky_solve diagonal_solve LDLsolve LUsolve QRsolve pinv_solve zMatrix must be square.zMatrices size mismatch.z Matrix must be lower triangular.)rr.rNr-rrrw)r;ryr4r4r5lower_triangular_solve s z!MatrixBase.lower_triangular_solvec sZ|j|||d\}fdd}fdd}|jj|}|jj|}|||fS)aReturns (L, U, perm) where L is a lower triangular matrix with unit diagonal, U is an upper triangular matrix, and perm is a list of row swap index pairs. If A is the original matrix, then A = (L*U).permuteBkwd(perm), and the row permutation matrix P such that P*A = L*U can be computed by P=eye(A.row).permuteFwd(perm). See documentation for LUCombined for details about the keyword argument rankcheck, iszerofunc, and simpfunc. Examples ======== >>> from sympy import Matrix >>> a = Matrix([[4, 3], [6, 3]]) >>> L, U, _ = a.LUdecomposition() >>> L Matrix([ [ 1, 0], [3/2, 1]]) >>> U Matrix([ [4, 3], [0, -3/2]]) See Also ======== cholesky LDLdecomposition QRdecomposition LUdecomposition_Simple LUdecompositionFF LUsolve )rYrl rankcheckcs8||krtjS||krtjS|jkr2||fStjS)N)rrJrQrO)r<rK)combinedr4r5entry_Ld s  z+MatrixBase.LUdecomposition..entry_Lcs||krtjS||fS)N)rrJ)r<rK)rr4r5entry_Up sz+MatrixBase.LUdecomposition..entry_U)rmrPrNrO) r;rYrlrrrrrzUr4)rr5LUdecomposition2 s' zMatrixBase.LUdecompositioncs|r|jdks|jdkr,||j|jgfS|g}dx>tdjdD](}d}xV|jkr|rfddt||jD}t|||\}} } } | dk}|r\d7q\W|rƈ|krtd|dkrdn||} | dkr|r|fSx | D]\} }||| f<qW|| kr||| g| d|f|d|f|d|f<| d|f<| jf|jf|jf<| jf<d}x~t|djD]j}|f|f||f<xBt|jD]2}||f||f||f||f<qWqW|kr`x(t|djD]}tj |f<qHWd7jkrP|fSqPW|fS)a"Compute an lu decomposition of m x n matrix A, where P*A = L*U * L is m x m lower triangular with unit diagonal * U is m x n upper triangular * P is an m x m permutation matrix Returns an m x n matrix lu, and an m element list perm where each element of perm is a pair of row exchange indices. The factors L and U are stored in lu as follows: The subdiagonal elements of L are stored in the subdiagonal elements of lu, that is lu[i, j] = L[i, j] whenever i > j. The elements on the diagonal of L are all 1, and are not explicitly stored. U is stored in the upper triangular portion of lu, that is lu[i ,j] = U[i, j] whenever i <= j. The output matrix can be visualized as: Matrix([ [u, u, u, u], [l, u, u, u], [l, l, u, u], [l, l, l, u]]) where l represents a subdiagonal entry of the L factor, and u represents an entry from the upper triangular entry of the U factor. perm is a list row swap index pairs such that if A is the original matrix, then A = (L*U).permuteBkwd(perm), and the row permutation matrix P such that ``P*A = L*U`` can be computed by ``P=eye(A.row).permuteFwd(perm)``. The keyword argument rankcheck determines if this function raises a ValueError when passed a matrix whose rank is strictly less than min(num rows, num cols). The default behavior is to decompose a rank deficient matrix. Pass rankcheck=True to raise a ValueError instead. (This mimics the previous behavior of this function). The keyword arguments iszerofunc and simpfunc are used by the pivot search algorithm. iszerofunc is a callable that returns a boolean indicating if its input is zero, or None if it cannot make the determination. simpfunc is a callable that simplifies its input. The default is simpfunc=None, which indicate that the pivot search algorithm should not attempt to simplify any candidate pivots. If simpfunc fails to simplify its input, then it must return its input instead of a copy. When a matrix contains symbolic entries, the pivot search algorithm differs from the case where every entry can be categorized as zero or nonzero. The algorithm searches column by column through the submatrix whose top left entry coincides with the pivot position. If it exists, the pivot is the first entry in the current search column that iszerofunc guarantees is nonzero. If no such candidate exists, then each candidate pivot is simplified if simpfunc is not None. The search is repeated, with the difference that a candidate may be the pivot if ``iszerofunc()`` cannot guarantee that it is nonzero. In the second search the pivot is the first candidate that iszerofunc can guarantee is nonzero. If no such candidate exists, then the pivot is the first candidate for which iszerofunc returns None. If no such candidate exists, then the search is repeated in the next column to the right. The pivot search algorithm differs from the one in `rref()`, which relies on ``_find_reasonable_pivot()``. Future versions of ``LUdecomposition_simple()`` may use ``_find_reasonable_pivot()``. See Also ======== LUdecomposition LUdecompositionFF LUsolve rr*Tc3s|]}|fVqdS)Nr4)rFr)rn pivot_colr4r5r\ sz4MatrixBase.LUdecomposition_Simple..NzRank of matrix is strictly less than number of rows or columns. Pass keyword argument rankcheck=False to compute the LU decomposition of this matrix.) rNrOrrr&_find_reasonable_pivot_naiverrRrrJ)r;rYrlrroZ pivot_rowZ iszeropivotZsub_colZpivot_row_offsetZ pivot_valueZis_assumed_non_zeroZind_simplified_pairsZcandidate_pivot_rowrrZ start_colrrr4)rnrr5rmy sJS     :B 8   z!MatrixBase.LUdecomposition_SimplecCs(ddlm}|j}|j}|j|j}}|||||}}}|||} d} xt|dD]} || | fdkrTx,t| d|D]} || | frPqWtd|| | df|| | df|| | df<|| | df<|| d| f|| d| f|| d| f<|| d| f<|| ddf|| ddf|| ddf<|| ddf<|| | f|| | f<} | | | | | f<xt| d|D]p}||| f||| f<}xDt| d|D]2}| |||f|| |f|| |||f<qWd||| f<qW| } q`W| | |d|df<||| |fS)aNCompute a fraction-free LU decomposition. Returns 4 matrices P, L, D, U such that PA = L D**-1 U. If the elements of the matrix belong to some integral domain I, then all elements of L, D and U are guaranteed to belong to I. **Reference** - W. Zhou & D.J. Jeffrey, "Fraction-free matrix factors: new forms for LU and QR factors". Frontiers in Computer Science in China, Vol 2, no. 1, pp. 67-80, 2008. See Also ======== LUdecomposition LUdecomposition_Simple LUsolve r)rkr*zMatrix is not full rankN) rrkrrrNrOrr&r)r;rkrrrrrrzrGZDDZoldpivotrqZkpivotZUkkr<ZUikrKr4r4r5LUdecompositionFF> s4   :::2zMatrixBase.LUdecompositionFFc s|j|jkrtd|jtd\}}|j}||}xDt|D]8}x2t|D]&}|||f|||fddqPWqBWxrt|dddD]^}x8t|d|D]&}|||f|||fddqW|||f||fddqW| |S) aSolve the linear system Ax = rhs for x where A = self. This is for symbolic matrices, for real or complex ones use mpmath.lu_solve or mpmath.qr_solve. See Also ======== lower_triangular_solve upper_triangular_solve gauss_jordan_solve cholesky_solve diagonal_solve LDLsolve QRsolve pinv_solve LUdecomposition z3`self` and `rhs` must have the same number of rows.)rYcs ||S)Nr4)r3y)scaler4r5r} sz$MatrixBase.LUsolve..r*rZcs ||S)Nr4)r3r)rr4r5r} scs|S)Nr4)r3re)rr4r5r} s) rNr-rmr6rMrr&Z zip_row_opZrow_oprX) r;ryrYrUrrrr<rKr4)rr5ro s"    zMatrixBase.LUsolvecCs||S)zrReturns self*b See Also ======== dot cross multiply_elementwise r4)r;rr4r4r5multiply s zMatrixBase.multiplycs:|jdkr|jdkrtd||fdd}|S)zdReturn the normalized version of ``self``. See Also ======== norm r*z'A Matrix must be a vector to normalize.cs|S)Nr4)r<)rr4r5r} sz'MatrixBase.normalized..)rNrOr-rr)r;outr4)rr5 normalized s zMatrixBase.normalizedc st|pdg}|jdks&|jdkrdks6dkrLttdd|DSdkrftdd|DStjkrtdd |DStj krt d d |DSy$t tfd d|DtdSt t fk rtd YnXnʈdkr|ttfd d tjDSdkr,t|SdkrBt |Stjkrt|ttfdd tjDSdksttrdkr|jddSt ddS)aReturn the Norm of a Matrix or Vector. In the simplest case this is the geometric size of the vector Other norms can be specified by the ord parameter ===== ============================ ========================== ord norm for matrices norm for vectors ===== ============================ ========================== None Frobenius norm 2-norm 'fro' Frobenius norm - does not exist inf maximum row sum max(abs(x)) -inf -- min(abs(x)) 1 maximum column sum as below -1 -- as below 2 2-norm (largest sing. value) as below -2 smallest singular value as below other - does not exist sum(abs(x)**ord)**(1./ord) ===== ============================ ========================== Examples ======== >>> from sympy import Matrix, Symbol, trigsimp, cos, sin, oo >>> x = Symbol('x', real=True) >>> v = Matrix([cos(x), sin(x)]) >>> trigsimp( v.norm() ) 1 >>> v.norm(10) (sin(x)**10 + cos(x)**10)**(1/10) >>> A = Matrix([[1, 1], [1, 1]]) >>> A.norm(1) # maximum sum of absolute values of A is 2 2 >>> A.norm(2) # Spectral norm (max of |Ax|/|x| under 2-vector-norm) 2 >>> A.norm(-2) # Inverse spectral norm (smallest singular value) 0 >>> A.norm() # Frobenius Norm 2 >>> A.norm(oo) # Infinity Norm 2 >>> Matrix([1, -2]).norm(oo) 2 >>> Matrix([-1, 2]).norm(-oo) 1 See Also ======== normalized rr*rENcss|]}t|dVqdS)rEN)abs)rFr<r4r4r5r\ sz"MatrixBase.norm..css|]}t|VqdS)N)r)rFr<r4r4r5r\ scSsg|] }t|qSr4)r)rFr<r4r4r5rI sz#MatrixBase.norm..cSsg|] }t|qSr4)r)rFr<r4r4r5rI sc3s|]}t|VqdS)N)r)rFr<)ordr4r5r\ sz'Expected order to be Number, Symbol, oocsg|]}t|qSr4)rr)rFr<)rr4r5rI sr csg|]}t|qSr4)rr)rFr<)rr4r5rI s)fZfroZ frobeniusZvector)rzMatrix Norms under development)rcrrNrOrrrZInfinityrZNegativeInfinityrr rr0rrrr&r rr rrr)r;rrr4)rrr5r s:4  $        zMatrixBase.normc Cspddlm}|}|}|dkrR|j|j}}td||td}||||j}||||j|||S)a; Solve Ax = B using the Moore-Penrose pseudoinverse. There may be zero, one, or infinite solutions. If one solution exists, it will be returned. If infinite solutions exist, one will be returned based on the value of arbitrary_matrix. If no solutions exist, the least-squares solution is returned. Parameters ========== B : Matrix The right hand side of the equation to be solved for. Must have the same number of rows as matrix A. arbitrary_matrix : Matrix If the system is underdetermined (e.g. A has more columns than rows), infinite solutions are possible, in terms of an arbitrary matrix. This parameter may be set to a specific matrix to use for that purpose; if so, it must be the same shape as x, with as many rows as matrix A has columns, and as many columns as matrix B. If left as None, an appropriate matrix containing dummy symbols in the form of ``wn_m`` will be used, with n and m being row and column position of each symbol. Returns ======= x : Matrix The matrix that will satisfy Ax = B. Will have as many rows as matrix A has columns, and as many columns as matrix B. Examples ======== >>> from sympy import Matrix >>> A = Matrix([[1, 2, 3], [4, 5, 6]]) >>> B = Matrix([7, 8]) >>> A.pinv_solve(B) Matrix([ [ _w0_0/6 - _w1_0/3 + _w2_0/6 - 55/18], [-_w0_0/3 + 2*_w1_0/3 - _w2_0/3 + 1/9], [ _w0_0/6 - _w1_0/3 + _w2_0/6 + 59/18]]) >>> A.pinv_solve(B, arbitrary_matrix=Matrix([0, 0, 0])) Matrix([ [-55/18], [ 1/9], [ 59/18]]) See Also ======== lower_triangular_solve upper_triangular_solve gauss_jordan_solve cholesky_solve diagonal_solve LDLsolve LUsolve QRsolve pinv Notes ===== This may return either exact solutions or least squares solutions. To determine which, check ``A * A.pinv() * B == B``. It will be True if exact solutions exist, and False if only a least-squares solution exists. Be aware that the left hand side of that equation may need to be simplified to correctly compare to the right hand side. References ========== .. [1] https://en.wikipedia.org/wiki/Moore-Penrose_pseudoinverse#Obtaining_all_solutions_of_a_linear_system r)rNz w:{0}_:{1})r) rrpinvrOr rr rXr7) r;r@Zarbitrary_matrixrrUZA_pinvrNrOwr4r4r5 pinv_solvesM zMatrixBase.pinv_solvecCsf|}|j}|jr|Sy0|j|jkr2|||S|||SWntk r`tdYnXdS)atCalculate the Moore-Penrose pseudoinverse of the matrix. The Moore-Penrose pseudoinverse exists and is unique for any matrix. If the matrix is invertible, the pseudoinverse is the same as the inverse. Examples ======== >>> from sympy import Matrix >>> Matrix([[1, 2, 3], [4, 5, 6]]).pinv() Matrix([ [-17/18, 4/9], [ -1/9, 1/9], [ 13/18, -2/9]]) See Also ======== inv pinv_solve References ========== .. [1] https://en.wikipedia.org/wiki/Moore-Penrose_pseudoinverse z.Rank-deficient matrices are not yet supported.N)rr1rNrOrbrr)r;rUZAHr4r4r5rks zMatrixBase.pinvr-cCsg}xht|jD]Z}g}x>> from sympy.matrices import Matrix, eye >>> m = Matrix(2, 3, lambda i, j: i*3+j) >>> m Matrix([ [0, 1, 2], [3, 4, 5]]) >>> m.print_nonzero() [ XX] [XXX] >>> m = eye(4) >>> m.print_nonzero("x") [x ] [ x ] [ x ] [ x] r z[%s]r[ N)r&rNrOrRrdjoinprint)r;Zsymbr'r<linerKr4r4r5 print_nonzeros zMatrixBase.print_nonzerocCs|||||S)a^Return the projection of ``self`` onto the line containing ``v``. Examples ======== >>> from sympy import Matrix, S, sqrt >>> V = Matrix([sqrt(3)/2, S.Half]) >>> x = Matrix([[1, 0]]) >>> V.project(x) Matrix([[sqrt(3)/2, 0]]) >>> V.project(-x) Matrix([[sqrt(3)/2, 0]]) )r)r;rr4r4r5rszMatrixBase.projectc Cs|j}|}|j|jks"td|j}|j}|}|d}x,t|jD]}||dkrJ|d8}qJW||jks~td| ||| |}} xt|D]} |dd| f} xNt| D]B}| |dd|f|dd| f |dd|f8} | qW| | | | f<| | | | f|dd| f<|dd| fdkrXt d| x>> from sympy import Matrix >>> A = Matrix([[12, -51, 4], [6, 167, -68], [-4, 24, -41]]) >>> Q, R = A.QRdecomposition() >>> Q Matrix([ [ 6/7, -69/175, -58/175], [ 3/7, 158/175, 6/175], [-2/7, 6/35, -33/35]]) >>> R Matrix([ [14, 21, -14], [ 0, 175, -70], [ 0, 0, 35]]) >>> A == Q*R True QR factorization of an identity matrix: >>> A = Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) >>> Q, R = A.QRdecomposition() >>> Q Matrix([ [1, 0, 0], [0, 1, 0], [0, 0, 1]]) >>> R Matrix([ [1, 0, 0], [0, 1, 0], [0, 0, 1]]) See Also ======== cholesky LDLdecomposition LUdecomposition QRsolve z/The number of rows must be greater than columnsrr*z-The rank of the matrix must match the columnsNz"Could not normalize the vector %d.) rXrrNrOr,rr&rrrrexpandr) r;rr_rrrZ row_reducedr<QrHrKtmpr4r4r5QRdecompositions8/    6  4zMatrixBase.QRdecompositionc Cs|\}}|j|}g}|j}xvt|dddD]b}||ddf}x6t|d|D]$} |||| f||d| 8}qZW|||||fq6W|ddt|DS)aSolve the linear system 'Ax = b'. 'self' is the matrix 'A', the method argument is the vector 'b'. The method returns the solution vector 'x'. If 'b' is a matrix, the system is solved for each column of 'b' and the return value is a matrix of the same shape as 'b'. This method is slower (approximately by a factor of 2) but more stable for floating-point arithmetic than the LUsolve method. However, LUsolve usually uses an exact arithmetic, so you don't need to use QRsolve. This is mainly for educational purposes and symbolic matrices, for real (or complex) matrices use mpmath.qr_solve. See Also ======== lower_triangular_solve upper_triangular_solve gauss_jordan_solve cholesky_solve diagonal_solve LDLsolve LUsolve pinv_solve QRdecomposition r*rZNcSsg|] }|jqSr4)r)rFrr4r4r5rICsz&MatrixBase.QRsolve..)rrr7rNr&rRrPr) r;rrrHrr3rrKrrqr4r4r5QRsolves $zMatrixBase.QRsolveCHcCs0|dkr||S|j}||j|d||S)aReturn the least-square fit to the data. By default the cholesky_solve routine is used (method='CH'); other methods of matrix inversion can be used. To find out which are available, see the docstring of the .inv() method. Examples ======== >>> from sympy.matrices import Matrix, ones >>> A = Matrix([1, 2, 3]) >>> B = Matrix([2, 3, 4]) >>> S = Matrix(A.row_join(B)) >>> S Matrix([ [1, 2], [2, 3], [3, 4]]) If each line of S represent coefficients of Ax + By and x and y are [2, 3] then S*xy is: >>> r = S*Matrix([2, 3]); r Matrix([ [ 8], [13], [18]]) But let's add 1 to the middle value and then solve for the least-squares value of xy: >>> xy = S.solve_least_squares(Matrix([8, 14, 18])); xy Matrix([ [ 5/3], [10/3]]) The error is given by S*xy - r: >>> S*xy - r Matrix([ [1/3], [1/3], [1/3]]) >>> _.norm().n(2) 0.58 If a different xy is used, the norm will be higher: >>> xy += ones(2, 1)/10 >>> (S*xy - r).norm().n(2) 1.5 r)rw)r|rrb)r;ryrwrr4r4r5solve_least_squaresEs6 zMatrixBase.solve_least_squaresGEcCsF|js2|j|jkrtdqB|j|jkrBtdn|j|d|SdS)zReturn solution to self*soln = rhs using given inversion method. For a list of possible inversion methods, see the .inv() docstring. z6Under-determined system. Try M.gauss_jordan_solve(rhs)z]For over-determined system, M, having more rows than columns, try M.solve_least_squares(rhs).)rwN)rrNrOrrb)r;ryrwr4r4r5solves     zMatrixBase.solve[]r, rightcCs|jdks|jdkrdSg}dg|j}xft|jD]X} |gxHt|jD]:} ||| | f} |d| tt| || || <qNWq4Wddddddd|}xVt|D]J\} } x*t| D]\} } t| ||| | | <qW|| | ||| <qW| |S)a String form of Matrix as a table. ``printer`` is the printer to use for on the elements (generally something like StrPrinter()) ``rowstart`` is the string used to start each row (by default '['). ``rowend`` is the string used to end each row (by default ']'). ``rowsep`` is the string used to separate rows (by default a newline). ``colsep`` is the string used to separate columns (by default ', '). ``align`` defines how the elements are aligned. Must be one of 'left', 'right', or 'center'. You can also use '<', '>', and '^' to mean the same thing, respectively. This is used by the string printer for Matrix. Examples ======== >>> from sympy import Matrix >>> from sympy.printing.str import StrPrinter >>> M = Matrix([[1, 2], [-33, 4]]) >>> printer = StrPrinter() >>> M.table(printer) '[ 1, 2]\n[-33, 4]' >>> print(M.table(printer)) [ 1, 2] [-33, 4] >>> print(M.table(printer, rowsep=',\n')) [ 1, 2], [-33, 4] >>> print('[%s]' % M.table(printer, rowsep=',\n')) [[ 1, 2], [-33, 4]] >>> print(M.table(printer, colsep=' ')) [ 1 2] [-33 4] >>> print(M.table(printer, align='center')) [ 1 , 2] [-33, 4] >>> print(M.table(printer, rowstart='{', rowend='}')) { 1, 2} {-33, 4} rz[]rZljustrjustcenter)leftrr<>^) rNrOr&rRZ_printrrirrTr)r;riZrowstartZrowendrgZcolsepZalignrmaxlenr<rKr'relemr4r4r5rhs,3  zMatrixBase.tablecCs:|jstd|j|jkr"td|js0td||S)aSolves Ax = B, where A is an upper triangular matrix. See Also ======== lower_triangular_solve gauss_jordan_solve cholesky_solve diagonal_solve LDLsolve LUsolve QRsolve pinv_solve zMatrix must be square.zMatrix size mismatch.zMatrix is not upper triangular.)rr.rNr0rrx)r;ryr4r4r5upper_triangular_solves z!MatrixBase.upper_triangular_solvec Csddlm}|j}||jkr$td|rD|||krDtdd}|r|||ddd}xt|D]0}x*t||D]}|||f||<|d7}q|WqlWnX|||ddd}x@t|D]4}x.t|d|D]}|||f||<|d7}qWqW|S)aReturn the unique elements of a symmetric Matrix as a one column matrix by stacking the elements in the lower triangle. Arguments: diagonal -- include the diagonal cells of self or not check_symmetry -- checks symmetry of self but not completely reliably Examples ======== >>> from sympy import Matrix >>> m=Matrix([[1, 2], [2, 3]]) >>> m Matrix([ [1, 2], [2, 3]]) >>> m.vech() Matrix([ [1], [2], [3]]) >>> m.vech(diagonal=False) Matrix([[2]]) See Also ======== vec r)rzMatrix must be squarez>Matrix appears to be asymmetric; consider check_symmetry=Falser*rE) rrrOrNr-rrvrr&) r;ZdiagonalZcheck_symmetryrrcountrrKr<r4r4r5vechs,   zMatrixBase.vech)N)F)N)N)N)r-)r)r)rrrrr)TT)Dr@rArBrCZ__array_priority__rmZ_class_priority staticmethodrrl__hash__objectrSrYrZr\r^rcr?r>rerjrrprtror|r}r~rrrrrrrrrrr6rrrrbrrrrrrrrrmrrrrrrrrrrrrrrhrrr4r4r4r5r.s    F1 +:'+ ,    @7) E C1 (  d V, "O- ;  Mr.i;z)from sympy.matrices.common import classofz1.3)rrrcCsddlm}|||S)Nr)classof)rr)rUr@Zclassof_r4r4r5r,s rz'from sympy.matrices.common import a2idx)rrrNcCsddlm}|||S)Nr)r+)rr+)rKrrr4r4r5r+4s r+c Csg}t|}tdd|Drtdd|Drdd|D}t|}||rt|dkrhddt|D}ddd |fS||}|||d |fSg}x:t|D].\}} || } | d kr|| d |fS|| qWt|rddd |fSxtt|D]h\}} ||dk rq|| } || } | d ks(| d kr6||| f| d krL|| d |fS| ||<qWt|rnddd |fSxNt|D]B\}} ||dk rqx| tj rxd ||<||tj fqxWt|rddd |fS|d}|||d |fS) a Find the lowest index of an item in `col` that is suitable for a pivot. If `col` consists only of Floats, the pivot with the largest norm is returned. Otherwise, the first element where `iszerofunc` returns False is used. If `iszerofunc` doesn't return false, items are simplified and retested until a suitable pivot is found. Returns a 4-tuple (pivot_offset, pivot_val, assumed_nonzero, newly_determined) where pivot_offset is the index of the pivot, pivot_val is the (possibly simplified) value of the pivot, assumed_nonzero is True if an assumption that the pivot was non-zero was made without being proved, and newly_determined are elements that were simplified during the process of pivot finding.css|]}t|ttfVqdS)N)rrr)rFr3r4r4r5r\Tsz)_find_reasonable_pivot..css|]}t|tVqdS)N)rr)rFr3r4r4r5r\UscSsg|] }t|qSr4)r)rFr3r4r4r5rIVsz*_find_reasonable_pivot..rcSs g|]\}}|dkr|dfqS)rr4)rFr<r3r4r4r5rI]sNFT) rcrrrrindexrRrrrJ) rrYrlrZcol_absZ max_valuerZpossible_zerosr<r3r1Zsimpedr4r4r5rb=sT            rbc Csg}xFt|D]:\}}||}|dkr2||dgfS|dkr|||fqWt|dkrddddgfS|dkr|dd|dddgfSg}xN|D]F\}}||}t|t|kr|||f||dkr||d|fSqW|dd|ddd|fS)a Helper that computes the pivot value and location from a sequence of contiguous matrix column elements. As a side effect of the pivot search, this function may simplify some of the elements of the input column. A list of these simplified entries and their indices are also returned. This function mimics the behavior of _find_reasonable_pivot(), but does less work trying to determine if an indeterminate candidate pivot simplifies to zero. This more naive approach can be much faster, with the trade-off that it may erroneously return a pivot that is zero. `col` is a sequence of contiguous column entries to be searched for a suitable pivot. `iszerofunc` is a callable that returns a Boolean that indicates if its input is zero, or None if no such determination can be made. `simpfunc` is a callable that simplifies its input. It must return its input if it does not simplify its input. Passing in `simpfunc=None` indicates that the pivot search should not attempt to simplify any candidate pivots. Returns a 4-tuple: (pivot_offset, pivot_val, assumed_nonzero, newly_determined) `pivot_offset` is the sequence index of the pivot. `pivot_val` is the value of the pivot. pivot_val and col[pivot_index] are equivalent, but will be different when col[pivot_index] was simplified during the pivot search. `assumed_nonzero` is a boolean indicating if the pivot cannot be guaranteed to be zero. If assumed_nonzero is true, then the pivot may or may not be non-zero. If assumed_nonzero is false, then the pivot is non-zero. `newly_determined` is a list of index-value pairs of pivot candidates that were simplified during the pivot search. FNrr*T)rrRriid) rrYrlZindeterminatesr<Zcol_valZcol_val_is_zerorZ tmp_col_valr4r4r5rs&+    r)N)RZ __future__rrZmpmath.libmp.libmpfrZsympy.core.addrZsympy.core.basicrZsympy.core.exprrZsympy.core.functionrZsympy.core.powerr Zsympy.core.symbolr r r r Zsympy.core.numbersrrrZsympy.core.singletonrZsympy.core.sympifyrZ(sympy.functions.elementary.miscellaneousrrrZsympy.functionsrrZ sympy.polysrrrZsympy.printingrZsympy.simplifyrrrZsympy.core.compatibilityrrr r!Zsympy.utilities.iterablesr"r#r$r%r&r'Zsympy.utilities.exceptionsr(typesr)commonr+r,r-r.r/Zsympy.core.decoratorsr0r6r7r8rDrrrr!r3r.rrbrr4r4r4r5s            (=8 1 g