
    gk                    ~   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j0        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 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     ^/var/www/html/ai-engine/env/lib/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dUd            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dVd2            Z.d3 Z/dWd4Z0d5 Z1d6 Z2d7 Z3d8 Z4d9 Z5d: Z6d; Z7d< Z8d= Z9 fd>Z:e;d?             Z<d@ Z=dA Z>dXdBZ?dC Z@dD ZAedE             ZBdF ZCdG ZDdH ZEedI             ZFdJ ZGdK ZHdYdLZIdM ZJdN ZKeLdfdOZMdP ZNdQ ZOdR ZPeQdZdS            ZRdT ZS xZTS )[
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__Q   s1    8T""}S242226222r*   returntuple[Expr, Expr]c                    t           r"   NotImplementedErrorselfs    r'   shapezMatrixExpr.shapeW   s    !!r*   c                    t           S r"   MatAddrA   s    r'   _add_handlerzMatrixExpr._add_handler[       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__c   s     amT**//111r*   c                    t           r"   r?   rA   s    r'   __abs__zMatrixExpr.__abs__f   s    !!r*   other__radd__c                F    t          | |                                          S r"   rF   rO   rB   rS   s     r'   __add__zMatrixExpr.__add__i         dE""'')))r*   rX   c                F    t          ||                                           S r"   rV   rW   s     r'   rT   zMatrixExpr.__radd__n         eT""'')))r*   __rsub__c                H    t          | |                                           S r"   rV   rW   s     r'   __sub__zMatrixExpr.__sub__s   s"     dUF##((***r*   r^   c                H    t          ||                                            S r"   rV   rW   s     r'   r\   zMatrixExpr.__rsub__x   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                    d S r"   r+   rA   s    r'   _eval_tracezMatrixExpr._eval_trace   s    tr*   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                    |j          o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)is_Floatr   
ValueErrorformat)r9   dimoks      r'   
_check_dimzMatrixExpr._check_dim   s^      1"34#1 #1 #1;;))/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_symbolicI  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>j  s1     &7 &7 &7 ! '+1a4j &7 &7 &7r*   )rangerz   r   r   rB   s    @r'   r   z*MatrixExpr.as_explicit.<locals>.<listcomp>j  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_explicitM  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_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   rC   objectr   ru   rz   )rB   r   copyr   r#   r   r   s          r'   	__array__zMatrixExpr.__array__  s    D[\\\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)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   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   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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 %4    	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_eqr5    s    5r*   c                B    | j         |j         k    rdS | |z
  j        rdS d S )NFT)rC   r%  r2  s     r'   r5  r5    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   r>  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_arrayrA  4sympy.tensor.array.expressions.arrayexpr_derivativesrB  r  r  )	r  r   old_algorithmrA  rB  r  
array_exprdiff_array_exprdiff_matrix_exprs	            r'   _matrix_derivativerJ    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_shape0  s!    dJ'' 	:tr*   c                :    t          fd| D                       S )Nc              3  <   K   | ]} |          D ]}|d vV  	dS )ry   NNr+   )r   r   r   rW  s      r'   	<genexpr>zE_matrix_derivative_old_algorithm.<locals>.get_rank.<locals>.<genexpr>6  s=      LL!jjmmLL1I%LLLLLLLr*   )sum)partsrW  s    r'   get_rankz2_matrix_derivative_old_algorithm.<locals>.get_rank5  s&    LLLLuLLLLLLr*   c                &    g | ]} |          S r+   r+   )r   r   r^  s     r'   r   z4_matrix_derivative_old_algorithm.<locals>.<listcomp>8  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)r]  p1p2pbases       r'   contract_one_dimsz;_matrix_derivative_old_algorithm.<locals>.contract_one_dims;  s    u::??8O2A2YFB| TXa[[  x{{""25zzQ? )$R..(S\%)4444r*   r   c                &    g | ]} |          S r+   r+   )r   r   rg  s     r'   r   z4_matrix_derivative_old_algorithm.<locals>.<listcomp>P  s%    AAAa..q11AAAr*   )$sympy.tensor.array.array_derivativesrL  _eval_derivative_matrix_linesr  r  r
   rc  )r  r   rL  linesr]  ranksrankrW  rg  r  r^  s          @@@@r'   rC  rC  &  s   DDDDDD..q11E&&&&&E[[[[[[DDDDeDDDE  
M M M M M )(((%(((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>V  s    49Q< r*   c                    | j         d         S rx   rq  rA   s    r'   rr  zMatrixElement.<lambda>W      dil r*   c                    | j         d         S r   rq  rA   s    r'   rr  zMatrixElement.<lambda>X  rt  r*   Tc                   t          t          ||f          \  }}t          |t                    rt	          |          }nt          |t
                    r(|j        r|j        r
|||f         S t          |          }n8t          |          }t          |j        t                    st          d           t          |dd           ||          st          d          t          j        | |||          }|S )Nz2First argument of MatrixElement should be a matrixr   c                    dS r}   r+   )r   ms     r'   rr  z'MatrixElement.__new__.<locals>.<lambda>j  s    T r*   zindices out of range)r7   r   r~   strr   r   
is_Integerr5   r   r   getattrr   r   r8   r9   namer   rx  objs        r'   r8   zMatrixElement.__new__]  s    8aV$$1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   rq  rA   s    r'   symbolzMatrixElement.symbolo  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>v  s+    ;;;#HCH%%u%%;;;r*   r   ry   r   )getr:   )rB   r   r   r:   s    `  r'   rO   zMatrixElement.doits  s^    yy&& 	;;;;;;;DD9DAwtAwQ'((r*   c                     | j         dd          S rx   rq  rA   s    r'   indiceszMatrixElement.indices{  s    y}r*   c                <   t          |t                    s,| 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                             |          z  ||	|f         z  |d|dz
  f|	d|dz
  f           S |                     |j        d                   rd S t          j        S )Nr   ry   r   )Sumzz1, z2)r9   )r~   ro  parentdiffr   r   r:   rC   r   r   sympy.concrete.summationsr  r   r   r   r   Zero)rB   vMrx  r   r  r   r   i1i2Yr1r2s                r'   r   zMatrixElement._eval_derivative  s   !]++ 	7;##A&&tvtv~66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'   ro  ro  U  s        X//00F**++A**++AIIN  $   X) ) )   X    r*   ro  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~   ry  r   r   r8   r|  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   rq  rA   s    r'   rC   zMatrixSymbol.shape  s    y|TYq\))r*   c                &    | j         d         j        S rs   )r:   r}  rA   s    r'   r}  zMatrixSymbol.name  s    y|  r*   c                $    t          | ||          S r"   )ro  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  _LeftRightArgsrb  r   )rB   r   firstseconds       r'   rj  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   r}  r   r  r   r   rj  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   rk  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  rO  s     r'   r   z)_LeftRightArgs._build.<locals>.<listcomp>   s&     K K Ka!6!6q!9!9 K K Kr*   )r~   r   rN  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'   rN  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)NNrT  rU  s    r'   rW  z._LeftRightArgs.matrix_form.<locals>._get_shape/  s!    $
++ "z!<r*   rS  )r   r   zincompatible shapes)r  r  r   r  r   )rB   rW  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              3  "   K   | ]
}|d k    V  dS rZ  r+   rO  s     r'   r[  z&_LeftRightArgs.rank.<locals>.<genexpr>H  s&      991Q999999r*   c              3  "   K   | ]
}|d k    V  dS rZ  r+   rO  s     r'   r[  z&_LeftRightArgs.rank.<locals>.<genexpr>J  s&      ::1Q::::::r*   r   )r  r\  rC   r  r  )rB   rm  s     r'   rm  z_LeftRightArgs.rankA  s    
 :??C99
(8999999D;!C::(9::::::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_pointerO  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_firstd  s    e#r*   c                &    | xj         |z  c_         d S r"   )r  rW   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  rN  r  rm  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  k  s@    ======!Z   !&&&r*   ry   rJ   rE   r   r   r   )r   rb  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/   r5  r?  "_constructor_postprocessor_mappingrJ  rC  ro  r  r  r  r  matmulrK   mataddrF   matpowrk   r   r   r   r   specialr   rb  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 : : : : : : * * * * * * 0 0 0 0 0 0 + + + + + + + + + + + +    s4 s4 s4 s4 s4 s4 s4 s4l 
*d   
*j!!  "!$ $ $P c""#c""#8 8 ( 4   &,$ ,$ ,$^B B B B BD B B BJB B B B B: B B BJ? ? ?E% E% E% E% E% E% E% E%P' ' '                                     ) ) ) ) ) ) ) ) $ $ $ $ $ $ $ $r*   