U 9%e&@sddlZddlmZddlmZddlmZddlm Z ddl m Z ddl m Z mZddlmZdd lmZdd lmZdd lmZmZmZdd lmZmZdd lmZmZddlm Z ddl!m"Z"m#Z#ddl$m%Z%m&Z&m'Z'ddl(m)Z)m*Z*ddl+m,Z,ddl-m.Z.ddl/m0Z0ddl1m2Z2ddl3m4Z4m5Z5m6Z6m7Z7ddl8m9Z9m:Z:ddl;mZ>m?Z?m@Z@mAZAmBZBddlCmDZDmEZEmFZFddlGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTddlUmVZVmWZWmXZXmYZYddlZm[Z[m\Z\m]Z]m^Z^ddl_m`Z`maZambZbmcZcmdZdmeZemfZfmgZgmhZhmiZimjZjmkZkmlZlmmZmddlnmoZompZpmqZqmrZrmsZsmtZtmuZumvZvmwZwdd lxmyZymzZzm{Z{m|Z|dd!l}m~Z~mZmZmZmZmZmZmZmZmZmZdd"lmZmZmZmZmZmZmZmZmZmZGd#d$d$ee5ZGd%d&d&e<ZGd'd(d(eZGd)d*d*eZGd+d,d,eZGd-d.d.e<ZGd/d0d0e<Zeje eAd1d2ZejeAeAd3d4ZGd5d6d6eeee>> 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_namer|V/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/sympy/matrices/matrices.py __getitem__Ts zDeferredVector.__getitem__cCst|SNrrzr|r|r}__str__\szDeferredVector.__str__cCs d|jS)NzDeferredVector('%s'))ryrr|r|r}__repr___szDeferredVector.__repr__N)__name__ __module__ __qualname____doc__r~rrr|r|r|r}rwDsrwc@seZdZdZefddZddZedfddZd d Z dd d Z de fddZ dddZ d ddZd!ddZddZd"ddZddZeje_eje_eje_eje_eje_eje _eje _eje _eje _eje_eje_eje_eje_eje_dS)#MatrixDeterminantzProvides basic matrix determinant operations. Should not be instantiated directly. See ``determinant.py`` for their implementations.cCs t||dSN) iszerofuncr:rzrr|r|r}_eval_det_bareissgsz#MatrixDeterminant._eval_det_bareisscCst|Sr)r;rr|r|r}_eval_det_berkowitzjsz%MatrixDeterminant._eval_det_berkowitzNcCst|||dS)N)rsimpfunc)r<)rzrrr|r|r} _eval_det_lumszMatrixDeterminant._eval_det_lucCst|Srr9rr|r|r}_eval_determinantpsz#MatrixDeterminant._eval_determinant berkowitzcCs t||dSNmethod)r4rzrr|r|r}adjugatesszMatrixDeterminant.adjugatelambdacCst|||dS)N)xsimplify)r5rzrrr|r|r}charpolyvszMatrixDeterminant.charpolycCst||||dSr)r6rzr{jrr|r|r}cofactoryszMatrixDeterminant.cofactorcCs t||dSr)r7rr|r|r}cofactor_matrix|sz!MatrixDeterminant.cofactor_matrixbareisscCst|||dS)N)rrr)rzrrr|r|r}detszMatrixDeterminant.detcCst|Sr)r8rr|r|r}perszMatrixDeterminant.percCst||||dSr)r=rr|r|r}minorszMatrixDeterminant.minorcCs t|||Sr)r>rzr{rr|r|r}minor_submatrixsz!MatrixDeterminant.minor_submatrix)r)r)r)rN)r) rrrrr0rrr/rrrr1rrrrrrrr2r3r:r;r<r9r4r5r6r7r8r=r>r|r|r|r}rcs6      rc@seZdZdZeddfddZeddZedfddZedd d fd d Z e je_e je_e je_e je _d!d dZddZddZddZddZddZddZd"ddZd#dd ZdS)$MatrixReductionszProvides basic matrix row/column operations. Should not be instantiated directly. See ``reductions.py`` for some of their implementations.FcCst||||dS)N)rr with_pivots)r@)rzrrrr|r|r} echelon_formszMatrixReductions.echelon_formcCst|Sr)r?rr|r|r} is_echelonszMatrixReductions.is_echeloncCst|||dSN)rr)rArzrrr|r|r}rankszMatrixReductions.rankTcCst|||||dS)N)rrpivotsnormalize_last)rB)rzrrrrr|r|r}rrefszMatrixReductions.rrefcolc Cs&|dkrtd|||dkr&|jn|j}|dkr|dk r@|n|}|dksT|dkrbtd|d|krv|ksntd||n|d kr@||||hdg}t|d kr|||hdg}t|d krtd ||\}}d|kr|ksntd||d|kr,|ksntd||n|d kr|dkrX|n|}|dkrj|n|}|dks|dks|dkrtd |||krtd|d|kr|ksntd||d|kr|ksntd||ntdt||||||fS)zValidate the arguments for a row/column operation. ``error_str`` can be one of "row" or "col" depending on the arguments being parsed.)n->knn<->mn->n+kmzOUnknown {} operation '{}'. Valid col operations are 'n->kn', 'n<->m', 'n->n+km'rrNzEFor a {0} operation 'n->kn' you must provide the kwargs `{0}` and `k`rz#This matrix does not have a {} '{}'rzIFor a {0} operation 'n<->m' you must provide the kwargs `{0}1` and `{0}2`rzPFor 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.zinvalid operation %s) ValueErrorformatcolsrows differencelenrepr) rzoprkcol1col2Z error_strZ self_colsrr|r|r}_normalize_op_argssX     z#MatrixReductions._normalize_op_argscs"fdd}jj|S)Ncs$|kr||fS||fSrr|r{rrrrzr|r}entryszBMatrixReductions._eval_col_op_multiply_col_by_const..entry_newrr)rzrrrr|rr}"_eval_col_op_multiply_col_by_constsz3MatrixReductions._eval_col_op_multiply_col_by_constcs"fdd}jj|S)Ncs4|kr|fS|kr(|fS||fSrr|rrrrzr|r}rs   z1MatrixReductions._eval_col_op_swap..entryr)rzrrrr|rr}_eval_col_op_swapsz"MatrixReductions._eval_col_op_swapcs$fdd}jj|S)Ncs0|kr$||f|fS||fSrr|rrrrrzr|r}rszFMatrixReductions._eval_col_op_add_multiple_to_other_col..entryr)rzrrrrr|rr}&_eval_col_op_add_multiple_to_other_colsz7MatrixReductions._eval_col_op_add_multiple_to_other_colcs"fdd}jj|S)Ncs4|kr|fS|kr(|fS||fSrr|rrow1row2rzr|r}rs   z1MatrixReductions._eval_row_op_swap..entryr)rzrrrr|rr}_eval_row_op_swapsz"MatrixReductions._eval_row_op_swapcs"fdd}jj|S)Ncs$|kr||fS||fSrr|rrrowrzr|r}r szBMatrixReductions._eval_row_op_multiply_row_by_const..entryr)rzrrrr|rr}"_eval_row_op_multiply_row_by_const sz3MatrixReductions._eval_row_op_multiply_row_by_constcs$fdd}jj|S)Ncs0|kr$||f|fS||fSrr|rrrrrzr|r}rszFMatrixReductions._eval_row_op_add_multiple_to_other_row..entryr)rzrrrrr|rr}&_eval_row_op_add_multiple_to_other_rowsz7MatrixReductions._eval_row_op_add_multiple_to_other_rowrNcCs`||||||d\}}}}}|dkr2|||S|dkrF|||S|dkr\||||SdS)adPerforms 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" rrrrN)rrrr)rzrrrrrr|r|r}elementary_col_ops  z"MatrixReductions.elementary_col_opcCs`||||||d\}}}}}|dkr2|||S|dkrF|||S|dkr\||||SdS)a4Performs 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" rrrrN)rrrr)rzrrrrrr|r|r}elementary_row_op7s  z"MatrixReductions.elementary_row_op)r)rNNNN)rNNNN)rrrrr/rpropertyrrrr@r?rArBrrrrrrrrrr|r|r|r}rs*   7   rc@sbeZdZdZd ddZdefddZd ddZd d Ze je_e je_e je_e je_e eZd S)MatrixSubspaceszProvides methods relating to the fundamental subspaces of a matrix. Should not be instantiated directly. See ``subspaces.py`` for their implementations.FcCs t||dSN)r)rCrzrr|r|r} columnspace[szMatrixSubspaces.columnspacecCst|||dS)N)rr)rD)rzrrr|r|r} nullspace^szMatrixSubspaces.nullspacecCs t||dSr)rErr|r|r}rowspaceaszMatrixSubspaces.rowspacecOst|f||Sr)rF)clsZvecskwargsr|r|r} orthogonalizegszMatrixSubspaces.orthogonalizeN)F)F)rrrrrr/rrrrCrDrErF classmethodr|r|r|r}rVs  rc@seZdZdZd!ddZdefddZd"dd Zd#d d Zd$d d Z d%ddZ e ddZ e ddZ e ddZe ddZe ddZd&ddZddZddZeje_eje_eje_eje_eje _eje _eje_eje_eje_eje_eje_eje_e je _e!je _d S)' MatrixEigenzProvides basic matrix eigenvalue/vector operations. Should not be instantiated directly. See ``eigen.py`` for their implementations.TcKst|fd|i|S)Nerror_when_incomplete)rG)rzrflagsr|r|r} eigenvalswszMatrixEigen.eigenvalscKst|f||d|S)N)rr)rH)rzrrrr|r|r} eigenvectszs zMatrixEigen.eigenvectsFcKst|fd|i|S)N reals_only)rK)rzrrr|r|r}is_diagonalizable~szMatrixEigen.is_diagonalizablecCst||||dS)N)rsort normalize)rL)rzrrrr|r|r} diagonalizeszMatrixEigen.diagonalizecCs t||dSN)upper)rIrzrr|r|r} bidiagonalizeszMatrixEigen.bidiagonalizecCs t||dSr)rJrr|r|r}bidiagonal_decompositionsz$MatrixEigen.bidiagonal_decompositioncCst|Sr)rMrr|r|r}is_positive_definitesz MatrixEigen.is_positive_definitecCst|Sr)rNrr|r|r}is_positive_semidefinitesz$MatrixEigen.is_positive_semidefinitecCst|Sr)rOrr|r|r}is_negative_definitesz MatrixEigen.is_negative_definitecCst|Sr)rPrr|r|r}is_negative_semidefinitesz$MatrixEigen.is_negative_semidefinitecCst|Sr)rQrr|r|r} is_indefiniteszMatrixEigen.is_indefinitecKst|fd|i|S)Ncalc_transform)rR)rzrrr|r|r} jordan_formszMatrixEigen.jordan_formcKs t|f|Sr)rSrzrr|r|r}left_eigenvectsszMatrixEigen.left_eigenvectscCst|Sr)rTrr|r|r}singular_valuesszMatrixEigen.singular_valuesN)T)F)FFF)T)T)T)"rrrrrr/rrrrrrrrrrrrrrrGrHrKrLrMrNrOrPrQrRrSrTrIrJr|r|r|r}rrsD           rc@s8eZdZdZddZddZddZdd Zd d Zd S) MatrixCalculusz,Provides calculus-related matrix operations.cOsFddlm}|dd||f|ddi}t|ts>|S|SdS)aCalculate the derivative of each element in the matrix. ``args`` will be passed to the ``integrate`` function. Examples ======== >>> from sympy 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)ArrayDerivativeevaluateTN)Z$sympy.tensor.array.array_derivativesr setdefault isinstancerZ as_mutable)rzargsrrZderivr|r|r}rs    zMatrixCalculus.diffcs|fddS)Ncs |Srrrargr|r}z1MatrixCalculus._eval_derivative.. applyfunc)rzrr|rr}_eval_derivativeszMatrixCalculus._eval_derivativecs|fddS)aIntegrate each element of the matrix. ``args`` will be passed to the ``integrate`` function. Examples ======== >>> from sympy 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 |jSr) integraterrrr|r}rrz*MatrixCalculus.integrate..r)rzrrr|r r}r szMatrixCalculus.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||Srr)rr{Xrzr|r}r.rz)MatrixCalculus.jacobian..)r MatrixBasershape TypeError)rzr mnr|r r}jacobians$      zMatrixCalculus.jacobiancs|fddS)aCalculate the limit of each element in the matrix. ``args`` will be passed to the ``limit`` function. Examples ======== >>> from sympy 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 |jSr)limitrrr|r}rErz&MatrixCalculus.limit..r)rzrr|rr}r0szMatrixCalculus.limitN) rrrrrrr rrr|r|r|r}rs 9rc@seZdZdZedefddZddZddZd d Z d d Z d"ddZ ddZ ddZ ddZd#ddZd$ddZddZddZdd Zd!S)%MatrixDeprecatedz+A class to house deprecated matrix methods.rcCs |j|dS)Nr)rrr|r|r}berkowitz_charpolyKsz#MatrixDeprecated.berkowitz_charpolycCs |jddS)zwComputes determinant using Berkowitz method. See Also ======== det berkowitz rrrrr|r|r} berkowitz_detNs zMatrixDeprecated.berkowitz_detcKs |jf|S)zwComputes eigenvalues of a Matrix using Berkowitz method. See Also ======== berkowitz )rrr|r|r}berkowitz_eigenvalsYsz$MatrixDeprecated.berkowitz_eigenvalscCs:|jg}}|D]}|||d| }qt|S)zpComputes principal minors using Berkowitz method. See Also ======== berkowitz )onerappendtuple)rzsignZminorsZpolyr|r|r}berkowitz_minorscs   z!MatrixDeprecated.berkowitz_minorscCsddlm}d}|s|S|js$t||j}}dg|d}t|ddD]}||d||d}}||d|f |d||f} } |d|d|f|||f }} | g} td|dD]} | || | qt| D]\} }| |d| | <q|j| g| } t|D]&} | d|| d|| d| f<q|||d<qJ| |j|d gg}t|D]\} }|||| qj|t t t |S)Nrzeros)r'r'rrrr) sympy.matricesr! is_squarer*rranger enumeraterrrmap)rzr!ZberkANZ transformsrTrRCaitemsr{BZpolysr|r|r}rss2  $$ $zMatrixDeprecated.berkowitzrcCs |j|dSr)rrr|r|r}cofactorMatrixszMatrixDeprecated.cofactorMatrixcCst|Srrrr|r|r} det_bareisszMatrixDeprecated.det_bareiscCs |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 Zlurrrr|r|r}det_LU_decompositionsz%MatrixDeprecated.det_LU_decompositioncCs|j||dS)N)sizeZ eigenvalue)Z jordan_block)rzZeigenvalrr|r|r} jordan_cellszMatrixDeprecated.jordan_cellTcCs|\}}||fSr)rget_diag_blocks)rzZcalc_transformationPJr|r|r} jordan_cellss zMatrixDeprecated.jordan_cellscCs|j|||dSr)rrr|r|r} minorEntryszMatrixDeprecated.minorEntrycCs |||Sr)rrr|r|r} minorMatrixszMatrixDeprecated.minorMatrixcCs|j|ddS)zEPermute the rows of the matrix with the given permutation in reverse.Zbackward directionZ permute_rowsrzpermr|r|r} permuteBkwdszMatrixDeprecated.permuteBkwdcCs|j|ddS)z:Permute the rows of the matrix with the given permutation.forwardr<r>r?r|r|r} permuteFwdszMatrixDeprecated.permuteFwdN)r)T)r)rrrrr r1rrrrrr1r2r3r5r9r:r;rArCr|r|r|r}rIs  (   rcCs*t|ts||}}t||j}t|S)z Return MatrixKind. The element kind is selected by recursive dispatching. Do not need to dispatch in reversed order because KindDispatcher searches for this automatically. )rr-r _kind_dispatcher element_kindZk1Zk2Zelemkr|r|r} num_mat_muls  rGcCst|j|j}t|S)zS Return MatrixKind. The element kind is selected by recursive dispatching. )r rDrEr-rFr|r|r} mat_mat_mulsrHc@seZdZdZdZdZdZeeZ e j Z e j ZeedddZdd Zefd d Zd d ZddZddZdddZeddZeddZeddZddZddZdd Zd!d"Z d#d$Z!ed%d&Z"dd'd(Z#d)d*Z$d+d,Z%d-d.Z&d/d0Z'd1d2Z(e)fd3d4Z*d5d6Z+d7d8Z,d9d:Z-e.fd;d<Z/dd=d>Z0dd@dAZ1dBdCZ2ddIdJZ3e.dKfdLdMZ4ddNdOZ5ddPdQZ6e.ddKfdRdSZ7e.ddKfdTdUZ8dVdWZ9dXdYZ:dZd[Z;d\d]ZdbdcZ?dddeZ@dfdgZAe.fdhdiZBdjdkZCddldmZDddndoZEddqdrZFddtduZGddwdxZHdydzZIe.fd{d|ZJe.fd}d~ZKe.fddZLe.fddZMe.fddZNe.fddZOe.fddZPde.dKfddZQddZRddZSddZTdddZUeVjWZWeXje4_eYje5_eZje6_e[je7_e\je8_e]je9_e^je:_e_je;_e`je<_eaje=_ebje>_ecje?_edje@_eejeA_efjeB_egjeC_ehjeD_eijeE_ejjeF_ekjeG_eljeH_emjeI_enjeJ_eojeL_epjeM_eqjeN_erjeO_esjeP_etjeK_eujeQ_evjeR_ewjeS_exjeT_eyjeU_dS)r zBase class for matrix objects. T)returncCs2dd|D}t|dkr&|\}nt}t|S)NcSsh|] }|jqSr|)kind).0er|r|r} sz"MatrixBase.kind..r')flatrr r-)rzZ elem_kindsZelemkindr|r|r}rLs  zMatrixBase.kindcsfddtjDS)Ncs(g|] }tjD]}||fqqSr|)r&r)rMr{rrr|r} s z#MatrixBase.flat..)r&rrr|rr}rPszMatrixBase.flatcCsddlm}|||dS)Nr') matrix2numpy)dtype)denserR)rzrSrRr|r|r} __array__s zMatrixBase.__array__cCs |j|jS)zkReturn the number of elements of ``self``. Implemented mainly so bool(Matrix()) == False. )rrrr|r|r}__len__szMatrixBase.__len__cspddlm}mdd}|\}}|}fdd|D}|D]}|||qB|||||S)Nr)diag MutableMatrixcSs|jd}|d}|jrl|dkr4|jr4|||d<q|jr@|jsJtdqt|D]}t|||d|f<qRnBt|D]8}t||}t|tr| }|||||d|f<qtt|D]<}td||D](}||d||df||||f<qqdS)Nrr#r'zANon-invertible matrix can only be raised to a nonnegative integer) ris_zeroZis_nonnegative is_integerr+r&rrrZ_eval_expand_func)Zjcrr*lr{Zbnrr|r|r}jordan_cell_powers"        zBMatrixBase._matrix_pow_by_jordan_blocks..jordan_cell_powercsg|] }|qSr|r|rMrrXr|r}rQ(sz;MatrixBase._matrix_pow_by_jordan_blocks..)r$rWrXrr6rmultiplyinv)rznumrWr\r7r8r9rr|r^r}_matrix_pow_by_jordan_blocks s  z'MatrixBase._matrix_pow_by_jordan_blockscCs,tj|jkrd|j|jfSdt|S)NMatrix(%s, %s, [])z Matrix(%s))r Zerorrrstrtolistrr|r|r}r.s zMatrixBase.__str__NcCsT|s t}tj|jkr&d|j|jfS|jdkrBd|j|ddSd|j|ddS)Nrcr'z Matrix([%s])z, )rowsepz Matrix([ %s]))r r rdrrrtable)rzprinterr|r|r} _format_str3s  zMatrixBase._format_strc st|}dd|DtttddD}fddt|D}tfdd|D}g}t|rg}t|D]V\} } || ||  ddf|| d8<|| dkrxrxd|| <qxt||krt t d | |qd| |S) a%Return a matrix filled by the given matrices which are listed in order of appearance from left to right, top to bottom as they first appear in the matrix. They must fill the matrix completely. Examples ======== >>> from sympy import ones, Matrix >>> Matrix.irregular(3, ones(2,1), ones(3,3)*2, ones(2,2)*3, ... ones(1,1)*4, ones(2,2)*5, ones(1,2)*6, ones(1,2)*7) Matrix([ [1, 2, 2, 2, 3, 3], [1, 2, 2, 2, 3, 3], [4, 2, 2, 2, 5, 5], [6, 6, 7, 7, 5, 5]]) cSs"g|]}t|dr|n|qS) as_explicit)hasattrrkrMr{r|r|r}rQRsz(MatrixBase.irregular..cSsg|] }|jqSr|)rrmr|r|r}rQUscsg|]}dqS)r)poprM_)qr|r}rQVscsg|]}|jqSr|)rrm)br|r}rQWsNr'rz^ Matrices provided do not appear to fill the space completely.) r%listr&rsumanyr'extendrnrr&rr) rZntopZmatricesrdatactiverrrr.rr|)rrrqr} irregular=s(    zMatrixBase.irregularcs|}t|jdkrL|jd|jd}}fdd|D}|||fSt|jdkr|fdd|D}|jdd|fStddS)Nrrr'csg|]}|qSr|rrmrr|r}rQosz.MatrixBase._handle_ndarray..csg|]}|qSr|r{rmr|r|r}rQrsz&SymPy supports just 1D and 2D matrices)rUrrZravelNotImplementedError)rrZarrrr flat_listr|r|r}_handle_ndarraygs zMatrixBase._handle_ndarraycsddlm}ddlmddlmd}t|dkrt|d|rf|dj|dj t |d fSt|dt r|dj|dj |d fSt|dtr|djr|dj|dj |d fSt|dtjr|d}fdd|D}|j|j |fSt|dd r$|dSt|drt|dtst|d}fd d fd d  |d drfddfddt|ttfrfdd|D}|gggfkrd}}g}qt fdd|Dsfdd|D}t|}|rdnd}qrtfdd|Drdd|D} | rt| dkrftddd|D}| }t||}n d}}g}qrtfdd|Drt} g}|D]r|dd Dtj rR| !j nL r>rR| !t|fddDn| !d|"t| dkrtdq| }t||}qg}t} d}}|D] } t| st#| dd std!t| d rd| j krqn | sqrPtfd"d| DrP$d#d| D\ } } t%| | g fd$dt&| D} |  } n8d t#| dd rnd} | g} nt| } fd%d| D} | !| t| dkrtd|| | 7}q| r| nd}nt|d&krt'|d}t'|d}|dks|dkrtd'(||t|d&krzt|d(t)rz|d( g}t&|D]&| fd)dt&|DqPnPt|d&krt|d(r|d(}t|||krtd*fd+d|D}nt|dkrd}}g}|dkrt*t+d,|||fS)-a}Return the number of rows, cols and flat matrix elements. Examples ======== >>> 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]]) See Also ======== irregular - filling a matrix with irregular blocks r) SparseMatrix) MatrixSymbol) BlockMatrixNr'csg|]}|qSr|r{rMrr|r|r}rQsz6MatrixBase._handle_creation_inputs..rUcs"t|to p t|p t|Sr)rr r{)rrrr|r}rs z4MatrixBase._handle_creation_inputs..cst|o| Sr)r#rismatr|r}rrrTcs@t|r|St|r8tdd|jDr8|S|SdS)zmake Block and Symbol explicitcss|] }|jVqdSr)Z is_Integerror|r|r} szLMatrixBase._handle_creation_inputs..make_explicit..N)rrkallrr)rrr|r} make_explicits  z9MatrixBase._handle_creation_inputs..make_explicitcs,t|ttfr fdd|DS|SdS)Ncsg|] }|qSr|r|rrr|r}rQszQMatrixBase._handle_creation_inputs..make_explicit_row..)rrsr)rrr|r}make_explicit_rowsz=MatrixBase._handle_creation_inputs..make_explicit_rowcsg|] }|qSr|r|)rMr)rr|r}rQsc3s|]}|p|VqdSrr|rm)rrawr|r}rsz5MatrixBase._handle_creation_inputs..csg|]}|qSr|r{rmr|r|r}rQsc3s|]}|VqdSrr|rmrr|r}rscSsh|]}t|jr|jqSr|)rurrrmr|r|r}rOs z5MatrixBase._handle_creation_inputs..zmismatched dimensionscSs(g|] }|D]}|D]}|qqqSr|)rf)rMr{ryrpr|r|r}rQs  c3s|]}|VqdSrr|rmrr|r}rscSsg|]}|D]}|q qSr|r|)rMrrr|r|r}rQscsg|]}|qSr|r{)rMZijr|r|r}rQs is_MatrixFzexpecting list of listsc3s|]}|VqdSrr|rmrr|r}rscSsg|] }|jqSr|)r+rmr|r|r}rQscs&g|]}tD]}||qqSr|)r&)rMrr{)r+ryr|r}rQ"s csg|]}|qSr|r{rmr|r|r}rQ+srJz@Cannot create a {} x {} matrix. Both dimensions must be positiverc s(g|] }|qSr|r{r])rr{rr|r}rQAsz+List length should be equal to rows*columnscsg|]}|qSr|r{rmr|r|r}rQJszf Data type not understood; expecting list of lists or lists of values.),r$r"sympy.matrices.expressions.matexprrZ&sympy.matrices.expressions.blockmatrixrrrrrr!rfr rPrrrkmpmatrixrlrr#rwrsgetrrurrrnsetrvraddrgetattr_handle_creation_inputsr$r&r%rrrr&)rrrrr~MrwrrZncolrcZflatTrPr|) rrr+rrr{rrrrryrr}rxs.   ""                            z"MatrixBase._handle_creation_inputscCsddlm}t|t}||\}}}t|t}t|tsFt|tr|rZ|||dSt|ts|t|r|| ||dSt d|n|st|t st|r||}d}|r|rtt ||j tt ||j f}n t|||jt|||j f}|||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'MatrixNzunexpected value: %sT)rTrrslicekey2ijr Z copyin_matrixrr#Z copyin_listrrdivmodrrr)rzkeyvaluerZis_slicer{rZis_matr|r|r}_setitemZs<(     zMatrixBase._setitemcCs||S)zReturn self + b.r|rzrrr|r|r}rszMatrixBase.addcCs"|s |jS|}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 )zerorrr)rzZsingularvaluesr|r|r}condition_numberszMatrixBase.condition_numbercCs||j|j|S)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]]) )rrrrPrr|r|r}copyszMatrixBase.copyc Csddlm}t|t|fs.td|t||j|j|j|jkrRdksvnt d|j|jf|j|jffnl| |j|j|d|d|d|d|d|d|d|d|d|d|d|dfSdS) a 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 r) MatrixExprz{} must be a Matrix, not {}.rJz/Dimensions incorrect for cross product: %s x %sr'rN) rrrr rrtyperrr,r)rzrrrr|r|r}crosss & zMatrixBase.crosscCs(ddlm}|jdkrt|j|dS)aReturn 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 ======== sympy.matrices.common.MatrixCommon.conjugate: By-element conjugation sympy.matrices.common.MatrixCommon.H: Hermite conjugation r)mgamma)Zsympy.physics.matricesrrAttributeErrorH)rzrr|r|r}Ds"  z MatrixBase.DcCs\ddlm}t|tsnt|r^t||jkrPt||jkrPtd|j t|f| ||St dt |d|j ksd|j krtt|t|krtd|j |j f|}t|}|j d|fkr| d|}|j |dfkr| |d}|dk r|dkrd}|r|dkrd}|dkrP|dkr4|}n|d krH|}ntd ||d S) a4Return 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 r'rz,Dimensions incorrect for dot product: %s, %sz2`b` must be an ordered iterable or Matrix, not %s.NTmaths)rleftmath)ZphysicsrightzUnknown conjugate_convention was entered. conjugate_convention must be one of the following: math, maths, left, physics or right.r)rTrrr r#rrrr,rdotrrr$ conjugater)rzrr hermitianZconjugate_conventionrmatrr|r|r}rsN4         zMatrixBase.dotc Cs ddlm}|ddddf|j}}||}|r<|Std|D]`}td|D]P}d}td|D]"}|t||d||d|f7}qf||||f<| |||f<qTqFtd|D]h} d}td|D]2} td|D]"} |td| | | || | f7}qq|d}| |d| f<||| df<q|S)aReturns the dual of a matrix. A dual of a matrix 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. rr Nr'r)r$r!rZ is_symmetricr&r) rzr!rrZworkr{rZacumrr[r.rrr|r|r}duals*   "zMatrixBase.dualcsH|j}|d}t|fddt|D}ddlm}||||S)aA helper function to compute an exponential of a Jordan block matrix Examples ======== >>> from sympy import Symbol, Matrix >>> l = Symbol('lamda') A trivial example of 1*1 Jordan block: >>> m = Matrix.jordan_block(1, l) >>> m._eval_matrix_exp_jblock() Matrix([[exp(lamda)]]) An example of 3*3 Jordan block: >>> m = Matrix.jordan_block(3, l) >>> m._eval_matrix_exp_jblock() Matrix([ [exp(lamda), exp(lamda), exp(lamda)/2], [ 0, exp(lamda), exp(lamda)], [ 0, 0, exp(lamda)]]) References ========== .. [1] https://en.wikipedia.org/wiki/Matrix_function#Jordan_decomposition r#csi|]}|t|qSr|)rrmZexp_lr|r} sz6MatrixBase._eval_matrix_exp_jblock..r'banded)rrr& sparsetoolsr __class__)rzr4r[bandsrr|rr}_eval_matrix_exp_jblocks  z"MatrixBase._eval_matrix_exp_jblockcCst|t|}}|jst|js0td|||jkrJtd||||jkrdtd|||}t| }i}|}t |dD]}t ||}|||d<q|j d}| |} | |d} d} |D]j}||} |||| | <| | jr| | jstd|| | d} t |D]}| | | |f<| |9} q&| dkr4ddt |D}d}| dkr4| d} | d8} ||||}|jr|jstd ||||| | <t |D]f}||ddkrd| | |f<d||<q||||d||<||t|||| | |f<q|d7}qb| d7} q| | }| |}||}t |D]}||||}||9}qd|S) a Computes f(A) where A is a Square Matrix and f is an analytic function. Examples ======== >>> from sympy import Symbol, Matrix, S, log >>> x = Symbol('x') >>> m = Matrix([[S(5)/4, S(3)/4], [S(3)/4, S(5)/4]]) >>> f = log(x) >>> m.analytic_func(f, x) Matrix([ [ 0, log(2)], [log(2), 0]]) Parameters ========== f : Expr Analytic Function x : Symbol parameter of f z{} must be a symbol.z{} must be a parameter of {}.z!{} must not be a parameter of {}.r'rz_Cannot evaluate the function because the function {} is not analytic at the given eigenvalue {}cSsg|]}dqSr"r|)rMiir|r|r}rQsz,MatrixBase.analytic_func..zaCannot evaluate the function because the derivative {} is not analytic at the given eigenvalue {})rr%r*Z is_symbolrrZ free_symbolsrmaxvaluesr&rrr!subsZ is_numberZ is_complexpowsolveeye)rzfreigenZmax_mulZ derivativeddr{rryf_valrmulvalr.ZcoeZderiZd_irZansprer|r|r} analytic_funcs                 "       zMatrixBase.analytic_funccCs|jstdz|\}}|}Wntk rBtdYnXdd|D}ddlm}||}|j|ddj| dd}t d d | Drt |t |St ||SdS) aReturn the exponential of a square matrix. Examples ======== >>> from sympy import Symbol, Matrix >>> t = Symbol('t') >>> m = Matrix([[0, 1], [-1, 0]]) * t >>> m.exp() Matrix([ [ exp(I*t)/2 + exp(-I*t)/2, -I*exp(I*t)/2 + I*exp(-I*t)/2], [I*exp(I*t)/2 - I*exp(-I*t)/2, exp(I*t)/2 + exp(-I*t)/2]]) z0Exponentiation is valid only for square matricesz`Exponentiation is implemented only for matrices for which the Jordan normal form can be computedcSsg|] }|qSr|)rrMcellr|r|r}rQHsz"MatrixBase.exp..rrWN)Z dotprodsimpcss|] }|jVqdSr)Zis_real)rMrr|r|r}rMsz!MatrixBase.exp..)r%r*rr6r)r}r$rWr_r`rrrr)rzr7r8cellsblocksrWeJretr|r|r}r/s$    zMatrixBase.expcCsp|j}|d}|jr"td|dt|i}td|D]}| |  |||<q8ddlm}||||S)azHelper function to compute logarithm of a jordan block. Examples ======== >>> from sympy import Symbol, Matrix >>> l = Symbol('lamda') A trivial example of 1*1 Jordan block: >>> m = Matrix.jordan_block(1, l) >>> m._eval_matrix_log_jblock() Matrix([[log(lamda)]]) An example of 3*3 Jordan block: >>> m = Matrix.jordan_block(3, l) >>> m._eval_matrix_log_jblock() Matrix([ [log(lamda), 1/lamda, -1/(2*lamda**2)], [ 0, log(lamda), 1/lamda], [ 0, 0, log(lamda)]]) r#zBCould not take logarithm or reciprocal for the given eigenvalue {}rr'r) rrYr)rrr&rrr)rzr4r[rr{rr|r|r}_eval_matrix_log_jblockRs  z"MatrixBase._eval_matrix_log_jblockc Cs|jstdz.|r&||\}}n |\}}|}Wntk rXtdYnXdd|D}ddlm}||}|r|||||}| |}n|||}|S)aHReturn the logarithm of a square matrix. Parameters ========== simplify : function, bool The function to simplify the result with. Default is ``cancel``, which is effective to reduce the expression growing for taking reciprocals and inverses for symbolic matrices. Examples ======== >>> from sympy import S, Matrix Examples for positive-definite matrices: >>> m = Matrix([[1, 1], [0, 1]]) >>> m.log() Matrix([ [0, 1], [0, 0]]) >>> m = Matrix([[S(5)/4, S(3)/4], [S(3)/4, S(5)/4]]) >>> m.log() Matrix([ [ 0, log(2)], [log(2), 0]]) Examples for non positive-definite matrices: >>> m = Matrix([[S(3)/4, S(5)/4], [S(5)/4, S(3)/4]]) >>> m.log() Matrix([ [ I*pi/2, log(2) - I*pi/2], [log(2) - I*pi/2, I*pi/2]]) >>> m = Matrix( ... [[0, 0, 0, 1], ... [0, 0, 1, 0], ... [0, 1, 0, 0], ... [1, 0, 0, 0]]) >>> m.log() Matrix([ [ I*pi/2, 0, 0, -I*pi/2], [ 0, I*pi/2, -I*pi/2, 0], [ 0, -I*pi/2, I*pi/2, 0], [-I*pi/2, 0, 0, I*pi/2]]) z+Logarithm is valid only for square matricesz[Logarithm is implemented only for matrices for which the Jordan normal form can be computedcSsg|] }|qSr|)rrr|r|r}rQsz"MatrixBase.log..rr) r%r*rr6r)r}r$rWr`r) rzrr7r8rrrWrrr|r|r}rys.4     zMatrixBase.logcCsN|sdS|jstdtd|ddd}||}|jd||jkrJdSdS) 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 matricesrcSsd|S)Nrpr|)sr|r|r}rrz)MatrixBase.is_nilpotent..)modifyrF)r%r*rrrr)rzrpr|r|r} is_nilpotents zMatrixBase.is_nilpotentcCsdd|D\}}|rD|js&d}}q\|d|jdd\}}nt|d|j}|d}|r|jspd}}q|d|jdd\}}nt|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 cSsg|]}t|tqSr|)rr)rMrr|r|r}rQsz)MatrixBase.key2bounds..rNrr')rindicesr.r)rzkeysisliceZjsliceZrloZrhiZclochir|r|r} key2boundss   zMatrixBase.key2boundscCslt|r2t|dkstdddt||jDSt|trR|t|ddStt |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 rz"key must be a sequence of length 2cSs(g|] \}}t|ts t||n|qSr|)rrr.)rMr{rr|r|r}rQsz%MatrixBase.key2ij..N) r#rrziprrrrrr.r)rzrr|r|r}rs    zMatrixBase.key2ijcsT|jdkr|jdkrtd||r>||j|j}n|fdd}|S)aReturn the normalized version of ``self``. Parameters ========== iszerofunc : Function, optional A function to determine whether ``self`` is a zero vector. The default ``_iszero`` tests to see if each element is exactly zero. Returns ======= Matrix Normalized vector form of ``self``. It has the same length as a unit vector. However, a zero vector will be returned for a vector with norm 0. Raises ====== ShapeError If the matrix is not in a vector form. See Also ======== norm r'z'A Matrix must be a vector to normalize.cs|Srr|rnormr|r}r=rz'MatrixBase.normalized..)rrr,rr!r)rzroutr|rr} normalizedszMatrixBase.normalizedc st|pdg}tj|jkrֈdkr>> 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 rrNcss|]}t|dVqdSrabsrmr|r|r}rxsz"MatrixBase.norm..r'css|]}t|VqdSrrrmr|r|r}r{scSsg|] }t|qSr|rrmr|r|r}rQ~sz#MatrixBase.norm..cSsg|] }t|qSr|rrmr|r|r}rQsc3s|]}t|VqdSrrrmordr|r}rsz'Expected order to be Number, Symbol, oocsg|]}t|qSr|)rtrrmrr|r}rQsrcsg|]}t|qSr|)rtrrmrr|r}rQsN)rZfroZ frobeniusZvectorrzMatrix Norms under development)rsrr OnerrrInfinityrNegativeInfinityrr r}rrrrr&rrrrrelowerZvecr)rzrvalsr|)rrr}r@sB5   $        zMatrixBase.normr cCsxg}t|jD]V}g}t|jD].}|||fdkr@|dq |t|q |dd|qtd|dS)aShows location of non-zero entries for fast shape lookup. Examples ======== >>> from sympy 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] N)r&rrrrejoinprint)rzZsymbrr{linerr|r|r} 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)rzvr|r|r}projectszMatrixBase.project[]r, rcCstj|jkrdSg}dg|j}t|jD]T} |gt|jD]:} ||| | f} |d| tt | || || <qBq*ddddddd|}t |D]F\} } t | D]\} } t | ||| | | <q|| | ||| <q| |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, 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} z[]rrljustrjustcenter)rrr<>^) r rdrrr&rrZ_printrrr'rr)rzriZrowstartZrowendrgZcolsepalignresmaxlenr{rrrelemr|r|r}rhs02   zMatrixBase.tableFcCst|||dSr)rUrr|r|r}rank_decomposition$szMatrixBase.rank_decompositioncCs tddSNz;This function is implemented in DenseMatrix or SparseMatrixr}rzrr|r|r}cholesky(szMatrixBase.choleskycCs tddSrrrr|r|r}LDLdecomposition+szMatrixBase.LDLdecompositioncCst||||dSN)rr rankcheck)rXrzrrr r|r|r}LUdecomposition.szMatrixBase.LUdecompositioncCst||||dSr )rYr r|r|r}LUdecomposition_Simple3sz!MatrixBase.LUdecomposition_SimplecCst|Sr)rZrr|r|r}LUdecompositionFF8szMatrixBase.LUdecompositionFFcCst|Sr)r[rr|r|r}singular_value_decomposition;sz'MatrixBase.singular_value_decompositioncCst|Sr)r\rr|r|r}QRdecomposition>szMatrixBase.QRdecompositioncCst|Sr)r]rr|r|r}upper_hessenberg_decompositionAsz)MatrixBase.upper_hessenberg_decompositioncCs t||Sr)rbrzrhsr|r|r}diagonal_solveDszMatrixBase.diagonal_solvecCs tddSrrrr|r|r}lower_triangular_solveGsz!MatrixBase.lower_triangular_solvecCs tddSrrrr|r|r}upper_triangular_solveJsz!MatrixBase.upper_triangular_solvecCs t||Sr)rerr|r|r}cholesky_solveMszMatrixBase.cholesky_solvecCs t||Sr)rfrr|r|r}LDLsolvePszMatrixBase.LDLsolvecCst|||dSr)rg)rzrrr|r|r}LUsolveSszMatrixBase.LUsolvecCs t||Sr)rhrr|r|r}QRsolveVszMatrixBase.QRsolvecCst|||dS)N)freevar)ri)rzr0rr|r|r}gauss_jordan_solveYszMatrixBase.gauss_jordan_solvecCst|||dS)N)arbitrary_matrix)rj)rzr0rr|r|r} pinv_solve\szMatrixBase.pinv_solveGJcCst|||dSr)rkrzrrr|r|r}r_szMatrixBase.solveCHcCst|||dSr)rlr!r|r|r}solve_least_squaresbszMatrixBase.solve_least_squaresRDcCs t||dSr)rmrr|r|r}pinveszMatrixBase.pinvcCs t||Sr)rn)rzrr|r|r}inv_modhszMatrixBase.inv_modcCs t||dSr)rorr|r|r} inverse_ADJkszMatrixBase.inverse_ADJcCs t||dSr)rvrr|r|r} inverse_BLOCKnszMatrixBase.inverse_BLOCKcCs t||dSr)rprr|r|r} inverse_GEqszMatrixBase.inverse_GEcCs t||dSr)rqrr|r|r} inverse_LUtszMatrixBase.inverse_LUcCs t||dSr)rrrr|r|r} inverse_CHwszMatrixBase.inverse_CHcCs t||dSr)rsrr|r|r} inverse_LDLzszMatrixBase.inverse_LDLcCs t||dSr)rtrr|r|r} inverse_QR}szMatrixBase.inverse_QRcCst||||dS)N)rrtry_block_diag)ru)rzrrr.r|r|r}r`szMatrixBase.invcCst|Sr)r^rr|r|r}connected_componentsszMatrixBase.connected_componentscCst|Sr)r_rr|r|r}"connected_components_decompositionsz-MatrixBase.connected_components_decompositioncCst|Sr)r`rr|r|r}strongly_connected_componentssz(MatrixBase.strongly_connected_componentscCs t||dS)N)r)ra)rzrr|r|r}+strongly_connected_components_decompositionsz6MatrixBase.strongly_connected_components_decomposition)N)NN)N)r )rrrrr)T)T)F)N)r )r")r$)T)zrrrrZ__array_priority__rZ_class_priority staticmethodrrr rdrrrrr-rLrPobjectrUrVrbrrjrrzrrrrrrrrrrrrrrrrrrrr/rrrrrhrrr r rrrrrrrrrrrrrrrr#r%r&r'r(r)r*r+r,r-r`r/r0r1r2rZ_sage_rUrVrWrXrYrZr[r\r]rbrcrdrerfrgrhrirjrkrlrmrnrorprqrrrsrtrvrur^r_r`rar|r|r|r}r s !  )  bF" * f((_#' R ' e " M                  r )Zmpmathrcollections.abcrZsympy.core.addrZsympy.core.basicrZsympy.core.functionrZsympy.core.exprrZsympy.core.kindrr Zsympy.core.mulr Zsympy.core.powerr Zsympy.core.singletonr Zsympy.core.symbolr rrZsympy.core.sympifyrrZ(sympy.functions.combinatorial.factorialsrrZ$sympy.functions.elementary.complexesrZ&sympy.functions.elementary.exponentialrrZ(sympy.functions.elementary.miscellaneousrrrZ(sympy.functions.special.tensor_functionsrrZ sympy.polysrZsympy.printingrZsympy.printing.defaultsrZsympy.printing.strr Zsympy.utilities.iterablesr!r"r#r$Zsympy.utilities.miscr%r&commonr(r)r*r+r,r-r.Z utilitiesr/r0r1Z determinantr2r3r4r5r6r7r8r9r:r;r<r=r>Z reductionsr?r@rArBZ subspacesrCrDrErFrrGrHrIrJrKrLrMrNrOrPrQrRrSrTZdecompositionsrUrVrWrXrYrZr[r\r]graphr^r_r`raZsolversrbrcrdrerfrgrhrirjrkrlZinversermrnrorprqrrrsrtrurvrwrrrrrrrDregisterrGrHr r|r|r|r}sh             $<@,408<F