~9\c@ s/ddlmZmZddlmZddlmZddlmZddl m Z ddl m Z m Z mZmZmZmZmZmZddlmZddlmZdd lmZdd lmZmZmZdd lmZdd l m!Z!dd l"m#Z#m$Z$m%Z%m&Z&ddl'm(Z(ddl)m*Z*m+Z+ddl,m-Z-m.Z.m/Z/ddl0m1Z1m2Z2m3Z3ddl4m5Z5ddl6m7Z7ddl6m8Z9ddl:m;Z;ddl<m=Z=m>Z>ddl?m@Z@mAZAmBZBmCZCdZDdZEde$e fdYZFde@fdYZGdeGfd YZHd!eHfd"YZId#eIfd$YZJd%e@fd&YZKd'e@fd(YZLd)eLeKeJe@fd*YZMed+d,d-d.d/d0d1ZNed+d,d/d0d-d2eOd3ZPeDe9d4ZQeDeOd5ZRd6S(7i(tdivisiontprint_function(t FunctionType(t prec_to_dps(tAdd(tBasic(tCallablet NotIterabletas_inttdefault_sort_keyt is_sequencetrangetreducet string_types(t deprecated(tExpr(t expand_mul(tFloattIntegert mod_inverse(tPow(tS(tDummytSymbolt_uniquely_named_symboltsymbols(tsympify(texpt factorial(tMaxtMintsqrt(tPurePolytcanceltroots(tsstr(t nsimplify(tsimplify(tSymPyDeprecationWarning(tflattentnumbered_symbolsi(t MatrixCommont MatrixErrortNonSquareMatrixErrort ShapeErrorcC st|ddS(sReturns True if x is zero.tis_zeroN(tgetattrtNone(tx((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt_iszero!scC st|dkS(sNTests by expand_mul only, suitable for polynomials and rational functions.i(R(R0((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt_is_zero_after_expand_mul&stDeferredVectorcB s)eZdZdZdZdZRS(s4A 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) cC sM|dkrd}n|dkr0tdnd|j|f}t|S(Nis!DeferredVector index out of ranges%s[%d](t IndexErrortnameR(tselftitcomponent_name((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt __getitem__<s    cC s t|S(N(R#(R6((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt__str__DscC s d|jS(NsDeferredVector('%s')(R5(R6((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt__repr__Gs(t__name__t __module__t__doc__R9R:R;(((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyR3,s  tMatrixDeterminantcB seZdZdZdZedZdZeddZ dZ ddZ d e d Zdd Zdd Zd ddZddZdZRS(sVProvides basic matrix determinant operations. Should not be instantiated directly.c  s5|jdkr7|jdkr7|jddtjgS|d|dddf}}|dddf|ddddf}}|gx0t|jdD]}j||qWgD]}| |d^qtj| gfd}|j|jd|j|}||fS(sReturn (A,T) where T the Toeplitz matrix used in the Berkowitz algorithm corresponding to ``self`` and A is the first principal submatrix.iiNic s||krtjS||S(N(RtZero(R7tj(tdiags(s6lib/python2.7/site-packages/sympy/matrices/matrices.pytentryss (ii(ii(trowstcolst_newRtOneR tappend( R6tatRtCtAR7tdRCttoeplitz((RBs6lib/python2.7/site-packages/sympy/matrices/matrices.pyt_eval_berkowitz_toeplitz_matrixOs!3 "cC s|jdkr7|jdkr7|jddtjgS|jdkrv|jdkrv|jddtj|d gS|j\}}||jS(s 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 iii(ii(RDRERFRRGROt_eval_berkowitz_vector(R6tsubmatRN((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRP{s $!c s(dfdtS(sCompute 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. ic sjdkrtjSjdkr-dStdddfd\}}dkrntjSdd}tfdtjD}ttj}j ||fd}|j jdjd|S( Niit iszerofunciic3 s!|]}|kr|VqdS(N((t.0R7(t pivot_pos(s6lib/python2.7/site-packages/sympy/matrices/matrices.pys sc sS||df|df|df}|jsOt|S|S(Nii(tis_AtomR!(R7RAtret(tcummtmatRTt pivot_valttmp_mat(s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRCs<  (ii( RDRRGt_find_reasonable_pivotR/R@tlistR REtextractRF(RXRWt_tsignRDRERC(tbareissRRR6(RWRXRTRYRZs6lib/python2.7/site-packages/sympy/matrices/matrices.pyR`s %(R!(R6RR((R`RRR6s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt_eval_det_bareisss cC s&|j}dt|d|dS(s8 Use the Berkowitz algorithm to compute the determinant.ii(RPtlen(R6t berk_vector((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt_eval_det_berkowitzs cC s|jdkrtjS|jd|dd\}}|||jd|jdfr_tjSt|drytj ntj}x+t|jD]}||||f9}qW|S(s 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.iRRtsimpfunciiN(RDRRGtLUdecomposition_SimpleR/R@RbR (R6RRRetlut row_swapstdettk((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt _eval_det_lus $#cC s |jS(suAssumed to exist by matrix expressions; If we subclass MatrixDeterminant, we can fully evaluate determinants.(Ri(R6((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt_eval_determinant st berkowitzcC s|j|jS(sReturns the adjugate, or classical adjoint, of a matrix. That is, the transpose of the matrix of cofactors. https://en.wikipedia.org/wiki/Adjugate See Also ======== cofactor_matrix transpose (tcofactor_matrixt transpose(R6tmethod((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytadjugates tlambdacC sV|jstn|j}t||}tg|D]}||^q:|S(sComputes 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 (t is_squareR+RPRR (R6R0R%RcRI((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytcharpolys 4   cC sH|j s|jdkr%tnd||d|j|||S(sCalculate the cofactor of an element. See Also ======== cofactor_matrix minor minor_submatrix iii(RsRDR+tminor(R6R7RARp((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytcofactorZs  c sJj sjdkr%tnjjjfdS(sReturn a matrix containing the cofactor of each element. See Also ======== cofactor minor minor_submatrix adjugate ic sj||S(N(Rv(R7RA(RpR6(s6lib/python2.7/site-packages/sympy/matrices/matrices.pytzt(RsRDR+RFRE(R6Rp((RpR6s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRnjs  R`cC s|j}|dkr!d}n|dkr6d}n|dddfkr^td|n|tkr|dkrt}n|dkrt}nn#t|t rtd|n|j rtn|j }|dkrt j Sno|d kr |ddfSnR|d krS|ddf|d d f|dd f|d dfSn |d kr^|ddf|d d f|d d f|dd f|d d f|d df|dd f|d df|d d f|dd f|d d f|d df|ddf|d d f|d d f|dd f|d df|d d fSn|dkr}|j d |Sn8|dkr|j Sn|dkr|jd |Snd S(sWComputes the determinant of a matrix. Parameters ========== method : string, optional Specifies the algorithm used for computing the matrix determinant. If the matrix is at most 3x3, a hard-coded formula is used and the specified method is ignored. Otherwise, it defaults to ``'bareiss'``. If it is set to ``'bareiss'``, Bareiss' fraction-free algorithm will be used. If it is set to ``'berkowitz'``, Berkowitz' algorithm will be used. Otherwise, if it is set to ``'lu'``, LU decomposition will be used. .. note:: For backward compatibility, legacy keys like "bareis" and "det_lu" can still be used to indicate the corresponding methods. And the keys are also case-insensitive for now. However, it is suggested to use the precise keys for specifying the method. iszerofunc : FunctionType or None, optional If it is set to ``None``, it will be defaulted to ``_iszero`` if the method is set to ``'bareiss'``, and ``_is_zero_after_expand_mul`` if the method is set to ``'lu'``. It can also accept any user-specified zero testing function, if it is formatted as a function which accepts a single symbolic argument and returns ``True`` if it is tested as zero and ``False`` if it tested as non-zero, and also ``None`` if it is undecidable. Returns ======= det : Basic Result of determinant. Raises ====== ValueError If unrecognized keys are given for ``method`` or ``iszerofunc``. NonSquareMatrixError If attempted to calculate determinant from a non-square matrix. tbareisR`tdet_luRgRms$Determinant method '%s' unrecognizeds%Zero testing method '%s' unrecognizediiiiRRN(tlowert ValueErrorR/R2R1t isinstanceRRsR+RDRRGRaRdRk(R6RpRRtn((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRi|s>6                 ;     cC sA|j s|jdkr%tn|j||jd|S(sReturn 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 iRp(RsRDR+tminor_submatrixRi(R6R7RARp((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRus  cC s|dkr||j7}n|dkr8||j7}nd|koR|jkn sxd|kor|jkn rtd|jd|jngt|jD]}||kr|^q}gt|jD]}||kr|^q}|j||S(sReturn the submatrix obtained by removing the `i`th row and `j`th column from ``self``. See Also ======== minor cofactor is4`i` and `j` must satisfy 0 <= i < ``self.rows`` (%d)s and 0 <= j < ``self.cols`` (%d).(RDRER|R R](R6R7RARIRDRE((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRs  @..N(R<R=R>RORPR2RaRdR1R/RkRlRqt _simplifyRtRvRnRiRuR(((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyR?Ks , , 0 /  ;  b tMatrixReductionscB seZdZdZdZdZdZdZdZdZ dZ e d Z d d Z d Ze e e d ZeeedZddddddZddddddZeedZeedZeee e dZRS(sUProvides basic matrix row/column operations. Should not be instantiated directly.c s.fd}jjj|S(Nc sB|kr|fS|kr4|fS||fS(N((R7RA(tcol1tcol2R6(s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRCs   (RFRDRE(R6RRRC((RRR6s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt_eval_col_op_swap sc s.fd}jjj|S(Nc s,|kr||fS||fS(N((R7RA(tcolRjR6(s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRCs (RFRDRE(R6RRjRC((RRjR6s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt"_eval_col_op_multiply_col_by_constsc s1fd}jjj|S(Nc s:|kr,||f|fS||fS(N((R7RA(RRRjR6(s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRCs  (RFRDRE(R6RRjRRC((RRRjR6s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt&_eval_col_op_add_multiple_to_other_colsc s.fd}jjj|S(Nc sB|kr|fS|kr4|fS||fS(N((R7RA(trow1trow2R6(s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRC%s   (RFRDRE(R6RRRC((RRR6s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt_eval_row_op_swap$sc s.fd}jjj|S(Nc s,|kr||fS||fS(N((R7RA(RjtrowR6(s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRC.s (RFRDRE(R6RRjRC((RjRR6s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt"_eval_row_op_multiply_row_by_const-sc s1fd}jjj|S(Nc s:|kr,||f|fS||fS(N((R7RA(RjRRR6(s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRC5s  (RFRDRE(R6RRjRRC((RjRRR6s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt&_eval_row_op_add_multiple_to_other_row4sc C s:|j||dtdtdt\}}}|||fS(sReturns (mat, swaps) where ``mat`` is a row-equivalent matrix in echelon form and ``swaps`` is a list of row-swaps performed.tnormalize_lastt normalizet zero_above(t _row_reducetTruetFalse(R6RRRetreducedt pivot_colstswaps((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt_eval_echelon_form;s c s|jdks|jdkr"tStfd|dddfD}|dr|o|ddddfjS|o|ddddfjS(Nic3 s|]}|VqdS(N((RStt(RR(s6lib/python2.7/site-packages/sympy/matrices/matrices.pys Gsi(ii(RDRERtallt_eval_is_echelon(R6RRt zeros_below((RRs6lib/python2.7/site-packages/sympy/matrices/matrices.pyRDs ,)cC s4|j|||dtdt\}}}||fS(NRR(RR(R6RRReRRRR((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt _eval_rrefLs  RcC s|d kr'tdj||n|dkr|d k rE|n|}|d ksc|d kr{tdj|nd|ko|jknstdj||qn|dkrt||||fjd g}t|dkrt|||fjd g}nt|dkrHtd j|n|\}}d|kon|jknstdj||nd|ko|jknstdj||qn|dkr|d kr|n|}|d kr|n|}|d ks+|d ks+|d krCtd j|n||krgtd j|nd|ko|jknstdj||nd|ko|jknstdj||qn|||||fS(sValidate the arguments for a row/column operation. ``error_str`` can be one of "row" or "col" depending on the arguments being parsed.sn->knsn<->msn->n+kmsOUnknown {} operation '{}'. Valid col operations are 'n->kn', 'n<->m', 'n->n+km'sEFor a {0} operation 'n->kn' you must provide the kwargs `{0}` and `k`is"This matrix doesn't have a {} '{}'isIFor a {0} operation 'n<->m' you must provide the kwargs `{0}1` and `{0}2`sPFor a {0} operation 'n->n+km' you must provide the kwargs `{0}`, `k`, and `{0}2`sAFor a {0} operation 'n->n+km' `{0}` and `{0}2` must be different.(sn->knsn<->msn->n+kmN(R|tformatR/REtsett differenceRb(R6topRRjRRt error_strRE((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt_normalize_op_argsRsH     $$   $   c s~fd}gtjD]}|||f^q"}gt|D]\}}|^qM}j|dd|fS(sPermute 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.c s*tfddd|fDS(Nc3 s-|]#}|dkr!dndVqdS(iiN(R/(RSte(RR(s6lib/python2.7/site-packages/sympy/matrices/matrices.pys s(tsum(R7(RRR6(s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt complexityst orientationRE(R REtsortedtpermute(R6RRRR7tcomplexRAtperm((RRR6s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt_permute_complexity_rights .%c s|j|j}t|fd}fd}fd} d\} } g} g} x| krH| |krHt|| | ||\}}}}x0|D](\}}|| 7}||| kncC s|j|||||d\}}}}}|dkrI|j||S|dkre|j||S|dkr|j|||SdS(sXPerforms 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" Rsn->knsn<->msn->n+kmN(RRRR(R6RRRjRR((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytelementary_col_ops-   cC s|j|||||d\}}}}}|dkrI|j||S|dkre|j||S|dkr|j|||SdS(s(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" Rsn->knsn<->msn->n+kmN(RRRR(R6RRRjRR((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytelementary_row_op#s-   cC s |j|S(sReturns `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(R6RR((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt is_echelonAsc C sjt|tr|nt}|jdks9|jdkr=dS|jdks[|jdkrg|D]}||^qb}t|krdSn|jdkr'|jdkr'g|D]}||^q}t|krd|krdS|j}||rt|krdS||tkr'dSn|jd|\}}|j d|d|\} } } t | S(s 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 iiiRRReN( R}RRRDRERR/RiRRRb( R6RRR%ReR0tzerosRiRXR^RRR((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytrankIs(   !cC sXt|tr|nt}|jd|d|d|\}}|rT||f}n|S(s-Return 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) RRReR(R}RRR(R6RRR%RRReRVR((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytrrefps3N(R<R=R>RRRRRRRRRRRRRR1RRR/RRtpropertyRRR(((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyR s*       1 a 'tMatrixSubspacescB sDeZdZedZeedZedZedZ RS(smProvides methods relating to the fundamental subspaces of a matrix. Should not be instantiated directly.cC s>|jd|dt\}}g|D]}|j|^q%S(sReturns 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 R%R(RRR(R6R%RRR7((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt columnspacesc C s|jd|d|\}}gt|jD]}||kr.|^q.}g}xr|D]j}tjg|j} tj| |>> 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 RRR%i( RR RERR@RGRRHRF( R6R%RRRRR7t free_varstbasistfree_vartvecRRR((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt nullspaces.  cC sJ|jd|dt\}}gtt|D]}|j|^q1S(s>Returns a list of vectors that span the row space of ``self``.R%R(RRR RbR(R6R%RRR7((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytrowspacesc s|jdt}dfd}g}t|}x*t|dkrh|djrh|d=q?Wx6|D].}|||}|jsp|j|qpqpW|rg|D]}||j^q}n|S(sApply the Gram-Schmidt orthogonalization procedure to vectors supplied in ``vecs``. Parameters ========== vecs vectors to be made orthogonal normalize : bool If true, return an orthonormal basis. RcS s||j||j|S(N(tdot(RIR((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytprojectsc sLg|D]}||^q}t|dkr8|S|td|S(sRprojects vec onto the subspace given by the orthogonal basis ``basis``icS s||S(N((RIR((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRwRx(RbR (RRRt components(R(s6lib/python2.7/site-packages/sympy/matrices/matrices.pytperp_to_subspaces"i(tgetRR\RbR-RHtnorm(tclstvecstkwargsRRRVRtperp((Rs6lib/python2.7/site-packages/sympy/matrices/matrices.pyt orthogonalizes  "   &( R<R=R>RRR1RRt classmethodR(((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRs  * t MatrixEigencB seZdZedZedZeeedZedZ ee dZ edZ edZ dZd ZRS( s\Provides basic matrix eigenvalue/vector operations. Should not be instantiated directly.cC s#tddddddjdS(Ntfeaturet_cache_is_diagonalizabletdeprecated_since_versions1.4tissuei>(R&twarnR/(R6((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyR4s  cC s#tddddddjdS(NRt_cache_eigenvectsRs1.4Ri>(R&RR/(R6((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyR=s  c C s|jstn|jd|s6tdn|jdt}|rct|dt}ngg}}x2|D]*\}}} ||g|7}|| 7}qwW|rg|D]} | | j^q}n|j ||j |fS(s> 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 t reals_onlysMatrix is not diagonalizableR%tkey( RsR+tis_diagonalizableR*t eigenvectsRRR Rthstacktdiag( R6RtsortRt eigenvecstp_colsRRtmultRtv((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt diagonalizeFs2   &c  s'|jdt|jdt}|jdt}|}|sFiS|ra|jd}n|jss|jr|jstngt |j D]}|||f^q}|r|}qpi}x|D]/} | |krd|| s N(RRtpopRt applyfunctis_uppertis_lowerRsR+R RDR/R}RR"RtRtdictRtvaluesRbRER*RRtitems( R6terror_when_incompletetflagsRRRXR7tdiagonal_entriesteigstdiagonal_entryR((R%s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt eigenvalssD?  ,    *!6 c sddlm}|jdtttsIr=tndn|jdt}|jdt}|jdd j t }|rj dnfd}j d td ||} gt| jd tD]!\} } | | || f^q} |rifd } g| D]$\} } }| | | |f^q<} n|rg| D]I\} } }| jd|| g|D]}|jd|^qf^qv} n| S(s\Return list of triples (eigenval, multiplicity, eigenspace). Parameters ========== error_when_incomplete : bool, optional Raise an error when not all eigenvalues are computed. This is caused by ``roots`` not returning a full list of eigenvalues. iszerofunc : function, optional Specifies a zero testing function to be used in ``rref``. Default value is ``_iszero``, which uses SymPy's naive and fast default assumption handler. It can also accept any user-specified zero testing function, if it is formatted as a function which accepts a single symbolic argument and returns ``True`` if it is tested as zero and ``False`` if it is tested as non-zero, and ``None`` if it is undecidable. simplify : bool or function, optional If ``True``, ``as_content_primitive()`` will be used to tidy up normalization artifacts. It will also be used by the ``nullspace`` routine. chop : bool or positive number, optional 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. The ``chop`` flag is passed to ``evalf``. When ``chop=True`` a default precision will be used; a number will be interpreted as the desired level of precision. Returns ======= ret : [(eigenval, multiplicity, eigenspace), ...] A ragged list containing tuples of data obtained by ``eigenvals`` and ``nullspace``. ``eigenspace`` is a list containing the ``eigenvector`` for each eigenvalue. ``eigenvector`` is a vector in the form of a ``Matrix``. e.g. a vector of length 3 is returned as ``Matrix([a_1, a_2, a_3])``. Raises ====== NotImplementedError If failed to compute nullspace. See Also ======== eigenvals MatrixSubspaces.nullspace i(teyeR%cS s|S(N((R0((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRw>RxtchopRcS st|dtS(NR(R$R(R0((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRwHRxc sjj|}|jd}t|dkr_r_|jddt}nt|dkrtd|n|S(s:Get a basis for the eigenspace for a particular eigenvalueRRiR%s,Can't evaluate eigenvector for eigenvalue %s(RRDRRbRtNotImplementedError(teigenvaltmRV(RRRXR6R%(s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt eigenspaceJsRRRc s@ddlm}g|D]%}||t|j^qS(Ni(tgcd(tsympyRR\R(tlRR(Re(s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt denom_clean`sN(tsympy.matricesRRRR}RRRRR/RRRRRRR tevalf(R6RRRRRt primitiveRt has_floatsRRRRRVRtesR((RRRXR6ReR%s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRs.: =4YcK sd|kr.tddddddjnd|kr\tddddddjn|jsitStd|Dr|jrtS|jd t}t}xK|D]C\}}}|r|j rt}n|t |krt}qqW|S( slReturns 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 t clear_cacheRRgffffff?Ri>tclear_subproductscs s|]}|jVqdS(N(tis_real(RSR((s6lib/python2.7/site-packages/sympy/matrices/matrices.pys sR%( R&RRsRRt is_symmetricRRRRb(R6RRRRVRRR((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRis,2   "  c s jstdn|jdtjtrytdjD}Wntk r{d}nXtt |dnfd}ifdfd}d }fd }r j d nj }t d |j DjkrRtd jnt|jjkrtt|jdt} j| } |s|| Sg| D]djd^q} j| } || | Sg} xt|jdtD]|}||}||}gt|D]\}}|d|f^qI}|j| jfd|DqWt d| D}|jkrtdjnfd| D} j| } |s|| Sg} xt|jdtD]g}x| D]\}}|krXq:n|j}|dj}||||}gt|D]}||^q}|j|| jt|q:Wq'Wj| } || | S(sReturn ``(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 s&Only square matrices have Jordan formsRcs s'|]}t|tr|jVqdS(N(R}Rt_prec(RStterm((s6lib/python2.7/site-packages/sympy/matrices/matrices.pys si5ic sRr4g|D]}|jdd^q }nt|dkrN|dS|S(sQIf ``has_floats`` is `True`, cast all ``args`` as matrices of floats.tprecRii(R Rb(targsR(RR tmax_dps(s6lib/python2.7/site-packages/sympy/matrices/matrices.pytrestore_floatss .c s||fkr ||fS||dfkre||df|df||fCss$Could not compute eigenvalues for {}Riic3 s4|]*\}}t|D]}|fVqqdS(N(R (RStsizetnumR^(teig(s6lib/python2.7/site-packages/sympy/matrices/matrices.pys `scs s|]\}}|VqdS(N((RSR&R$((s6lib/python2.7/site-packages/sympy/matrices/matrices.pys bssOSymPy had encountered an inconsistent result while computing Jordan block. : {}c3 s-|]#\}}jd|d|VqdS(R$t eigenvalueN(t jordan_block(RSR&R$(RX(s6lib/python2.7/site-packages/sympy/matrices/matrices.pys is(RsR+RRRRtmaxt_matR|RRRRRRER*RRbtkeysR\RR RRRRtreversetextendRDR treversed(R6tcalc_transformRtmax_precRRR R#Rtblockst jordan_matt jordan_basist basis_mattblock_structureRtchaint block_sizesR7R%t size_numstjordan_form_sizet eig_basist block_eigR$tnull_bigt null_smallRtnew_vecs((RR&RR RXRRR6s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt jordan_forms|$        % ,   /   , cK sW|jj|}g|D]7\}}}||g|D]}|j^q8f^qS(s#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]])])] (RoR(R6RRRRRR((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytleft_eigenvectsscC s|}|j|jkr.|j|j}n||jj}g}x1|jD]#\}}|t|g|7}qTWt||jkr|tjg|jt|7}n|j dt dt |S(s_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 R,R( RDREtHRRRRbRR@RRR (R6RXt valmultpairstvalsRjR((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytsingular_valuess$(R<R=R>RRRRRRRR1RRR?R@RD(((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyR0s  G si R !tMatrixCalculuscB sVeZdZdZdZdZdZdZdZdZ dZ RS( s,Provides calculus-related matrix operations.cO sVddlm}|jdt||dt|}t|tsN|jS|SdS(sCalculate 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 i(t DerivativetevaluateN(RRFt setdefaultRR}Rt as_mutable(R6RRRFtderiv((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytdiffs  c s|jfdS(Nc s |jS(N(RK(R0(targ(s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRwRx(R(R6RL((RLs6lib/python2.7/site-packages/sympy/matrices/matrices.pyt_eval_derivativescC s |j|S(N(t_visit_eval_derivative_array(R6ts((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt_accept_eval_derivativesc s|jfdS(Nc s j|S(N(RK(R0(tbase(s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRwRx(R(R6RQ((RQs6lib/python2.7/site-packages/sympy/matrices/matrices.pyt_visit_eval_derivative_scalarscC sddlm}|||S(Ni(tderive_by_array(RRS(R6RQRS((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRNsc s|jfdS(sIntegrate 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 c s |jS(N(t integrate(R0(R(s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRw"Rx(R(R6R((Rs6lib/python2.7/site-packages/sympy/matrices/matrices.pyRT sc stts!jnjddkrDjd}n/jddkrgjd}n tdjddkrjd}n/jddkrjd}n tdj||fdS(sCalculates 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 iis)``self`` must be a row or a column matrixs"X must be a row or a column matrixc s|j|S(N(RK(RAR7(tXR6(s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRw[Rx(R}t MatrixBaseRFtshapet TypeError(R6RURR~((RUR6s6lib/python2.7/site-packages/sympy/matrices/matrices.pytjacobian$s$  c s|jfdS(sCalculate 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 c s |jS(N(tlimit(R0(R(s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRwrRx(R(R6R((Rs6lib/python2.7/site-packages/sympy/matrices/matrices.pyRZ]s( R<R=R>RKRMRPRRRNRTRYRZ(((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyREs       9tMatrixDeprecatedcB seZdZdZededZdZdZdZ dZ dd Z d Z d Z d Zd ZedZddZdZdZdZRS(s+A class to house deprecated matrix methods.cC s]ddlm}t|tst|rt||jkrwt||jkrwtd|j t|fn|j ||St dt |n|}|j|jkr|jdkr|j }|j }nt||j}|S|j|jkr|j |j S|j|jkr=|j j |Std|j |j fdS(sQCompatibility function for deprecated behavior of ``matrix.dot(vector)`` i(tMatrixs,Dimensions incorrect for dot product: %s, %ss2`b` must be an ordered iterable or Matrix, not %s.N(tdenseR\R}RVR RbRERDR,RWRRXttypetTR'ttolist(R6RR\RXtprod((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt_legacy_array_dotxs0 *  RrcC s|jd|S(NR0(Rt(R6R0R%((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytberkowitz_charpolyscC s|jddS(swComputes determinant using Berkowitz method. See Also ======== det berkowitz RpRm(Ri(R6((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt berkowitz_dets cK s |j|S(swComputes eigenvalues of a Matrix using Berkowitz method. See Also ======== berkowitz (R(R6R((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytberkowitz_eigenvalsscC sMtjg}}x0|jD]"}|j||d| }qWt|S(spComputes principal minors using Berkowitz method. See Also ======== berkowitz i(RRGRmRHR(R6R_tminorstpoly((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytberkowitz_minorss  cC sddlm}d}|s |S|js5tn||j}}dg|d}xYt|ddD]E}||d||d}}||d|f |d||f} } |d|d|f|||f }} | g} x0td|dD]} | j|| | qWx,t| D]\} }| |d| | RbRRRcRdReRhRmRoRpRqRrRsRRxRyRzR~R(((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyR[vs" !  (         RVcB seZdZdZeZdZeeZ dBZ dZ e Z edZdZdZdZdZd Zd Zd Zd ZdBd ZedZdZdZdZedZdZdZ dZ!e"dZ#dZ$dBdBdZ%dZ&dZ'e(dZ)dZ*e+dZ,e+dZ-e+dZ.dBd Z/d!Z0d"Z1d#Z2ed$Z3d%Z4d&Z5e+dBe(d'Z6e+dBe(d(Z7d)Z8e+d*Z9d+Z:e+d,Z;dBd-Z<dBd.Z=d/Z>d0d1Z?d2Z@d3ZAd4ZBe+e(d5ZCd6d7ZDd8d9ZEd:d;d<d=d>d?ZFd@ZGeedAZHRS(CsBase class for matrix objects.i icC s*ddlm}||dd}d|S(s^ IPython/Jupyter LaTeX printing To change the behavior of this (e.g., pass in some settings to LaTeX), use init_printing(). init_printing() will also enable LaTeX printing for built in numeric types like ints and container types that contain SymPy objects, like lists and dictionaries of expressions. i(tlatextmodetplains$\displaystyle %s$(tsympy.printing.latexR(R6RRO((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt _repr_latex_As cC s ddlm}||d|S(Ni(t matrix2numpytdtype(R]R(R6RR((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt __array__Psc sBdkr"fd}|StdjjfdS(NRKRTRZc sfd}j|S(Nc st|S(N(R.(titem(Rtattr(s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRwWRx(R(Rt item_doit(RR6(Rs6lib/python2.7/site-packages/sympy/matrices/matrices.pytdoitVss%s has no attribute %s.(RKRTRZ(tAttributeErrort __class__R<(R6RR((RR6s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt __getattr__Ts  cC s|j|jS(skReturn the number of elements of ``self``. Implemented mainly so bool(Matrix()) == False. (RDRE(R6((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt__len___scC std}x_t|jD]N}|d7}x1t|jD] }||||fj7}q6W|d7}qWd|dS(NRxs s ss (R RDREt __mathml__(R6tmmlR7RA((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRfs cC s ||k S(N((R6tother((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt__ne__psc  sddlm}m}ddlmfd}|j\}}|j}g|D]}||^qZ}x|D]}|||qyW|j||||jS(Ni(Rt MutableMatrix(tbinomialc s|jd}|d}|dkrH||dktkrHtdn7|dkr|dkr|ddkrtdnx|t|D]n}xet||D]S}||}t|r|j}n||||||||f>> 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]]) i(t SparseMatrixiiRis&SymPy supports just 1D and 2D matricess Got rows of variable lengths: %sis@Cannot create a {} x {} matrix. Both dimensions must be positives+List length should be equal to rows*columnssData type not understoodN(%tsympy.matrices.sparseRR/RbR}RDRER'R`RVR*Rt is_Matrixt as_explicitthasattrRRWtravelt_sympifyRR@R RR R3RR-taddRHRXR|RR\RRRR(RRRRt flat_listtarrRDRER7tin_mattncolRRAR((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt_handle_creation_inputss++" ((      ", % H"  (   cC sddlm}t|t}|j|\}}}t|t}t|tkskt|tkr|r|j||dSt|t rt |r|j ||dSt d|n| rt|t  rt |r||}t }n|r~|r?tt||jtt||jf}n,t|||jt|||jf}|j||n|||j|fSdSdS(smHelper 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]]) i(R\Nsunexpected value: %s(R]R\R}tslicetkey2ijRVR^t copyin_matrixRR t copyin_listR|RRtdivmodRERDR(R6RRR\tis_sliceR7RAtis_mat((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt_setitem9 s2($  cC s||S(sReturn self + b ((R6R((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyR scC st}|jr-t}|jd|}ne|jrK|jd|}nG|j|jkr|j|jd|}|j|}n td|j |}|r|jj |S|j j |SdS(sSolves ``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 t hermitians6Under-determined System. Try M.gauss_jordan_solve(rhs)N( RRRt _choleskyt is_hermitianRDRERARt_lower_triangular_solvet_upper_triangular_solveR_(R6trhsRtLtY((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytcholesky_solve s   cC sj|jstdn|r7|j r7tdn| rZ|j rZtdn|jd|S(swReturns the Cholesky-type decomposition L of a matrix A such that L * L.H == A if hermitian flag is True, or L * L.T == A if hermitian is False. A must be a Hermitian positive-definite matrix if hermitian is True, or a symmetric matrix if it is False. 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]]) Non-hermitian Cholesky-type decomposition may be useful when the matrix is not positive-definite. >>> A = Matrix([[1, 2], [2, 1]]) >>> L = A.cholesky(hermitian=False) >>> L Matrix([ [1, 0], [2, sqrt(3)*I]]) >>> L*L.T == A True See Also ======== LDLdecomposition LUdecomposition QRdecomposition sMatrix must be square.sMatrix must be Hermitian.sMatrix must be symmetric.R(RsR+RR|RR(R6R((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytcholesky s9 cC s-|s tjS|j}t|t|S(s{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 (RR@RDRR(R6tsingularvalues((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytcondition_number s cC s|j|j|j|jS(s 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]]) (RFRDRER*(R6((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytcopy sc C st|s%tdt|n|j|j|j|jkoPdknstd|j|jf|j|jffnv|j|j|j|d|d|d|d|d|d|d|d|d|d|d|dfSdS(s Return the cross product of ``self`` and ``b`` relaxing the condition of compatible dimensions: if each has 3 elements, a matrix of the same type and shape as ``self`` will be returned. If ``b`` has the same shape as ``self`` then common identities for the cross product (like `a \times b = - b \times a`) will hold. Parameters ========== b : 3x1 or 1x3 Matrix See Also ======== dot multiply multiply_elementwise s2`b` must be an ordered iterable or Matrix, not %s.is/Dimensions incorrect for cross product: %s x %siiiN(R RXR^RDRER,RF(R6R((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytcross s 0+cC s9ddlm}|jdkr(tn|j|dS(soReturn Dirac conjugate (if ``self.rows == 4``). Examples ======== >>> 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 i(tmgammaii(tsympy.physics.matricesRRDRRA(R6R((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytD0 s" cC sI|jstdn|j|jkr<tdn|j|S(sSolves ``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 sMatrix should be diagonalsSize mis-match(t is_diagonalRXRDt_diagonal_solve(R6R((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytdiagonal_solve[ s  c C s)ddlm}t|tst|rt||jkrwt||jkrwtd|j t|fn|j ||St dt |n|}d|j ksd|j krt ddddd d d d j|j|St|t|kr0td|j |j fnt|}|j d|fkrf|jd|}n|j |dfkr|j|d}n|dk r|dkrt}n|r|dkrd }n|tkr|dkr|j}q|dkr|j}qtdn||dS(s4Return the dot or inner product of two vectors of equal length. Here ``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. By default, ``dot`` does not conjugate ``self`` or ``b``, even if there are complex entries. Set ``hermitian=True`` (and optionally a ``conjugate_convention``) to compute the hermitian inner product. Possible kwargs are ``hermitian`` and ``conjugate_convention``. If ``conjugate_convention`` is ``"left"``, ``"math"`` or ``"maths"``, the conjugate of the first vector (``self``) is used. If ``"right"`` or ``"physics"`` is specified, the conjugate of the second vector ``b`` is used. 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 >>> from sympy import I >>> q = Matrix([1*I, 1*I, 1*I]) >>> q.dot(q, hermitian=False) -3 >>> q.dot(q, hermitian=True) 3 >>> q1 = Matrix([1, 1, 1*I]) >>> q.dot(q1, hermitian=True, conjugate_convention="maths") 1 - 2*I >>> q.dot(q1, hermitian=True, conjugate_convention="physics") 1 + 2*I See Also ======== cross multiply multiply_elementwise i(R\s,Dimensions incorrect for dot product: %s, %ss2`b` must be an ordered iterable or Matrix, not %s.Rs%Dot product of non row/column vectorsRi5Rs1.2t useinsteads* to take matrix productstmathstlefttmathtphysicstrightsUnknown conjugate_convention was entered. conjugate_convention must be one of the following: math, maths, left, physics or right.iN(RRR(RR(R]R\R}RVR RbRERDR,RWRRXR^R&RRbtreshapeR/Rt conjugateR|(R6RRtconjugate_conventionR\RXR~((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRz sJ4 *         c C sddlm}ddlm}|ddddf|j}}||}|jrb|Sxtd|D]}xtd|D]n}d}x>td|D]-} ||||d| |d| f7}qW||||f<| |||ftd|D]-} ||d| | | || | f7}q@Wq*W|d}| |d| f<||| df0 sN(RsR+R?RtR*RR\RiR RRRRRRR^( R6RvRwtcellsRR1RRteJRV((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyR s$      c sddlm}m}|j|j|j}|j}|ddd| fj\}|jdt\}} |ddd| f|dd| df}} t t fd| } t | } |t j } x*t| D]\} }| j| |qW| | dddfjsPtdn| t | }td|dd j}t|}|gt | |D]}t|^qj| |}|d| ddf}x!t| D]}|j|qW| d| ddf}|j||||}||}x>t D]0}||ddf|| |ddf>> 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]]) >>> taus_zeroes = { tau:0 for tau in params } >>> sol_unique = sol.xreplace(taus_zeroes) >>> sol_unique Matrix([ [2], [0], [5], [0]]) >>> 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, []) >>> A = Matrix([[2, -7], [-1, 4]]) >>> B = Matrix([[-21, 3], [12, -2]]) >>> sol, params = A.gauss_jordan_solve(B) >>> sol Matrix([ [0, -2], [3, -1]]) >>> params Matrix(0, 2, []) See Also ======== lower_triangular_solve upper_triangular_solve cholesky_solve diagonal_solve LDLsolve LUsolve QRsolve pinv References ========== .. [1] https://en.wikipedia.org/wiki/Gaussian_elimination i(R\RNR%c s |kS(N((R(R(s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRw RxsLinear system has no solutionttautcomparecS st|jdS(Nt 1234567890(Rtrstrip(R7((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRw Rx(R R\RRRRERWRRR\tfilterRbR R_Rtcol_swapR-R|RR5R(tnextRR.tcol_deltvstack(R6RmtfreevarR\RtaugtB_colsRRLRRRt permutationR7tctfree_var_indexR5tgenRjRtVtvttfree_soltsol((Rs6lib/python2.7/site-packages/sympy/matrices/matrices.pytgauss_jordan_solve5 s>f &;    3. c C s|jstn|j}|j}d}yt||}Wn!tk rftd|nX|j}|j||gt |D]1}t |D]}||||f|^qq}|S(st 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]]) s!Matrix is not invertible (mod %d)N( RsR+RERiR/RR|RqRR ( R6RRktdet_Ktdet_invtK_adjR7RAtK_inv((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytinv_mod s       4c s|jstdn|jdd}|jd}|dkr|jdtdtfdtj D}n|rt dn|j |S( sCalculates the inverse using the adjugate matrix and a determinant. See Also ======== inv inverse_LU inverse_GE s"A Matrix must be square to invert.RpRmiR%c3 s%|]}||fVqdS(N((RSRA(RRtok(s6lib/python2.7/site-packages/sympy/matrices/matrices.pys  ss Matrix det == 0; not invertible.N( RsR+RitequalsR/RRtanyR RDR|Rq(R6RRRMtzero((RRRs6lib/python2.7/site-packages/sympy/matrices/matrices.pyt inverse_ADJ s  +c sddlm}|js(tdn|j|j|j|j}|jddt dt fdt jDrt dn|j d d |jd fS( sCalculates the inverse using Gaussian elimination. See Also ======== inv inverse_LU inverse_ADJ i(R\s"A Matrix must be square to invert.RRR%ic3 s%|]}||fVqdS(N((RSRA(RRtred(s6lib/python2.7/site-packages/sympy/matrices/matrices.pys $ ss Matrix det == 0; not invertible.N(R]R\RsR+RRIRRDRRRR R|RF(R6RRR\tbig((RRRs6lib/python2.7/site-packages/sympy/matrices/matrices.pyt inverse_GE s  $(c s|jstn|jdtdtfdtjDrbtdn|j|j |jdt S(sCalculates the inverse using LU decomposition. See Also ======== inv inverse_GE inverse_ADJ R%ic3 s%|]}||fVqdS(N((RSRA(RRR(s6lib/python2.7/site-packages/sympy/matrices/matrices.pys 7 ss Matrix det == 0; not invertible.RR( RsR+RRRR RDR|tLUsolveRR1(R6RR((RRRs6lib/python2.7/site-packages/sympy/matrices/matrices.pyt inverse_LU) s  (cK s;|jstn|dk r.||d>> 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 s,Nilpotency is valid only for square matricesR0i(RRsR+RRtRRDR(R6R0R((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt is_nilpotent| s  c C sddlm}g|D]}t|t^q\}}|rw|jsTd}}q|dj|jd \}}n ||d|j}|d}|r|jsd}} q|dj|jd \}} n ||d|j}|d} |||| fS(sConverts 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 i(ta2idxiii(tsympy.matrices.commonR R}RRDtindicesRE( R6R+ta2idx_Rjtislicetjslicetrlotrhitclotchi((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt key2bounds s (  #   # cC sddlm}t|rt|dks=tdngt||jD]0\}}t|tsz|||n|^qPSt|tr|j t|d St ||t||j SdS(sConverts key into canonical form, converting integers or indexable items into valid integers for ``self``'s range or returning slices unchanged. See Also ======== key2bounds i(R is"key must be a sequence of length 2N( R R R RbRXtzipRWR}RRRRE(R6RRR7R~((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyR s  DcC sj|jstdn|r7|j r7tdn| rZ|j rZtdn|jd|S(sReturns the LDL Decomposition (L, D) of matrix A, such that L * D * L.H == A if hermitian flag is True, or L * D * L.T == A if hermitian is False. 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 if hermitian is True, or a symmetric matrix otherwise. 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 sMatrix must be square.sMatrix must be Hermitian.sMatrix must be symmetric.R(RsR+RR|Rt_LDLdecomposition(R6R((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytLDLdecomposition s3 cC st}|jr3t}|jd|\}}nq|jrW|jd|\}}nM|j|jkr|j|jd|\}}|j|}n td|j |}|j |}|r|jj |S|j j |SdS(sSolves ``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 Rs6Under-determined System. Try M.gauss_jordan_solve(rhs)N( RRRRRRDRERARRRRR_(R6RRRRRtZ((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytLDLsolve s   cC s^|jstdn|j|jkr9tdn|jsQtdn|j|S(sSolves ``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 sMatrix must be square.sMatrices size mismatch.s Matrix must be lower triangular.(RsR+RDR,RR|R(R6R((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytlower_triangular_solve9 s  c  s|jd|d|d|\}fd}fd}|jjj|}|jjj|}|||fS(sReturns (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 RRRet rankcheckc sJ||krtjS||kr&tjS|jkrC||fStjS(N(RR@RGRE(R7RA(tcombined(s6lib/python2.7/site-packages/sympy/matrices/matrices.pytentry_L s  c s!||krtjS||fS(N(RR@(R7RA(R(s6lib/python2.7/site-packages/sympy/matrices/matrices.pytentry_U s(RfRFRDRE( R6RRReRRRR RtU((Rs6lib/python2.7/site-packages/sympy/matrices/matrices.pytLUdecompositionQ s'  c s|r n|jdks'|jdkrC|j|j|jgfS|jg}dxtdjdD]}t}x{|jkr|rfdt||jD}t|||\}} } } | dk}|rd7qqW|r|krtdn|dkr/dn||} | dkrU|rU|fSx(| D] \} }||| f 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 iic3 s|]}|fVqdS(N((RStr(Rgt pivot_col(s6lib/python2.7/site-packages/sympy/matrices/matrices.pys ssRank of matrix is strictly less than number of rows or columns. Pass keyword argument rankcheck=False to compute the LU decomposition of this matrix.N( RDRERRIR Rt_find_reasonable_pivot_naiveR/R|RHRR@R(R6RRReRRht pivot_rowt iszeropivottsub_coltpivot_row_offsett pivot_valuetis_assumed_non_zerotind_simplified_pairstcandidate_pivot_rowRRt start_colRR((RgR$s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRf sTS  %   M\ (>  9cC sddlm}|j}|j}|j|j}}|j||||}}}|||} d} x,t|dD]} || | fdkrx;t| d|D]} || | frPqqWtd|| | df|| | df|| | df<|| | df<|| d| f|| d| f|| d| f<|| d| f<|| ddf|| ddf|| ddf<|| ddf>> 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 iiics s|]}t|dVqdS(iN(tabs(RSR7((s6lib/python2.7/site-packages/sympy/matrices/matrices.pys 9scs s|]}t|VqdS(N(R=(RSR7((s6lib/python2.7/site-packages/sympy/matrices/matrices.pys <sc3 s|]}t|VqdS(N(R=(RSR7(tord(s6lib/python2.7/site-packages/sympy/matrices/matrices.pys Gss'Expected order to be Number, Symbol, ooitftfrot frobeniustvectorR>sMatrix Norms under developmentN(R?R@RARB(R\RRDRER/RRRtInfinityRR=tNegativeInfinityRRRRXR|RR RRRDRR}R R{RR(R6R>RCR7R((R>s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRs:4 ##1 5  5 c C sddlm}|}|j}|dkrz|j|j}}tdj||dt}|j|||j }n||||j|||S(sC 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 i(Rs w:{0}_:{1}RN( R RtpinvR/RERRRRR_( R6Rmtarbitrary_matrixRRLtA_pinvRDREtw((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt pinv_solvefsM  cC s&|}|j}|jr|Sy:|j|jkrC||j|S|||jSWntk rinXy|j|jkr||jdt\}}|jd}|||j|S||jdt\}}|jd}||||jSWnt k r!t dnXdS(stCalculate 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 RcS st|rdSd|S(Nii(R1(R0((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRwRxcS st|rdSd|S(Nii(R1(R0((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRwRxs[pinv for rank-deficient matrices where diagonalization of A.H*A fails is not supported yet.N( RAR-RDRERR|RRRR*R(R6RLtAHRvRtD_pinv((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyREs(    RUcC sg}xt|jD]y}g}xPt|jD]?}|||fdkr^|jdq2|jt|q2W|jddj|qWtdj|dS(sShows location of non-zero entries for fast shape lookup. Examples ======== >>> 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] it s[%s]Rxs N(R RDRERHRtjointprint(R6tsymbROR7tlineRA((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyt print_nonzeroscC s||j||j|S(s^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(R6R((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRsc C s||j}|j}|j}|j}t}||krj|}|}|j|j|||}n|}|j|||j|}}x t|D]} |dd| f} xt| D]q} |dd| fj|dd| f|| | f<| |dd| f|| | f8} | j qW| j || | f<|| | fj s|j | | || | f|dd| f>> 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 Nii(RRIRDRER\tcol_joinRR RtexpandRR-RHRbR]R( R6RRXR~RtrankedtnOrigtQRJRAttmpR7((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytQRdecomposition&s8/      ""9( +"*c C s|jj\}}|j|}g}|j}xt|dddD]y}||ddf}x?t|d|D]*} |||| f||d| 8}q{W|j||||fqKW|jgt|D]} | j^qS(sSolve 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 iiN( RIRXR_RDR RHRFR.R*( R6RRVRJR5R0R~RARWRjR((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytQRsolves  (cC sq|jd|d|dt\}}t|}|jt|j|}|d|ddf}||fS(sReturns a pair of matrices (`C`, `F`) with matching rank such that `A = C F`. Parameters ========== iszerofunc : Function, optional A function used for detecting whether an element can act as a pivot. ``lambda x: x.is_zero`` is used by default. simplify : Bool or Function, optional A function used to simplify elements when looking for a pivot. By default SymPy's ``simplify`` is used. Returns ======= (C, F) : Matrices `C` and `F` are full-rank matrices with rank as same as `A`, whose product gives `A`. See Notes for additional mathematical details. Examples ======== >>> from sympy.matrices import Matrix >>> A = Matrix([ ... [1, 3, 1, 4], ... [2, 7, 3, 9], ... [1, 5, 3, 1], ... [1, 2, 0, 8] ... ]) >>> C, F = A.rank_decomposition() >>> C Matrix([ [1, 3, 4], [2, 7, 9], [1, 5, 1], [1, 2, 8]]) >>> F Matrix([ [1, 0, -2, 0], [0, 1, 1, 0], [0, 0, 0, 1]]) >>> C * F == A True Notes ===== Obtaining `F`, an RREF of `A`, is equivalent to creating a product .. math:: E_n E_{n-1} ... E_1 A = F where `E_n, E_{n-1}, ... , E_1` are the elimination matrices or permutation matrices equivalent to each row-reduction step. The inverse of the same product of elimination matrices gives `C`: .. math:: C = (E_n E_{n-1} ... E_1)^{-1} It is not necessary, however, to actually compute the inverse: the columns of `C` are those from the original matrix with the same column indices as the indices of the pivot columns of `F`. References ========== .. [1] https://en.wikipedia.org/wiki/Rank_factorization .. [2] Piziak, R.; Odell, P. L. (1 June 1999). "Full Rank Factorization of Matrices". Mathematics Magazine. 72 (3): 193. doi:10.2307/2690882 See Also ======== rref R%RRRN(RRRbR]R RD(R6RRR%tFRRRK((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytrank_decompositions U  tCHcC s|dkr|j|S|dkr2|j|S|dkrK|j|S|dkrd|j|S|j}||j||d|SdS(sReturn the least-square fit to the data. Parameters ========== rhs : Matrix Vector representing the right hand side of the linear equation. method : string or boolean, optional If set to ``'CH'``, ``cholesky_solve`` routine will be used. If set to ``'LDL'``, ``LDLsolve`` routine will be used. If set to ``'QR'``, ``QRsolve`` routine will be used. If set to ``'PINV'``, ``pinv_solve`` routine will be used. Otherwise, the conjugate of ``self`` will be used to create a system of equations that is passed to ``solve`` along with the hint defined by ``method``. Returns ======= solutions : Matrix Vector representing the solution. 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\tQRtLDLtPINVRpN(RRYRRIRAtsolve(R6RRpR((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytsolve_least_squaressK         tGJcC s|dkrey.|j|\}}|r9tdnWn$tk r`|jdjnX|S|dkr~|j|S|dkr|j|S|dkr|j|S|dkr|j|S|dkr|j|S|jd ||Sd S( s`Solves linear equation where the unique solution exists. Parameters ========== rhs : Matrix Vector representing the right hand side of the linear equation. method : string, optional If set to ``'GJ'``, the Gauss-Jordan elimination will be used, which is implemented in the routine ``gauss_jordan_solve``. If set to ``'LU'``, ``LUsolve`` routine will be used. If set to ``'QR'``, ``QRsolve`` routine will be used. If set to ``'PINV'``, ``pinv_solve`` routine will be used. It also supports the methods available for special linear systems For positive definite systems: If set to ``'CH'``, ``cholesky_solve`` routine will be used. If set to ``'LDL'``, ``LDLsolve`` routine will be used. To use a different method and to compute the solution via the inverse, use a method defined in the .inv() docstring. Returns ======= solutions : Matrix Vector representing the solution. Raises ====== ValueError If there is not a unique solution then a ``ValueError`` will be raised. If ``self`` is not square, a ``ValueError`` and a different routine for solving the system will be suggested. RbsfMatrix det == 0; not invertible. Try ``self.gauss_jordan_solve(rhs)`` to obtain a parametric solution.itLUR\R]R^R_RpN( RR|RRRRRYRRI(R6RRptsolntparam((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyR`es&/            t[t]s s, RcC ss|jdks|jdkr"dSg}dg|j}xt|jD]t} |jgx^t|jD]M} |j|| | f} |dj| tt| || || ', 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} is[]itljustRtrjustRtcentertt^( RDRER RHt_printR)RbRR.RM(R6RtrowstarttrowendRtcolseptalignRtmaxlenR7RARORtelem((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRs.3 %!cC s^|jstdn|j|jkr9tdn|jsQtdn|j|S(sSolves ``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 sMatrix must be square.sMatrix size mismatch.sMatrix is not upper triangular.(RsR+RDRXRR(R6R((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytupper_triangular_solves  c C sVddlm}|j}||jkr7tdn|rk|j||jkrktdqknd}|r|||ddd}xt|D]>}x5t||D]$}|||f||<|d7}qWqWnn|||ddd}xPt|D]B}x9t|d|D]$}|||f||<|d7}q&Wq W|S(sReturn 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 i(RsMatrix must be squares>Matrix appears to be asymmetric; consider check_symmetry=Falseiii( R RRERDR,R%RoR|R ( R6tdiagonaltcheck_symmetryRRtcountRRAR7((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytvechs,  N(IR<R=R>t__array_priority__RRt_class_priorityt staticmethodRRR/t__hash__Rt_repr_latex_origtobjectRRRRRRR;R:RRRRRRRRRRRRRRRRRRRRR1RRR RR RRRRRR"RfR4RR:R<RRIRERQRRXRYR[RaR`RRuRy(((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRV-s           F  $ A   + i ' + ,    @    ; 0  E 1 8 ' d V 8 "  ] -^ W F M Ri;Rs)from sympy.matrices.common import classofRs1.3cC sddlm}|||S(Ni(tclassof(R R(RLRmtclassof_((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyRGss'from sympy.matrices.common import a2idxcC sddlm}|||S(Ni(R (R R (RAR~R((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyR Osc C sg}t|}td|Drtd|Drg|D]}t|^qE}t|}||r|dkrgt|D]$\}}|dkr|df^q}nddt|fS|j|}|||t|fSg} xOt|D]A\}}||} | tkr5||t|fS| j | qWt| rbddt|fSxt|D]\}}| |dk rqon||} || } | t ks| tkr|j || fn| tkr|| t|fS| | |oscs s|]}t|tVqdS(N(R}R(RSR0((s6lib/python2.7/site-packages/sympy/matrices/matrices.pys psiN(R\RRR=R)RR/RtindexRHRRRR@( RRRReRR0tcol_abst max_valueR7Rtpossible_zerosR-tsimped((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyR[XsT    :         c C sTg}xdt|D]V\}}||}|tkrG||tgfS|dkr|j||fqqWt|dkrddtgfS|dkr|dd|ddtgfSg}xp|D]h\}}||}t|t|kr|j||f||tkr0||t|fSqqW|dd|ddt|fS(s 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. iiN(RRR/RHRbRtid( RRRRetindeterminatesR7tcol_valtcol_val_is_zeroRt tmp_col_val((s6lib/python2.7/site-packages/sympy/matrices/matrices.pyR%s&+      N(St __future__RRttypesRtmpmath.libmp.libmpfRtsympy.core.addRtsympy.core.basicRtsympy.core.compatibilityRRRR R R R R tsympy.core.decoratorsRtsympy.core.exprRtsympy.core.functionRtsympy.core.numbersRRRtsympy.core.powerRtsympy.core.singletonRtsympy.core.symbolRRRRtsympy.core.sympifyRtsympy.functionsRRt(sympy.functions.elementary.miscellaneousRRRt sympy.polysR R!R"tsympy.printingR#tsympy.simplifyR$R%Rtsympy.utilities.exceptionsR&tsympy.utilities.iterablesR'R(tcommonR)R*R+R,R1R2R3R?RRRRER[RVRR/R R[R%(((s6lib/python2.7/site-packages/sympy/matrices/matrices.pytsx:""  !g