
    RieOk                    v   d dl mZ d dlmZ d dlmZmZmZmZm	Z	 d dl
mZ d dlmZ d dlmZmZ d dlmZ d dlmZmZmZmZ d d	lmZmZ d d
lmZ d dlmZmZ d dl m!Z! d dl"m#Z# d dl$m%Z%m&Z& d dl'm(Z( d dl)m*Z* d,dZ+ G d de          Z, e(e,e          d             Z- e(e,e,          d             Z-d Z. e.e          g e.e	          gdej/        e,<   d-dZ0d Z1 G d de          Z2 G d de,          Z3d  Z4 G d! d"          Z5d# Z6d$d%l7m8Z8 d$d&l9m:Z: d$d'l;m<Z< d$d(l=m>Z> d$d)l?m@Z@ d$d*lAmBZBmCZC d$d+lDmEZE dS ).    )annotationswraps)SIntegerBasicMulAdd)check_assumptions)call_highest_priority)ExprExprBuilder)	FuzzyBool)StrDummysymbolsSymbol)SympifyError_sympify)
SYMPY_INTS)	conjugateadjoint)KroneckerDelta)NonSquareMatrixError)
MatrixKind
MatrixBase)dispatch)
filldedentNc                    fd}|S )Nc                @     t                      fd            }|S )Nc                `    	 t          |          } | |          S # t          $ r cY S w xY wN)r   r   )abfuncretvals     Blib/python3.11/site-packages/sympy/matrices/expressions/matexpr.py__sympifyit_wrapperz5_sympifyit.<locals>.deco.<locals>.__sympifyit_wrapper   sG    QKKtAqzz!   s    --r   )r%   r(   r&   s   ` r'   decoz_sympifyit.<locals>.deco   s:    	t	 	 	 	 	 
	 #"     )argr&   r)   s    ` r'   
_sympifyitr-      s#    	# 	# 	# 	# 	# Kr*   c                      e Zd ZU dZdZded<   dZdZdZded	<   dZ	ded
<   dZ
ded<   dZdZdZdZdZdZdZdZdZ e            Zded<   d ZedTd            Zed             Zed             Zd Zd Z ede           ed          d                         Z  ede           ed          d                         Z! ede           ed          d                         Z" ede           ed          d                          Z# ede           ed!          d"                         Z$ ede           ed!          d#                         Z% ede           ed$          d%                         Z& ede           ed$          d&                         Z' ede           ed'          d(                         Z( ede           ed)          d*                         Z) ede           ed+          d,                         Z* ede           ed-          d.                         Z+ed/             Z,ed0             Z-edUd2            Z.d3 Z/dVd4Z0d5 Z1d6 Z2d7 Z3d8 Z4d9 Z5d: Z6d; Z7d< Z8 fd=Z9e:d>             Z;d? Z<d@ Z=dWdAZ>dB Z?dC Z@edD             ZAdE ZBdF ZCdG ZDedH             ZEdI ZFdJ ZGdXdKZHdL ZIdM ZJdN ZKdO ZLdP ZMdQ ZNeOdYdR            ZPdS ZQ xZRS )Z
MatrixExpra  Superclass for Matrix Expressions

    MatrixExprs represent abstract matrices, linear transformations represented
    within a particular basis.

    Examples
    ========

    >>> from sympy import MatrixSymbol
    >>> A = MatrixSymbol('A', 3, 3)
    >>> y = MatrixSymbol('y', 3, 1)
    >>> x = (A.T*A).I * A * y

    See Also
    ========

    MatrixSymbol, MatAdd, MatMul, Transpose, Inverse
    r+   ztuple[str, ...]	__slots__Fg      &@Tbool	is_Matrixis_MatrixExprNr   is_Identityr   kindc                V    t          t          |          }t          j        | g|R i |S r"   )mapr   r   __new__)clsargskwargss      r'   r8   zMatrixExpr.__new__P   s1    8T""}S242226222r*   returntuple[Expr, Expr]c                    t           r"   NotImplementedErrorselfs    r'   shapezMatrixExpr.shapeV   s    !!r*   c                    t           S r"   MatAddrA   s    r'   _add_handlerzMatrixExpr._add_handlerZ       r*   c                    t           S r"   MatMulrA   s    r'   _mul_handlerzMatrixExpr._mul_handler^   rH   r*   c                Z    t          t          j        |                                           S r"   )rK   r   NegativeOnedoitrA   s    r'   __neg__zMatrixExpr.__neg__b   s     amT**//111r*   c                    t           r"   r?   rA   s    r'   __abs__zMatrixExpr.__abs__e   s    !!r*   other__radd__c                F    t          | |                                          S r"   rF   rO   rB   rS   s     r'   __add__zMatrixExpr.__add__h         dE""'')))r*   rX   c                F    t          ||                                           S r"   rV   rW   s     r'   rT   zMatrixExpr.__radd__m         eT""'')))r*   __rsub__c                H    t          | |                                           S r"   rV   rW   s     r'   __sub__zMatrixExpr.__sub__r   s"     dUF##((***r*   r^   c                H    t          ||                                            S r"   rV   rW   s     r'   r\   zMatrixExpr.__rsub__w   s"     edU##((***r*   __rmul__c                F    t          | |                                          S r"   rK   rO   rW   s     r'   __mul__zMatrixExpr.__mul__|   rY   r*   c                F    t          | |                                          S r"   rb   rW   s     r'   
__matmul__zMatrixExpr.__matmul__   rY   r*   rc   c                F    t          ||                                           S r"   rb   rW   s     r'   r`   zMatrixExpr.__rmul__   r[   r*   c                F    t          ||                                           S r"   rb   rW   s     r'   __rmatmul__zMatrixExpr.__rmatmul__   r[   r*   __rpow__c                F    t          | |                                          S r"   )MatPowrO   rW   s     r'   __pow__zMatrixExpr.__pow__   rY   r*   rl   c                     t          d          )NzMatrix Power not definedr?   rW   s     r'   ri   zMatrixExpr.__rpow__   s     ""<===r*   __rtruediv__c                &    | |t           j        z  z  S r"   )r   rN   rW   s     r'   __truediv__zMatrixExpr.__truediv__   s     eQ]***r*   rp   c                    t                      r"   r?   rW   s     r'   rn   zMatrixExpr.__rtruediv__   s     "###r*   c                    | j         d         S Nr   rC   rA   s    r'   rowszMatrixExpr.rows       z!}r*   c                    | j         d         S N   rt   rA   s    r'   colszMatrixExpr.cols   rv   r*   bool | Nonec                    | j         \  }}t          |t                    rt          |t                    r||k    S ||k    rdS d S NT)rC   
isinstancer   )rB   ru   rz   s      r'   	is_squarezMatrixExpr.is_square   sM    Z
ddG$$ 	 D')B)B 	 4<4<<4tr*   c                >    ddl m}  |t          |                     S Nr   )Adjoint)"sympy.matrices.expressions.adjointr   	TransposerB   r   s     r'   _eval_conjugatezMatrixExpr._eval_conjugate   s*    >>>>>>wy'''r*   c                *    |                                  S r"   )_eval_as_real_imag)rB   deephintss      r'   as_real_imagzMatrixExpr.as_real_imag   s    &&(((r*   c                    t           j        | |                                 z   z  }| |                                 z
  dt           j        z  z  }||fS N   )r   Halfr   ImaginaryUnit)rB   realims      r'   r   zMatrixExpr._eval_as_real_imag   sK    v 4 4 6 667T))+++a.?@bzr*   c                     t          |           S r"   InverserA   s    r'   _eval_inversezMatrixExpr._eval_inverse       t}}r*   c                     t          |           S r"   DeterminantrA   s    r'   _eval_determinantzMatrixExpr._eval_determinant   s    4   r*   c                     t          |           S r"   r   rA   s    r'   _eval_transposezMatrixExpr._eval_transpose       r*   c                "    t          | |          S )z
        Override this in sub-classes to implement simplification of powers.  The cases where the exponent
        is -1, 0, 1 are already covered in MatPow.doit(), so implementations can exclude these cases.
        rk   )rB   exps     r'   _eval_powerzMatrixExpr._eval_power   s    
 dC   r*   c                \    | j         r| S ddlm  | j        fd| j        D              S )Nr   )simplifyc                "    g | ]} |fi S r+   r+   ).0xr;   r   s     r'   
<listcomp>z-MatrixExpr._eval_simplify.<locals>.<listcomp>   s+    HHHxx44V44HHHr*   )is_Atomsympy.simplifyr   r%   r:   )rB   r;   r   s    `@r'   _eval_simplifyzMatrixExpr._eval_simplify   sO    < 	JK//////49HHHHHdiHHHIIr*   c                $    ddl m}  ||           S r   )r   r   r   s     r'   _eval_adjointzMatrixExpr._eval_adjoint   s"    >>>>>>wt}}r*   c                .    t          j        | ||          S r"   )r   _eval_derivative_n_times)rB   r   ns      r'   r   z#MatrixExpr._eval_derivative_n_times   s    -dAq999r*   c                    |                      |          r!t                                          |          S t          | j         S r"   )hassuper_eval_derivative
ZeroMatrixrC   )rB   r   	__class__s     r'   r   zMatrixExpr._eval_derivative   s:    88A;; 	+77++A...tz**r*   c                v    t          |dd          }|du r"t          d                    |                    dS )z2Helper function to check invalid matrix dimensionsT)integernonnegativeFz?The dimension specification {} should be a nonnegative integer.N)r   
ValueErrorformat)r9   dimoks      r'   
_check_dimzMatrixExpr._check_dim   sJ     sDdCCC;;))/6 6 6 ;r*   c                :    t          d| j        j        z            )NzIndexing not implemented for %s)r@   r   __name__rB   ijr;   s       r'   _entryzMatrixExpr._entry   s$    !-0GGI I 	Ir*   c                     t          |           S r"   )r   rA   s    r'   r   zMatrixExpr.adjoint   r   r*   c                    t           j        | fS )z1Efficiently extract the coefficient of a product.)r   One)rB   rationals     r'   as_coeff_MulzMatrixExpr.as_coeff_Mul   s    ud{r*   c                     t          |           S r"   )r   rA   s    r'   r   zMatrixExpr.conjugate   r   r*   c                $    ddl m}  ||           S )Nr   	transpose)$sympy.matrices.expressions.transposer   )rB   r   s     r'   r   zMatrixExpr.transpose   s"    BBBBBByr*   c                *    |                                  S )zMatrix transpositionr   rA   s    r'   TzMatrixExpr.T  s     ~~r*   c                Z    | j         du rt          d          |                                 S )NFzInverse of non-square matrix)r   r   r   rA   s    r'   inversezMatrixExpr.inverse	  s0    >U""&'EFFF!!###r*   c                *    |                                  S r"   r   rA   s    r'   invzMatrixExpr.inv  s    ||~~r*   c                $    ddl m}  ||           S )Nr   )det)&sympy.matrices.expressions.determinantr   )rB   r   s     r'   r   zMatrixExpr.det  s"    >>>>>>s4yyr*   c                *    |                                  S r"   r   rA   s    r'   IzMatrixExpr.I  s    ||~~r*   c                    d } ||          oQ ||          oF| j         d u p|| j          k    dk    o|| j         k     dk    o|| j         k    dk    o|| j        k     dk    S )Nc                R    t          | t          t          t          t          f          S r"   )r~   intr   r   r   )idxs    r'   is_validz(MatrixExpr.valid_index.<locals>.is_valid  s    cC&$#?@@@r*   F)ru   rz   )rB   r   r   r   s       r'   valid_indexzMatrixExpr.valid_index  s    	A 	A 	A H Hd" HtyjU*GDI%/GH tyjU*H 12DI%/G	Ir*   c                   t          |t                    s(t          |t                    rddlm}  || |d          S t          |t                    rt          |          dk    r|\  }}t          |t                    st          |t                    rddlm}  || ||          S t          |          t          |          }}|                     ||          dk    r|                     ||          S t          d|d|d          t          |t          t          f          r| j        \  }}t          |t                    st          t          d	                    t          |          }||z  }||z  }|                     ||          dk    r|                     ||          S t          d
|z            t          |t          t          f          rt          t          d                    t          d| z            )Nr   )MatrixSlice)r   Nry   r   FzInvalid indices (z, )zo
                    Single indexing is only supported when the number
                    of columns is known.zInvalid index %szj
                Only integers may be used when addressing the matrix
                with a single index.zInvalid index, wanted %s[i,j])r~   tupleslice sympy.matrices.expressions.slicer   lenr   r   r   
IndexErrorr   r   rC   r   r   r   )rB   keyr   r   r   ru   rz   s          r'   __getitem__zMatrixExpr.__getitem__!  s&   #u%% 	8*S%*@*@ 	8DDDDDD;tS,777c5!! 	*c#hh!mmDAq!U## /z!U';'; /HHHHHH"{4A...A;;qA1%%..{{1a((( jqqq!!!!DEEEj'233 	*JD$dG,, .  -, "- "- . . . 3--CtAd
A1%%..{{1a((( !3c!9:::fd^,, 	*Z )( ) ) * * * 84?@@@r*   c                    t          | j        t          t          f           p!t          | j        t          t          f           S r"   )r~   ru   r   r   rz   rA   s    r'   _is_shape_symboliczMatrixExpr._is_shape_symbolicD  s<    ty:w*?@@@ @di*g)>???	Ar*   c                                                       rt          d          ddlm}  | fdt	           j                  D                       S )a  
        Returns a dense Matrix with elements represented explicitly

        Returns an object of type ImmutableDenseMatrix.

        Examples
        ========

        >>> from sympy import Identity
        >>> I = Identity(3)
        >>> I
        I
        >>> I.as_explicit()
        Matrix([
        [1, 0, 0],
        [0, 1, 0],
        [0, 0, 1]])

        See Also
        ========
        as_mutable: returns mutable Matrix type

        z<Matrix with symbolic shape cannot be represented explicitly.r   ImmutableDenseMatrixc                T    g | ]#fd t          j                  D             $S )c                $    g | ]}|f         S r+   r+   )r   r   r   rB   s     r'   r   z5MatrixExpr.as_explicit.<locals>.<listcomp>.<listcomp>e  s1     &7 &7 &7 ! '+1a4j &7 &7 &7r*   )rangerz   r   r   rB   s    @r'   r   z*MatrixExpr.as_explicit.<locals>.<listcomp>e  sZ     %7 %7 %7 !&7 &7 &7 &7 &7%*49%5%5&7 &7 &7 %7 %7 %7r*   )r   r   sympy.matrices.immutabler   r   ru   )rB   r   s   ` r'   as_explicitzMatrixExpr.as_explicitH  s    0 ""$$ 	545 5 5 	BAAAAA## %7 %7 %7 %7%*49%5%5%7 %7 %7 8 8 	8r*   c                N    |                                                                  S )a  
        Returns a dense, mutable matrix with elements represented explicitly

        Examples
        ========

        >>> from sympy import Identity
        >>> I = Identity(3)
        >>> I
        I
        >>> I.shape
        (3, 3)
        >>> I.as_mutable()
        Matrix([
        [1, 0, 0],
        [0, 1, 0],
        [0, 0, 1]])

        See Also
        ========
        as_explicit: returns ImmutableDenseMatrix
        )r   
as_mutablerA   s    r'   r   zMatrixExpr.as_mutablei  s"    . !!,,...r*   c                    ddl m}  || j        t                    }t	          | j                  D ](}t	          | j                  D ]}| ||f         |||f<   )|S )Nr   )empty)dtype)numpyr   rC   objectr   ru   rz   )rB   r   r#   r   r   s        r'   	__array__zMatrixExpr.__array__  s}    E$*F+++ty!! 	% 	%A49%% % %q!t*!Q$%r*   c                P    |                                                      |          S )z
        Test elementwise equality between matrices, potentially of different
        types

        >>> from sympy import Identity, eye
        >>> Identity(3).equals(eye(3))
        True
        )r   equalsrW   s     r'   r   zMatrixExpr.equals  s$     !!((///r*   c                    | S r"   r+   rA   s    r'   canonicalizezMatrixExpr.canonicalize      r*   c                8    t           j        t          |           fS r"   )r   r   rK   rA   s    r'   as_coeff_mmulzMatrixExpr.as_coeff_mmul  s    ufTll""r*   c                    ddl m} ddlm} g }||                    |           ||                    |            || |          } ||          S )a  
        Parse expression of matrices with explicitly summed indices into a
        matrix expression without indices, if possible.

        This transformation expressed in mathematical notation:

        `\sum_{j=0}^{N-1} A_{i,j} B_{j,k} \Longrightarrow \mathbf{A}\cdot \mathbf{B}`

        Optional parameter ``first_index``: specify which free index to use as
        the index starting the expression.

        Examples
        ========

        >>> from sympy import MatrixSymbol, MatrixExpr, Sum
        >>> from sympy.abc import i, j, k, l, N
        >>> A = MatrixSymbol("A", N, N)
        >>> B = MatrixSymbol("B", N, N)
        >>> expr = Sum(A[i, j]*B[j, k], (j, 0, N-1))
        >>> MatrixExpr.from_index_summation(expr)
        A*B

        Transposition is detected:

        >>> expr = Sum(A[j, i]*B[j, k], (j, 0, N-1))
        >>> MatrixExpr.from_index_summation(expr)
        A.T*B

        Detect the trace:

        >>> expr = Sum(A[i, i], (i, 0, N-1))
        >>> MatrixExpr.from_index_summation(expr)
        Trace(A)

        More complicated expressions:

        >>> expr = Sum(A[i, j]*B[k, j]*A[l, k], (j, 0, N-1), (k, 0, N-1))
        >>> MatrixExpr.from_index_summation(expr)
        A*B.T*A.T
        r   )convert_indexed_to_arrayconvert_array_to_matrixN)first_indices)4sympy.tensor.array.expressions.from_indexed_to_arrayr  3sympy.tensor.array.expressions.from_array_to_matrixr	  append)exprfirst_index
last_index
dimensionsr  r	  r
  arrs           r'   from_index_summationzMatrixExpr.from_index_summation  s    T 	baaaaa______"  ---!  ,,,&&t=III&&s+++r*   c                &    ddl m}  |||           S )Nry   )ElementwiseApplyFunction)	applyfuncr  )rB   r%   r  s      r'   r  zMatrixExpr.applyfunc  s'    777777''d333r*   )r<   r=   )r<   r{   )TF)r<   r1   )NNN)Sr   
__module____qualname____doc__r0   __annotations__	_iterable_op_priorityr2   r3   r4   
is_Inverseis_Transposeis_ZeroMatrix	is_MatAdd	is_MatMulis_commutative	is_number	is_symbol	is_scalarr   r5   r8   propertyrC   rG   rL   rP   rR   r-   NotImplementedr   rX   rT   r^   r\   rc   re   r`   rh   rl   ri   rp   rn   ru   rz   r   r   r   r   r   r   r   r   r   r   r   r   classmethodr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  staticmethodr  r  __classcell__)r   s   @r'   r/   r/   $   s         $ "$I####
 ILIM!K!!!!JLMIINIII!z||D####3 3 3 " " " X"   X   X2 2 2" " " Z((:&&* * '& )(* Z((9%%* * &% )(* Z((:&&+ + '& )(+ Z((9%%+ + &% )(+ Z((:&&* * '& )(* Z((:&&* * '& )(* Z((9%%* * &% )(* Z((9%%* * &% )(* Z((:&&* * '& )(* Z((9%%> > &% )(> Z((>**+ + +* )(+ Z((=))$ $ *) )($   X   X    X( ( () ) ) )  
  ! ! !  ! ! !J J J  : : :+ + + + + 6 6 [6I I I              X $ $ $
       XI I I!A !A !AFA A A A8 8 8B/ / /2  	0 	0 	0  # # # 1, 1, 1, \1,f4 4 4 4 4 4 4r*   r/   c                    dS )NFr+   lhsrhss     r'   _eval_is_eqr0    s    5r*   c                B    | j         |j         k    rdS | |z
  j        rdS d S )NFT)rC   r   r-  s     r'   r0  r0    s4    
yCIuc	  t r*   c                      fd}|S )Nc                   t           t          t          t          i         }g }g }| j        D ]B}t          |t                    r|                    |           -|                    |           C|s                    |          S |rt           k    rbt          t          |                    D ]D}||         j        s5||                                                 |                    ||<   g } nEn0                    | ||                     d          gz             S |t          k    r ||                     d          S  |                    |          g|R                      d          S )NF)r   )r	   rK   r
   rF   r:   r~   r/   r  
_from_argsr   r   r3   rc   rO   )r  	mat_classnonmatricesmatricestermr   r9   s         r'   _postprocessorz)get_postprocessor.<locals>._postprocessor  s   &#v.s3	I 	) 	)D$
++ )%%%%""4(((( 	/>>+... 	]czzs8}}--  A#A;4  '/qk&9&9#..:U:U&V&V&( ~~kYY5I5N5NTY5N5Z5Z4[&[\\\9h',,%,888y44@x@@@EE5EQQQr*   r+   )r9   r9  s   ` r'   get_postprocessorr:    s*    "R "R "R "R "RF r*   )r	   r
   Fc                    t          | t                    st          |t                    rd}|rt          | |          S ddlm} ddlm} ddlm}  ||           } |||          } ||          }|S )NTr   )convert_matrix_to_array)array_deriver  )	r~   r    _matrix_derivative_old_algorithm3sympy.tensor.array.expressions.from_matrix_to_arrayr<  4sympy.tensor.array.expressions.arrayexpr_derivativesr=  r  r	  )	r  r   old_algorithmr<  r=  r	  
array_exprdiff_array_exprdiff_matrix_exprs	            r'   _matrix_derivativerE    s    $
## z!Z'@'@  9/a888[[[[[[QQQQQQ[[[[[[((..J"l:q11O..??r*   c                &  	
 ddl m} |                     |          }d |D             }ddlm	 	fd|D             }d fd

fd|D             }|d         }d	 |d
k    r t          j        fd|D                       S  || |          S )Nr   )ArrayDerivativec                6    g | ]}|                                 S r+   )buildr   r   s     r'   r   z4_matrix_derivative_old_algorithm.<locals>.<listcomp>#  s     &&&1QWWYY&&&r*   r  c                ,    g | ]}fd |D             S )c                &    g | ]} |          S r+   r+   )r   r   r	  s     r'   r   z?_matrix_derivative_old_algorithm.<locals>.<listcomp>.<listcomp>'  s%    444Q%%a((444r*   r+   )r   r   r	  s     r'   r   z4_matrix_derivative_old_algorithm.<locals>.<listcomp>'  s.    DDD4444!444DDDr*   c                >    t          | t                    r| j        S dS )Nry   ry   r~   r/   rC   elems    r'   
_get_shapez4_matrix_derivative_old_algorithm.<locals>._get_shape)  s!    dJ'' 	:tr*   c                :    t          fd| D                       S )Nc                4    g | ]} |          D ]}|d vS ))ry   Nr+   )r   r   r   rR  s      r'   r   zF_matrix_derivative_old_algorithm.<locals>.get_rank.<locals>.<listcomp>/  s3    MMM1zz!}}MM!AY&MMMMr*   )sum)partsrR  s    r'   get_rankz2_matrix_derivative_old_algorithm.<locals>.get_rank.  s&    MMMMMMMNNNr*   c                &    g | ]} |          S r+   r+   )r   r   rW  s     r'   r   z4_matrix_derivative_old_algorithm.<locals>.<listcomp>1  s!    (((QXXa[[(((r*   c                d   t          |           dk    r| d         S | d d         \  }}|j        r|j        }|t          d          k    r|}n|t          d          k    r|}n||z  }t          |           dk    r|S |j        rt	          d          |t          j        | dd                    z  S )Nry   r   r    )r   r2   r   Identityr   r	   fromiter)rV  p1p2pbases       r'   contract_one_dimsz;_matrix_derivative_old_algorithm.<locals>.contract_one_dims4  s    u::??8O2A2YFB| TXa[[  x{{""25zzQ? )$R..(S\%)4444r*   r   c                &    g | ]} |          S r+   r+   )r   r   r`  s     r'   r   z4_matrix_derivative_old_algorithm.<locals>.<listcomp>I  s%    AAAa..q11AAAr*   )$sympy.tensor.array.array_derivativesrG  _eval_derivative_matrix_linesr  r	  r
   r\  )r  r   rG  linesrV  ranksrankrR  r`  r	  rW  s          @@@@r'   r>  r>    s   DDDDDD..q11E&&&&&E[[[[[[DDDDeDDDE  
O O O O O )(((%(((E8D5 5 5( qyy|AAAA5AAABBB?4###r*   c                      e Zd Z ed           Z ed           Z ed           ZdZdZdZ	d Z
ed             Zd Zed             Zd	 Zd
S )MatrixElementc                    | j         d         S rs   r:   rA   s    r'   <lambda>zMatrixElement.<lambda>O  s    49Q< r*   c                    | j         d         S rx   rj  rA   s    r'   rk  zMatrixElement.<lambda>P      dil r*   c                    | j         d         S r   rj  rA   s    r'   rk  zMatrixElement.<lambda>Q  rm  r*   Tc                   t          t          ||f          \  }}ddlm} t	          |t
                    rt          |          }nt	          ||          r(|j        r|j        r
|||f         S t          |          }n8t          |          }t	          |j        t                    st          d           t          |dd           ||          st          d          t          j        | |||          }|S )Nr   r   z2First argument of MatrixElement should be a matrixr   c                    dS r}   r+   )r   ms     r'   rk  z'MatrixElement.__new__.<locals>.<lambda>d  s    T r*   zindices out of range)r7   r   sympy.matrices.matricesr   r~   strr   
is_Integerr5   r   	TypeErrorgetattrr   r   r8   )r9   namer   rr  r   objs         r'   r8   zMatrixElement.__new__V  s   8aV$$1666666dC   	9$<<DD$
++ Z< &AL &1:%~~~~!$)Z88 Z#$XYYYB740A0ABB1aHH 9 !7888l3a++
r*   c                    | j         d         S rs   rj  rA   s    r'   symbolzMatrixElement.symboli  s    y|r*   c                                         dd          }|rfd| j        D             }n| j        }|d         |d         |d         f         S )Nr   Tc                *    g | ]} |j         d i S )r+   )rO   )r   r,   r   s     r'   r   z&MatrixElement.doit.<locals>.<listcomp>p  s+    ;;;#HCH%%u%%;;;r*   r   ry   r   )getr:   )rB   r   r   r:   s    `  r'   rO   zMatrixElement.doitm  s^    yy&& 	;;;;;;;DD9DAwtAwQ'((r*   c                     | j         dd          S rx   rj  rA   s    r'   indiceszMatrixElement.indicesu  s    y}r*   c                   t          |t                    sSddlm} t          | j        |          r,| j                            |          | j        | j        f         S t          j	        S | j
        d         }| j        j        \  }}||j
        d         k    rYt          | j
        d         |j
        d         d|dz
  f          t          | j
        d         |j
        d         d|dz
  f          z  S t          |t                    rddlm} | j
        dd          \  }}t!          dt"                    \  }	}
|j
        d         }|j        \  }} ||||	f         ||	|
f                             |          z  ||
|f         z  |	d|dz
  f|
d|dz
  f           S |                     |j
        d                   rd S t          j	        S )Nr   rp  ry   r   )Sumzz1, z2)r9   )r~   rh  rs  r   parentdiffr   r   r   Zeror:   rC   r   r   sympy.concrete.summationsr  r   r   r   )rB   vr   Mrr  r   r  r   r   i1i2Yr1r2s                 r'   r   zMatrixElement._eval_derivativey  s   !]++ 	::::::$+z22 ;{''**4646>::6MIaL{ 1q	>>!$)A,q	Aqs8DD!$)A,q	Aqs8DDE E a!! 	[5555559QRR=DAqX5111FBq	AWFBC!R%2r6!2!221RU8;b!RT]RQRTVWXTXMZZZZ88AF1I 	4vr*   N)r   r  r  r'  r  r   r   	_diff_wrtr%  r#  r8   r{  rO   r  r   r+   r*   r'   rh  rh  N  s        X//00F**++A**++AIIN  &   X) ) )   X    r*   rh  c                  ~    e Zd ZdZdZdZdZd Zed             Z	ed             Z
d Zed             Zd	 Zd
 Zd ZdS )MatrixSymbola  Symbolic representation of a Matrix object

    Creates a SymPy Symbol to represent a Matrix. This matrix has a shape and
    can be included in Matrix Expressions

    Examples
    ========

    >>> from sympy import MatrixSymbol, Identity
    >>> A = MatrixSymbol('A', 3, 4) # A 3 by 4 Matrix
    >>> B = MatrixSymbol('B', 4, 3) # A 4 by 3 Matrix
    >>> A.shape
    (3, 4)
    >>> 2*A*B + Identity(3)
    I + 2*A*B
    FTc                   t          |          t          |          }}|                     |           |                     |           t          |t                    rt	          |          }t          j        | |||          }|S r"   )r   r   r~   rt  r   r   r8   )r9   rx  r   rr  ry  s        r'   r8   zMatrixSymbol.__new__  sr    {{HQKK1qqdC   	t99DmCq!,,
r*   c                6    | j         d         | j         d         fS )Nry   r   rj  rA   s    r'   rC   zMatrixSymbol.shape  s    y|TYq\))r*   c                &    | j         d         j        S rs   )r:   rx  rA   s    r'   rx  zMatrixSymbol.name  s    y|  r*   c                $    t          | ||          S r"   )rh  r   s       r'   r   zMatrixSymbol._entry  s    T1a(((r*   c                    | hS r"   r+   rA   s    r'   free_symbolszMatrixSymbol.free_symbols  s	    vr*   c                    | S r"   r+   )rB   r;   s     r'   r   zMatrixSymbol._eval_simplify  r  r*   c                N    t          | j        d         | j        d                   S Nr   ry   )r   rC   )rB   r   s     r'   r   zMatrixSymbol._eval_derivative  s    $*Q-A777r*   c                >   | |k    r| j         d         dk    r&t          |j         d         | j         d                   nt          j        }| j         d         dk    r&t          |j         d         | j         d                   nt          j        }t	          ||g          gS | j         d         dk    rt          | j         d                   nt          j        }| j         d         dk    rt          | j         d                   nt          j        }t	          ||g          gS r  )rC   r   r   r  _LeftRightArgsr[  r   )rB   r   firstseconds       r'   rc  z*MatrixSymbol._eval_derivative_matrix_lines  s   199=AZ]a=O=OJqwqz4:a=999UVU[E>Bjmq>P>PZ
DJqM:::VWV\F"    04z!}/A/AHTZ]+++quE04
10B0BXdjm,,,F"   r*   N)r   r  r  r  r#  r%  r  r8   r'  rC   rx  r   r  r   r   rc  r+   r*   r'   r  r    s           NII	 	 	 * * X* ! ! X!) ) )   X  8 8 8    r*   r  c                $    d | j         D             S )Nc                     g | ]}|j         	|S r+   )r2   )r   syms     r'   r   z"matrix_symbols.<locals>.<listcomp>  s    >>>C>C>>>r*   )r  r  s    r'   matrix_symbolsr    s    >>4,>>>>r*   c                      e Zd ZdZej        fdZed             Zej	        d             Zed             Z
e
j	        d             Z
d Zd Zed	             Zd
 Zd Zd Zd Zd Zd ZdS )r  a  
    Helper class to compute matrix derivatives.

    The logic: when an expression is derived by a matrix `X_{mn}`, two lines of
    matrix multiplications are created: the one contracted to `m` (first line),
    and the one contracted to `n` (second line).

    Transposition flips the side by which new matrices are connected to the
    lines.

    The trace connects the end of the two lines.
    c                    t          |          | _        | j        | _        d| _        d| _        | j        | _        d| _        d| _        || _        d S r  )	list_lines_first_pointer_parent_first_pointer_index_first_line_index_second_pointer_parent_second_pointer_index_second_line_indexhigher)rB   rd  r  s      r'   __init__z_LeftRightArgs.__init__  sN    5kk%)["$%!!"&*k#%&""#r*   c                &    | j         | j                 S r"   r  r  rA   s    r'   first_pointerz_LeftRightArgs.first_pointer  s    ()BCCr*   c                $    || j         | j        <   d S r"   r  rB   values     r'   r  z_LeftRightArgs.first_pointer  s    @E"4#<===r*   c                &    | j         | j                 S r"   r  r  rA   s    r'   second_pointerz_LeftRightArgs.second_pointer   s    *4+EFFr*   c                $    || j         | j        <   d S r"   r  r  s     r'   r  z_LeftRightArgs.second_pointer  s    BG#D$>???r*   c                F      fd j         D             }d|d j        dS )Nc                :    g | ]}                     |          S r+   _buildr   s     r'   r   z+_LeftRightArgs.__repr__.<locals>.<listcomp>	  s#    555AQ555r*   z_LeftRightArgs(lines=z	, higher=r   )r  r  )rB   builts   ` r'   __repr__z_LeftRightArgs.__repr__  s:    5555555EEKKK
 	
r*   c                    | j         | j        c| _        | _         | j        | j        c| _        | _        | j        | j        c| _        | _        | S r"   )r  r  r  r  r  r  rA   s    r'   r   z_LeftRightArgs.transpose  sR    BFB]_c_y?"D$?@D@Z\`\u=!4#=:>:QSWSi7 7r*   c                    t          | t                    r|                                 S t          | t                    r6t	          |           dk    r| d         S  | d         d | d         D              S | S )Nry   r   c                B    g | ]}t                               |          S r+   )r  r  rJ  s     r'   r   z)_LeftRightArgs._build.<locals>.<listcomp>  s&     K K Ka!6!6q!9!9 K K Kr*   )r~   r   rI  r  r   r  s    r'   r  z_LeftRightArgs._build  su    dK(( 	 ::<<dD!! 	4yyA~~AwtAw K K47 K K KLLKr*   c                      fd j         D             } j        dk    r|                      j                  gz  }t          |          }|S )Nc                :    g | ]}                     |          S r+   r  r   s     r'   r   z(_LeftRightArgs.build.<locals>.<listcomp>"  s#    4441A444r*   ry   )r  r  r  r  )rB   datas   ` r'   rI  z_LeftRightArgs.build!  sV    4444444;!T[[--..DDzzr*   c                   | j         dk    r| j        dk    rt          d          d } || j                   d          || j                  d         k    rf || j                  dk    r| j         | j        d         z  S  || j                   dk    r| j         d         | j        j        z  S t          d          | j         dk    r| j         | j        j        z  S | j        S )Nry   z.higher dimensional array cannot be representedc                >    t          | t                    r| j        S dS )N)NNrO  rP  s    r'   rR  z._LeftRightArgs.matrix_form.<locals>._get_shape,  s!    $
++ "z!<r*   rN  )r   r   zincompatible shapes)r  r  r   r  r   )rB   rR  s     r'   matrix_formz_LeftRightArgs.matrix_form(  s    :??t{a//MNNN	  	  	 
 :dj!!!$

4;(?(?(BBB z$+&&&00z$+d"333z$*%%//z$'552333:??:dkm++;r*   c                    d}| j         dk    r&|t          d | j         j        D                       z  }| j        dk    r&|t          d | j        j        D                       z  }| j        dk    r|dz  }|S )zl
        Number of dimensions different from trivial (warning: not related to
        matrix rank).
        r   ry   c                    g | ]}|d k    	S ry   r+   rJ  s     r'   r   z'_LeftRightArgs.rank.<locals>.<listcomp>E  s    :::Aa:::r*   c                    g | ]}|d k    	S r  r+   rJ  s     r'   r   z'_LeftRightArgs.rank.<locals>.<listcomp>G  s    ;;;Aa;;;r*   r   )r  rU  rC   r  r  )rB   rf  s     r'   rf  z_LeftRightArgs.rank>  s    
 :??C::)9:::;;;D;!C;;):;;;<<<D;!AIDr*   c                p    ddl m} ddl m} t          |t          |||g          dg|j                  }|S )N   )ArrayTensorProduct)ArrayContraction)ry   r   )	validator)*tensor.array.expressions.array_expressionsr  r  r   	_validate)rB   pointerrS   r  r  subexprs         r'   _multiply_pointerz _LeftRightArgs._multiply_pointerL  sq    TTTTTTRRRRRR&  	 '0
 
 
 r*   c                &    | xj         |z  c_         d S r"   )r  rW   s     r'   append_firstz_LeftRightArgs.append_firsta  s    e#r*   c                &    | xj         |z  c_         d S r"   )r  rW   s     r'   append_secondz_LeftRightArgs.append_secondd  s    u$r*   N)r   r  r  r  r   r   r  r'  r  setterr  r  r   r*  r  rI  r  rf  r  r  r  r+   r*   r'   r  r    sL         &'U     D D XD F F F G G XG H H H
 
 
   	 	 \	    ,    *$ $ $% % % % %r*   r  c                V    ddl m} t          | t                    r| S  || gg          S )Nr   r   )r   r   r~   r/   )r   r   s     r'   _make_matrixr  h  s@    ======!Z   !&&&r*   ry   rJ   rE   r   r   r   )r   r[  r   r"   r  )F
__future__r   	functoolsr   
sympy.corer   r   r   r	   r
   sympy.core.assumptionsr   sympy.core.decoratorsr   sympy.core.exprr   r   sympy.core.logicr   sympy.core.symbolr   r   r   r   sympy.core.sympifyr   r   sympy.external.gmpyr   sympy.functionsr   r   (sympy.functions.special.tensor_functionsr   sympy.matrices.commonr   rs  r   r   sympy.multipledispatchr   sympy.utilities.miscr   r-   r/   r0  r:  "_constructor_postprocessor_mappingrE  r>  rh  r  r  r  r  matmulrK   mataddrF   matpowrk   r   r   r   r   specialr   r[  determinantr   r+   r*   r'   <module>r     s   " " " " " "       2 2 2 2 2 2 2 2 2 2 2 2 2 2 4 4 4 4 4 4 7 7 7 7 7 7 - - - - - - - - & & & & & & 9 9 9 9 9 9 9 9 9 9 9 9 5 5 5 5 5 5 5 5 * * * * * * . . . . . . . . C C C C C C 6 6 6 6 6 6 : : : : : : : : + + + + + + + + + + + +    m4 m4 m4 m4 m4 m4 m4 m4` 
*d   
*j!!  "!$ $ $P c""#c""#8 8 ( 4   &,$ ,$ ,$^F F F F FD F F FRB B B B B: B B BJ? ? ?E% E% E% E% E% E% E% E%P' ' '                                     ) ) ) ) ) ) ) ) $ $ $ $ $ $ $ $r*   