
    sgk                    J   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% d dl&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Z1d Z2 G d de      Z3 G d de-      Z4d  Z5 G d! d"      Z6d# Z7d$d%l8m9Z9 d$d&l:m;Z; d$d'l<m=Z= d$d(l>m?Z? d$d)l@mAZA d$d*lBmCZCmDZD d$d+lEmFZF y).    )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                2     t                fd       }|S )Nc                P    	 t        |      } | |      S # t        $ r cY S w xY wN)r   r   )abfuncretvals     U/var/www/html/venv/lib/python3.12/site-packages/sympy/matrices/expressions/matexpr.py__sympifyit_wrapperz5_sympifyit.<locals>.deco.<locals>.__sympifyit_wrapper   s1    QKAqz! 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dRd       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d.        Z-edSd/       Z.d0 Z/dTd1Z0d2 Z1d3 Z2d4 Z3d5 Z4d6 Z5d7 Z6d8 Z7d9 Z8d: Z9 fd;Z:e;d<        Z<d= Z=d> Z>dUd?Z?d@ Z@dA ZAedB        ZBdC ZCdD ZDdE ZEedF        ZFdG ZGdH ZHdVdIZIdJ ZJdK ZKeLdfdLZMdM ZNdN ZOdO ZPeQdWdP       ZRdQ ZS xZTS )X
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                T    t        t        |      }t        j                  | g|i |S r"   )mapr   r   __new__)clsargskwargss      r'   r8   zMatrixExpr.__new__Q   s'    8T"}}S242622r*   c                    t         r"   NotImplementedErrorselfs    r'   shapezMatrixExpr.shapeW   s    !!r*   c                    t         S r"   MatAddr?   s    r'   _add_handlerzMatrixExpr._add_handler[       r*   c                    t         S r"   MatMulr?   s    r'   _mul_handlerzMatrixExpr._mul_handler_   rF   r*   c                R    t        t        j                  |       j                         S r"   )rI   r   NegativeOnedoitr?   s    r'   __neg__zMatrixExpr.__neg__c   s    ammT*//11r*   c                    t         r"   r=   r?   s    r'   __abs__zMatrixExpr.__abs__f   s    !!r*   other__radd__c                6    t        | |      j                         S r"   rD   rM   r@   rQ   s     r'   __add__zMatrixExpr.__add__i        dE"''))r*   rV   c                6    t        ||       j                         S r"   rT   rU   s     r'   rR   zMatrixExpr.__radd__n        eT"''))r*   __rsub__c                8    t        | |       j                         S r"   rT   rU   s     r'   __sub__zMatrixExpr.__sub__s   s     dUF#((**r*   r\   c                8    t        ||        j                         S r"   rT   rU   s     r'   rZ   zMatrixExpr.__rsub__x   s     edU#((**r*   __rmul__c                6    t        | |      j                         S r"   rI   rM   rU   s     r'   __mul__zMatrixExpr.__mul__}   rW   r*   c                6    t        | |      j                         S r"   r`   rU   s     r'   
__matmul__zMatrixExpr.__matmul__   rW   r*   ra   c                6    t        ||       j                         S r"   r`   rU   s     r'   r^   zMatrixExpr.__rmul__   rY   r*   c                6    t        ||       j                         S r"   r`   rU   s     r'   __rmatmul__zMatrixExpr.__rmatmul__   rY   r*   __rpow__c                6    t        | |      j                         S r"   )MatPowrM   rU   s     r'   __pow__zMatrixExpr.__pow__   rW   r*   rj   c                    t        d      )NzMatrix Power not definedr=   rU   s     r'   rg   zMatrixExpr.__rpow__   s     ""<==r*   __rtruediv__c                .    | |t         j                  z  z  S r"   )r   rL   rU   s     r'   __truediv__zMatrixExpr.__truediv__   s     eQ]]***r*   rn   c                    t               r"   r=   rU   s     r'   rl   zMatrixExpr.__rtruediv__   s     "##r*   c                     | j                   d   S Nr   rA   r?   s    r'   rowszMatrixExpr.rows       zz!}r*   c                     | j                   d   S N   rr   r?   s    r'   colszMatrixExpr.cols   rt   r*   c                x    | j                   \  }}t        |t              rt        |t              r||k(  S ||k(  ryy NT)rA   
isinstancer   )r@   rs   rx   s      r'   	is_squarezMatrixExpr.is_square   s9    ZZ
ddG$D')B4<4<r*   c                0    ddl m}  |t        |             S Nr   )Adjoint)"sympy.matrices.expressions.adjointr   	Transposer@   r   s     r'   _eval_conjugatezMatrixExpr._eval_conjugate   s    >y''r*   c                "    | j                         S r"   )_eval_as_real_imag)r@   deephintss      r'   as_real_imagzMatrixExpr.as_real_imag   s    &&((r*   c                    t         j                  | | j                         z   z  }| | j                         z
  dt         j                  z  z  }||fS N   )r   Halfr   ImaginaryUnit)r@   realims      r'   r   zMatrixExpr._eval_as_real_imag   sI    vv 4 4 667T))++a.?@bzr*   c                    t        |       S r"   Inverser?   s    r'   _eval_inversezMatrixExpr._eval_inverse       t}r*   c                    t        |       S r"   Determinantr?   s    r'   _eval_determinantzMatrixExpr._eval_determinant   s    4  r*   c                    t        |       S r"   r   r?   s    r'   _eval_transposezMatrixExpr._eval_transpose       r*   c                     y r"   r+   r?   s    r'   _eval_tracezMatrixExpr._eval_trace   s    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.
        ri   )r@   exps     r'   _eval_powerzMatrixExpr._eval_power   s    
 dC  r*   c           
         | j                   r| S ddlm}  | j                  | j                  D cg c]  } ||fi | c} S c c}w )Nr   )simplify)is_Atomsympy.simplifyr   r%   r:   )r@   r;   r   xs       r'   _eval_simplifyzMatrixExpr._eval_simplify   s>    <<K/499diiHx4V4HIIHs   Ac                    ddl m}  ||       S r~   )r   r   r   s     r'   _eval_adjointzMatrixExpr._eval_adjoint   s    >t}r*   c                0    t        j                  | ||      S r"   )r   _eval_derivative_n_times)r@   r   ns      r'   r   z#MatrixExpr._eval_derivative_n_times   s    --dAq99r*   c                h    | j                  |      rt        | 	  |      S t        | j                   S r"   )hassuper_eval_derivative
ZeroMatrixrA   )r@   r   	__class__s     r'   r   zMatrixExpr._eval_derivative   s-    88A;7+A..tzz**r*   c                z    |j                    xr t        |dd      }|du rt        dj                  |            y)z2Helper function to check invalid matrix dimensionsT)integernonnegativeFz?The dimension specification {} should be a nonnegative integer.N)is_Floatr   
ValueErrorformat)r9   dimoks      r'   
_check_dimzMatrixExpr._check_dim   sK      1"34#1;))/6 6 r*   c                F    t        d| j                  j                  z        )NzIndexing not implemented for %s)r>   r   __name__r@   ijr;   s       r'   _entryzMatrixExpr._entry   s#    !-0G0GGI 	Ir*   c                    t        |       S r"   )r   r?   s    r'   r   zMatrixExpr.adjoint   r   r*   c                &    t         j                  | fS )z1Efficiently extract the coefficient of a product.)r   One)r@   rationals     r'   as_coeff_MulzMatrixExpr.as_coeff_Mul   s    uud{r*   c                    t        |       S r"   )r   r?   s    r'   r   zMatrixExpr.conjugate  r   r*   c                    ddl m}  ||       S )Nr   	transpose)$sympy.matrices.expressions.transposer   )r@   r   s     r'   r   zMatrixExpr.transpose  s    Br*   c                "    | j                         S )zMatrix transpositionr   r?   s    r'   TzMatrixExpr.T	  s     ~~r*   c                T    | j                   du rt        d      | j                         S )NFzInverse of non-square matrix)r|   r   r   r?   s    r'   inversezMatrixExpr.inverse  s)    >>U"&'EFF!!##r*   c                "    | j                         S r"   r   r?   s    r'   invzMatrixExpr.inv  s    ||~r*   c                    ddl m}  ||       S )Nr   )det)&sympy.matrices.expressions.determinantr   )r@   r   s     r'   r   zMatrixExpr.det  s    >4yr*   c                "    | j                         S r"   r   r?   s    r'   IzMatrixExpr.I  s    ||~r*   c                    d } ||      xrj  ||      xr` | j                   d u xs' || j                    k\  dk7  xr || j                   k  dk7  xr' || j                   k\  dk7  xr || j                  k  dk7  S )Nc                B    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)rs   rx   )r@   r   r   r   s       r'   valid_indexzMatrixExpr.valid_index  s    	A H Hd" HtyyjU*GDII%/GH tyyjU*H 12DII%/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        |      }}| j                  ||      dk7  r| j                  ||      S t        d|d|d      t        |t        t        f      r}| j                  \  }}t        |t              st        t        d	            t        |      }||z  }||z  }| j                  ||      dk7  r| j                  ||      S t        d
|z        t        |t        t        f      rt        t        d            t        d| z        )Nr   )MatrixSlice)r   Nrw   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   rA   r   r   r   )r@   keyr   r   r   rs   rx   s          r'   __getitem__zMatrixExpr.__getitem__&  s}   #u%*S%*@DtS,77c5!c#h!mDAq!U#z!U';H"4A..A;qA1%.{{1a(( q!!DEEj'23JD$dG,  -, "- . . 3-CtAd
A1%.{{1a(( !3c!9::fd^,Z )( ) * * 84?@@r*   c                    t        | j                  t        t        f       xs! t        | j                  t        t        f       S r"   )r{   rs   r   r   rx   r?   s    r'   _is_shape_symboliczMatrixExpr._is_shape_symbolicI  s:    tyy:w*?@@ @dii*g)>??	Ar*   c                    | j                         rt        d      ddlm}  |t	        | j
                        D cg c]*  }t	        | j                        D cg c]	  }| ||f    c}, c}}      S c c}w c c}}w )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   ImmutableDenseMatrix)r   r   sympy.matrices.immutabler   rangers   rx   )r@   r   r   r   s       r'   as_explicitzMatrixExpr.as_explicitM  s    0 ""$45 5 	B#%*499%5%7 ! &+499%5&7 ! '+1a4j &7 %7 8 	8 &7 %7s   A8
A3&A8
3A8
c                >    | j                         j                         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_mutabler?   s    r'   r   zMatrixExpr.as_mutablen  s    . !,,..r*   c                    ||st        d      ddlm}  || j                  t              }t        | j                        D ](  }t        | j                        D ]  }| ||f   |||f<    * |S )Nz=Cannot implement copy=False when converting Matrix to ndarrayr   )empty)dtype)	TypeErrornumpyr   rA   objectr   rs   rx   )r@   r   copyr   r#   r   r   s          r'   	__array__zMatrixExpr.__array__  su    D[\\$**F+tyy! 	%A499% %q!t*!Q$%	% r*   c                @    | j                         j                  |      S )z
        Test elementwise equality between matrices, potentially of different
        types

        >>> from sympy import Identity, eye
        >>> Identity(3).equals(eye(3))
        True
        )r   equalsrU   s     r'   r   zMatrixExpr.equals  s     !((//r*   c                    | S r"   r+   r?   s    r'   canonicalizezMatrixExpr.canonicalize      r*   c                8    t         j                  t        |       fS r"   )r   r   rI   r?   s    r'   as_coeff_mmulzMatrixExpr.as_coeff_mmul  s    uufTl""r*   c                    ddl m} ddlm} g }||j	                  |       ||j	                  |        || |      } ||      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_matrix)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  sP    T 	b_"  -!  ,&t=I&s++r*   c                     ddl m}  |||       S )Nrw   )ElementwiseApplyFunction)	applyfuncr  )r@   r%   r  s      r'   r  zMatrixExpr.applyfunc  s    7'd33r*   )returnztuple[Expr, Expr])r  zbool | None)TF)r  r1   )NNN)Ur   
__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   propertyrA   rE   rJ   rN   rP   r-   NotImplementedr   rV   rR   r\   rZ   ra   rc   r^   rf   rj   rg   rn   rl   rs   rx   r|   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   r  staticmethodr  r  __classcell__)r   s   @r'   r/   r/   %   s   $ "$I#
 ILItM4!K!JLMIINIII!|D*#3 " "    2" (:&* ' )* (9%* & )* (:&+ ' )+ (9%+ & )+ (:&* ' )* (:&* ' )* (9%* & )* (9%* & )* (:&* ' )* (9%> & )> (>*+ + )+ (=)$ * )$      ()
!!J:+ 6 6I    $
  I!AFA8B/2 %4 	0# 1, 1,f4r*   r/   c                     y)NFr+   lhsrhss     r'   _eval_is_eqr-    s    r*   c                X    | j                   |j                   k7  ry| |z
  j                  ryy )NFT)rA   r  r*  s     r'   r-  r-    s*    
yyCIIc	   !r*   c                      fd}|S )Nc                   t         t        t        t        i   }g }g }| j                  D ]5  }t        |t              r|j                  |       %|j                  |       7 |sj                  |      S |rt         k(  rSt        t        |            D ];  }||   j                  r||   j                  j                  |            ||<   g } n* n(j                  | || j                  d      gz         S |t        k(  r || j                  d      S  |j                  |      g| j                  d      S )NF)r   )r	   rI   r
   rD   r:   r{   r/   r	  
_from_argsr   r   r3   ra   rM   )r
  	mat_classnonmatricesmatricestermr   r9   s         r'   _postprocessorz)get_postprocessor.<locals>._postprocessor  s:   &#v.s3	II 	)D$
+%""4(		) >>+..czs8}- A#A;44 '/qk&9&9#..:U&V&( ~~kY5I5N5NTY5N5Z4[&[\\h',,%,884@x@EE5EQQr*   r+   )r9   r6  s   ` r'   get_postprocessorr7    s    "RF r*   )r	   r
   c                    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_arrayr9  4sympy.tensor.array.expressions.arrayexpr_derivativesr:  r  r  )	r
  r   old_algorithmr9  r:  r  
array_exprdiff_array_exprdiff_matrix_exprs	            r'   _matrix_derivativerB    sZ    $
#z!Z'@/a88[Q[(.J":q1O.?r*   c           
        ddl m} | j                  |      }|D cg c]  }|j                          }}ddlm} |D cg c]  }|D cg c]
  } ||       c} }}}d fd}|D cg c]
  } ||       }	}|	d   }
d }|
dk  r)t        j                  |D cg c]
  } ||       c}      S  || |      S c c}w c c}w c c}}w c c}w c c}w )Nr   )ArrayDerivativer  c                <    t        | t              r| j                  S y)Nrw   rw   r{   r/   rA   elems    r'   
_get_shapez4_matrix_derivative_old_algorithm.<locals>._get_shape0  s    dJ'::r*   c                ,    t        fd| D              S )Nc              3  @   K   | ]  } |      D ]  }|d v 
  yw)rw   NNr+   ).0r   r   rJ  s      r'   	<genexpr>zE_matrix_derivative_old_algorithm.<locals>.get_rank.<locals>.<genexpr>6  s'     L!jmL1I%L%Ls   )sum)partsrJ  s    r'   get_rankz2_matrix_derivative_old_algorithm.<locals>.get_rank5  s    LuLLLr*   c                :   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 )Nrw   r   r    )r   r2   r   Identityr   r	   fromiter)rQ  p1p2pbases       r'   contract_one_dimsz;_matrix_derivative_old_algorithm.<locals>.contract_one_dims;  s    u:?8O2AYFB||TTXa[ x{"25zQ??$R.(S\\%)444r*   r   )$sympy.tensor.array.array_derivativesrD  _eval_derivative_matrix_linesbuildr  r  r
   rV  )r
  r   rD  linesr   rQ  r  r   rR  ranksrankrZ  rJ  s               @r'   r;  r;  &  s    D..q1E %&1QWWY&E&[>CD!4Q%a(4DED
M #((QXa[(E(8D5( qy||5Aa.q1ABB4##Q ' 5D )0 Bs)   B=	C
CC-CCC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y
)MatrixElementc                     | j                   d   S rq   r:   r?   s    r'   <lambda>zMatrixElement.<lambda>V  s    499Q< r*   c                     | j                   d   S rv   rd  r?   s    r'   re  zMatrixElement.<lambda>W      diil r*   c                     | j                   d   S r   rd  r?   s    r'   re  zMatrixElement.<lambda>X  rg  r*   Tc                   t        t        ||f      \  }}t        |t              rt	        |      }nt        |t
              r+|j                  r|j                  r|||f   S t        |      }n0t        |      }t        |j                  t              st        d       t        |dd       ||      st        d      t        j                  | |||      }|S )Nz2First argument of MatrixElement should be a matrixr   c                     yrz   r+   )r   ms     r'   re  z'MatrixElement.__new__.<locals>.<lambda>j  s    r*   zindices out of range)r7   r   r{   strr   r   
is_Integerr5   r   r   getattrr   r   r8   r9   namer   rk  objs        r'   r8   zMatrixElement.__new__]  s    8aV$1dC $<D$
+<<ALL1:%~~!$))Z8#$XYYB740AB1aH !788ll3a+
r*   c                     | j                   d   S rq   rd  r?   s    r'   symbolzMatrixElement.symbolo  s    yy|r*   c                    |j                  dd      }|r*| j                  D cg c]  } |j                  di | }}n| j                  }|d   |d   |d   f   S c c}w )Nr   Tr   rw   r   r+   )getr:   rM   )r@   r   r   r,   r:   s        r'   rM   zMatrixElement.doits  sd    yy&15;#HCHH%u%;D;99DAwtAwQ'(( <s   Ac                     | j                   dd  S rv   rd  r?   s    r'   indiceszMatrixElement.indices{  s    yy}r*   c                8   t        |t              s4| j                  j                  |      | j                  | j
                  f   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   j                  |      z  ||	|f   z  |d|dz
  f|	d|dz
  f       S | j                  |j                  d         ry t        j                   S )Nr   rw   r   )Sumzz1, z2)r9   )r{   rb  parentdiffr   r   r:   rA   r   r   sympy.concrete.summationsry  r   r   r   r   Zero)r@   vMrk  r   ry  r   r   i1i2Yr1r2s                r'   r   zMatrixElement._eval_derivative  sv   !]+;;##A&tvvtvv~66IIaL{{  1q	>!$))A,q	Aqs8D!$))A,q	Aqs8DE E a!599QR=DAqX51FBq	AWWFB!R%2r6!221RU8;b!RT]RQRTVWXTXMZZZ88AFF1Ivvr*   N)r   r  r  r$  rz  r   r   	_diff_wrtr"  r   r8   rs  rM   rw  r   r+   r*   r'   rb  rb  U  si    /0F*+A*+AIIN$  )  r*   rb  c                  j    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y)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        |      }}| j                  |       | j                  |       t        |t              rt	        |      }t        j                  | |||      }|S r"   )r   r   r{   rl  r   r   r8   ro  s        r'   r8   zMatrixSymbol.__new__  sW    {HQK1qqdC t9DmmCq!,
r*   c                >    | j                   d   | j                   d   fS )Nrw   r   rd  r?   s    r'   rA   zMatrixSymbol.shape  s    yy|TYYq\))r*   c                4    | j                   d   j                  S rq   )r:   rp  r?   s    r'   rp  zMatrixSymbol.name  s    yy|   r*   c                    t        | ||      S r"   )rb  r   s       r'   r   zMatrixSymbol._entry  s    T1a((r*   c                    | hS r"   r+   r?   s    r'   free_symbolszMatrixSymbol.free_symbols  s	    vr*   c                    | S r"   r+   )r@   r;   s     r'   r   zMatrixSymbol._eval_simplify  r   r*   c                N    t        | j                  d   | j                  d         S Nr   rw   )r   rA   )r@   r   s     r'   r   zMatrixSymbol._eval_derivative  s    $**Q-A77r*   c                L   | |k7  r| j                   d   dk7  r&t        |j                   d   | j                   d         nt        j                  }| j                   d   dk7  r&t        |j                   d   | j                   d         nt        j                  }t	        ||g      gS | j                   d   dk7  rt        | j                   d         nt        j                  }| j                   d   dk7  rt        | j                   d         nt        j                  }t	        ||g      gS r  )rA   r   r   r}  _LeftRightArgsrU  r   )r@   r   firstseconds       r'   r\  z*MatrixSymbol._eval_derivative_matrix_lines  s    19=AZZ]a=OJqwwqz4::a=9UVU[U[E>Bjjmq>PZ
DJJqM:VWV\V\F"   04zz!}/AHTZZ]+quuE04

10BXdjjm,F"  r*   N)r   r  r  r  r   r"  r  r8   r$  rA   rp  r   r  r   r   r\  r+   r*   r'   r  r    sm      NII	 * * ! !)  8r*   r  c                Z    | j                   D cg c]  }|j                  s| c}S c c}w r"   )r  r2   )r
  syms     r'   matrix_symbolsr    s"    ,,>CC>>>s   ((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y)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| _        || _        y r  )	list_lines_first_pointer_parent_first_pointer_index_first_line_index_second_pointer_parent_second_pointer_index_second_line_indexhigher)r@   r^  r  s      r'   __init__z_LeftRightArgs.__init__  sL    5k%)[["$%!!"&*kk#%&""#r*   c                4    | j                   | j                     S r"   r  r  r?   s    r'   first_pointerz_LeftRightArgs.first_pointer  s    (()B)BCCr*   c                6    || j                   | j                  <   y r"   r  r@   values     r'   r  z_LeftRightArgs.first_pointer  s    @E""4#<#<=r*   c                4    | j                   | j                     S r"   r  r  r?   s    r'   second_pointerz_LeftRightArgs.second_pointer  s    **4+E+EFFr*   c                6    || j                   | j                  <   y r"   r  r  s     r'   r  z_LeftRightArgs.second_pointer  s    BG##D$>$>?r*   c                    | j                   D cg c]  }| j                  |       }}d|d| j                  dS c c}w )Nz_LeftRightArgs(lines=z	, higher=r   )r  _buildr  )r@   r   builts      r'   __repr__z_LeftRightArgs.__repr__  s:    )-5AQ55KK
 	
 6s   <c                    | j                   | j                  c| _        | _         | j                  | j                  c| _        | _        | j                  | j
                  c| _        | _        | S r"   )r  r  r  r  r  r  r?   s    r'   r   z_LeftRightArgs.transpose  sd    BFB]B]_c_y_y?"D$?@D@Z@Z\`\u\u=!4#=:>:Q:QSWSiSi7 7r*   c                    t        | t              r| j                         S t        | t              r?t	        |       dk(  r| d   S  | d   | d   D cg c]  }t
        j                  |       c} S | S c c}w )Nrw   r   )r{   r   r]  r  r   r  r  )r
  r   s     r'   r  z_LeftRightArgs._build  sl    dK(::<dD!4yA~AwtAw47 Ka!6!6q!9 KLLK !Ls   A2c                    | j                   D cg c]  }| j                  |       }}| j                  dk7  r|| j                  | j                        gz  }t        |      }|S c c}w rv   )r  r  r  r  )r@   r   datas      r'   r]  z_LeftRightArgs.build$  sZ    (,41A44;;!T[[-..DDz	 5s   A$c                   | j                   dk7  r| j                  dk7  rt        d      d } || j                         d    || j                        d   k7  rw || j                        dk(  r| j                   | j                  d   z  S  || j                         dk(  r&| j                   d   | j                  j                  z  S t        d      | j                   dk7  r#| j                   | j                  j                  z  S | j                  S )Nrw   z.higher dimensional array cannot be representedc                <    t        | t              r| j                  S y)N)NNrG  rH  s    r'   rJ  z._LeftRightArgs.matrix_form.<locals>._get_shape/  s    $
+zz!r*   rF  )r   r   zincompatible shapes)r  r  r   r  r   )r@   rJ  s     r'   matrix_formz_LeftRightArgs.matrix_form+  s    ::?t{{a/MNN	 
 djj!!$
4;;(?(BB $++&&0zz$++d"333$**%/zz$'55233::?::dkkmm++;;r*   c                   d}| j                   dk7  r)|t        d | j                   j                  D              z  }| j                  dk7  r)|t        d | j                  j                  D              z  }| j                  dk7  r|dz  }|S )zl
        Number of dimensions different from trivial (warning: not related to
        matrix rank).
        r   rw   c              3  &   K   | ]	  }|d k7    ywrM  r+   rN  r   s     r'   rO  z&_LeftRightArgs.rank.<locals>.<genexpr>H  s     91Q9   c              3  &   K   | ]	  }|d k7    ywrM  r+   r  s     r'   rO  z&_LeftRightArgs.rank.<locals>.<genexpr>J  s     :1Q:r  r   )r  rP  rA   r  r  )r@   r`  s     r'   r`  z_LeftRightArgs.rankA  sx    
 ::?C9

(8(8999D;;!C:(9(9:::D;;!AIDr*   c                j    ddl m} ddl m} t        |t        |||g      dg|j                        }|S )N   )ArrayTensorProduct)ArrayContraction)rw   r   )	validator)*tensor.array.expressions.array_expressionsr  r  r   	_validate)r@   pointerrQ   r  r  subexprs         r'   _multiply_pointerz _LeftRightArgs._multiply_pointerO  sG    TR& 	 '00
 r*   c                .    | xj                   |z  c_         y r"   )r  rU   s     r'   append_firstz_LeftRightArgs.append_firstd  s    e#r*   c                .    | xj                   |z  c_         y r"   )r  rU   s     r'   append_secondz_LeftRightArgs.append_secondg  s    u$r*   N)r   r  r  r  r   r   r  r$  r  setterr  r  r   r'  r  r]  r  r`  r  r  r  r+   r*   r'   r  r    s     &'UU  D D F F G G H H
 	 	,*$%r*   r  c                F    ddl m} t        | t              r| S  || gg      S )Nr   r   )r   r   r{   r/   )r   r   s     r'   _make_matrixr  k  s#    =!Z !&&r*   rw   rH   rC   r   r   r   )r   rU  r   r"   r  )G
__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.exceptionsr   sympy.matrices.kindr   sympy.matrices.matrixbaser   sympy.multipledispatchr   sympy.utilities.miscr   r-   r/   r-  r7  "_constructor_postprocessor_mappingrB  r;  rb  r  r  r  r  matmulrI   mataddrD   matpowri   r   r   r   r   specialr   rU  determinantr   r+   r*   r'   <module>r     s   "  2 2 4 7 - & 9 9 5 * . C : * 0 + + s4 s4l 
*d  
*j! "$P c"#c"#8 ( ( 4&,$^BD BJB: BJ?E% E%P'       ) $r*   