
    geJ                         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
 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Zd dlmZ  G d de          Z G d de          Z G d dee          Zd
S )    )Basic)DictTuple)Expr)Kind
NumberKindUndefinedKind)Integer)S)sympify)
SYMPY_INTS)	PrintableN)Iterablec                   D     e Zd ZdZef fd	Zd Zedd            Z xZ	S )	ArrayKinda  
    Kind for N-dimensional array in SymPy.

    This kind represents the multidimensional array that algebraic
    operations are defined. Basic class for this kind is ``NDimArray``,
    but any expression representing the array can have this.

    Parameters
    ==========

    element_kind : Kind
        Kind of the element. Default is :obj:NumberKind `<sympy.core.kind.NumberKind>`,
        which means that the array contains only numbers.

    Examples
    ========

    Any instance of array class has ``ArrayKind``.

    >>> from sympy import NDimArray
    >>> NDimArray([1,2,3]).kind
    ArrayKind(NumberKind)

    Although expressions representing an array may be not instance of
    array class, it will have ``ArrayKind`` as well.

    >>> from sympy import Integral
    >>> from sympy.tensor.array import NDimArray
    >>> from sympy.abc import x
    >>> intA = Integral(NDimArray([1,2,3]), x)
    >>> isinstance(intA, NDimArray)
    False
    >>> intA.kind
    ArrayKind(NumberKind)

    Use ``isinstance()`` to check for ``ArrayKind` without specifying
    the element kind. Use ``is`` with specifying the element kind.

    >>> from sympy.tensor.array import ArrayKind
    >>> from sympy.core import NumberKind
    >>> boolA = NDimArray([True, False])
    >>> isinstance(boolA.kind, ArrayKind)
    True
    >>> boolA.kind is ArrayKind(NumberKind)
    False

    See Also
    ========

    shape : Function to return the shape of objects with ``MatrixKind``.

    c                 Z    t                                          | |          }||_        |S N)super__new__element_kind)clsr   obj	__class__s      Y/var/www/html/ai-engine/env/lib/python3.11/site-packages/sympy/tensor/array/ndim_array.pyr   zArrayKind.__new__D   s'    ggooc<00'
    c                     d| j         z  S )NzArrayKind(%s))r   selfs    r   __repr__zArrayKind.__repr__I   s    !222r   returnc                 v    d |D             }t          |          dk    r|\  }nt          }t          |          S )Nc                     h | ]	}|j         
S  )kind).0es     r   	<setcomp>z#ArrayKind._union.<locals>.<setcomp>N   s    ,,,af,,,r      )lenr	   r   )r   kinds
elem_kindselemkinds       r   _unionzArrayKind._unionL   sB    ,,e,,,
z??a"IHH$H"""r   )r    r   )
__name__
__module____qualname____doc__r   r   r   classmethodr-   __classcell__)r   s   @r   r   r      s|        3 3h #-      
3 3 3 # # # [# # # # #r   r   c                   B   e Zd ZdZdZdZd+dZd Zd Zd Z	d	 Z
d
 Zed             Zed,d            Zd Zed             Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Z d Z!d Z"d  Z#d! Z$d" Z%d# Z&d$ Z'd% Z(d& Z)d' Z*d( Z+ed)             Z,d* Z-dS )-	NDimArraya  N-dimensional array.

    Examples
    ========

    Create an N-dim array of zeros:

    >>> from sympy import MutableDenseNDimArray
    >>> a = MutableDenseNDimArray.zeros(2, 3, 4)
    >>> a
    [[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]]

    Create an N-dim array from a list;

    >>> a = MutableDenseNDimArray([[2, 3], [4, 5]])
    >>> a
    [[2, 3], [4, 5]]

    >>> b = MutableDenseNDimArray([[[1, 2], [3, 4], [5, 6]], [[7, 8], [9, 10], [11, 12]]])
    >>> b
    [[[1, 2], [3, 4], [5, 6]], [[7, 8], [9, 10], [11, 12]]]

    Create an N-dim array from a flat list with dimension shape:

    >>> a = MutableDenseNDimArray([1, 2, 3, 4, 5, 6], (2, 3))
    >>> a
    [[1, 2, 3], [4, 5, 6]]

    Create an N-dim array from a matrix:

    >>> from sympy import Matrix
    >>> a = Matrix([[1,2],[3,4]])
    >>> a
    Matrix([
    [1, 2],
    [3, 4]])
    >>> b = MutableDenseNDimArray(a)
    >>> b
    [[1, 2], [3, 4]]

    Arithmetic operations on N-dim arrays

    >>> a = MutableDenseNDimArray([1, 1, 1, 1], (2, 2))
    >>> b = MutableDenseNDimArray([4, 4, 4, 4], (2, 2))
    >>> c = a + b
    >>> c
    [[5, 5], [5, 5]]
    >>> a - b
    [[-3, -3], [-3, -3]]

    TFNc                 "    ddl m}  |||fi |S )Nr   )ImmutableDenseNDimArray)sympy.tensor.arrayr7   )r   iterableshapekwargsr7   s        r   r   zNDimArray.__new__   s/    >>>>>>&&xAA&AAAr   c                      t          d          )Nz4A subclass of NDimArray should implement __getitem__NotImplementedErrorr   indexs     r   __getitem__zNDimArray.__getitem__   s    !"XYYYr   c                     t          |t          t          f          r|| j        k    rt	          d          |S | j        dk    rt	          d          t          |          | j        k    rt	          d          d}t          | j                  D ]}}||         | j        |         k    s||         | j        |          k     r"t	          dt          |          z   dz             ||         dk     r|dz  }|| j        |         z  ||         z   }~|S )NzOnly a tuple index is acceptedr   z#Index not valid with an empty arrayzWrong number of array axeszIndex z out of borderr(   )

isinstancer   r
   
_loop_size
ValueErrorr)   _rankranger:   str)r   r@   
real_indexis       r   _parse_indexzNDimArray._parse_index   s   ej'233 	'' !ABBBL?aBCCCu::##9:::
tz"" 	= 	=AaDJqM))uQx4:a=./H/H CJJ!69I!IJJJQx!||a
#DJqM1E!H<JJr   c                     g }t          | j                  D ]}|                    ||z             ||z  } |                                 t	          |          S r   )reversedr:   appendreversetuple)r   integer_indexr@   shs       r   _get_tuple_indexzNDimArray._get_tuple_index   s\    4:&& 	! 	!BLL+,,,b MMU||r   c                    t          |t                    r|n|f}t          d |D                       rMt          || j                  D ](\  }}|dk     dk    s
||k    dk    rt          d          )ddlm}  || g|R  S d S )Nc              3   P   K   | ]!}t          |t                    o|j         V  "d S r   )rC   r   	is_numberr%   rJ   s     r   	<genexpr>z2NDimArray._check_symbolic_index.<locals>.<genexpr>   s5      PPq
1d##9Q[PPPPPPr   r   Tzindex out of range)Indexed)rC   rP   anyzipr:   rE   sympy.tensorrY   )r   r@   tuple_indexrJ   nth_dimrY   s         r   _check_symbolic_indexzNDimArray._check_symbolic_index   s     *5% 8 8FuuuhPPKPPPPP 	/!+tz:: ; ;
7UtOO!w,4)?)?$%9::: *@,,,,,,74.+....tr   c                 Z    ddl m} t          |t          |t          f          rt
          d S )Nr   
MatrixBase)sympy.matrices.matrixbaserb   rC   r   r5   r>   )r   valuerb   s      r   _setter_iterable_checkz NDimArray._setter_iterable_check   s=    888888eh
I>?? 	&%%	& 	&r   c                 $    fd |          S )Nc                 b   t          | t                    s| gdfS t          |           dk    rg dfS g }t          fd| D              \  }}t          t	          |                    dk    rt          d          |D ]}|                    |           |t          |          f|d         z   fS )Nr#   r   r   c                 &    g | ]} |          S r#   r#   )r%   rJ   fs     r   
<listcomp>z=NDimArray._scan_iterable_shape.<locals>.f.<locals>.<listcomp>   s!    !8!8!81!!A$$!8!8!8r   r(   z'could not determine shape unambiguously)rC   r   r)   r[   setrE   extend)pointerresultelemsshapesrJ   rj   s        r   rj   z)NDimArray._scan_iterable_shape.<locals>.f   s    gx00 %y"}$7||q  4xF!8!8!8!8!8!8!89ME63v;;1$$ !JKKK ! !a    CKK>&)333r   r#   )r   r9   rj   s     @r   _scan_iterable_shapezNDimArray._scan_iterable_shape   s,    	4 	4 	4 	4 	4 q{{r   c                    ddl m} ddlm} ||d}d}nt	          ||          r|j        |j        fS t	          |t                    r|j        }nKt	          |t                    r| 
                    |          \  }}nt	          ||          r|j        }nd}|f}t	          |t          t          f          rj|h|                                }|D ]Q}t	          |t          t          f          r3d}t!          |          D ]\  }	}
|||	         z  |
z   }||         ||<   ||= Rt	          |t"          t$          f          r|f}t'          d |D                       st)          d          t          |          |fS )Nr   ra   SparseNDimArrayr#   c              3   N   K   | ] }t          |t          t          f          V  !d S r   )rC   r   r
   )r%   dims     r   rX   z<NDimArray._handle_ndarray_creation_inputs.<locals>.<genexpr>  s1      KKc:cJ#899KKKKKKr   z#Shape should contain integers only.)rc   rb   r8   ru   rC   _shape_sparse_arrayr5   r:   r   rr   r   dictcopyrP   r   	enumerater   r
   all	TypeError)r   r9   r:   r;   rb   ru   new_dictknew_keyrJ   idxs              r   _handle_ndarray_creation_inputsz)NDimArray._handle_ndarray_creation_inputs   s   888888666666=Ho66 '(>>> Hi00 '  Hh// 	'"%":":8"D"D%% Hj11 '  $;ht-- 	$%2C}}H $ $a%00 $G"+A,, ; ;3")E!H"4s":(0HW% ej'233 	HEKKUKKKKK 	CABBBU||X%%r   c                     | j         S )a-  Overload common function len(). Returns number of elements in array.

        Examples
        ========

        >>> from sympy import MutableDenseNDimArray
        >>> a = MutableDenseNDimArray.zeros(3, 3)
        >>> a
        [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
        >>> len(a)
        9

        )rD   r   s    r   __len__zNDimArray.__len__  s     r   c                     | j         S )z
        Returns array shape (dimension).

        Examples
        ========

        >>> from sympy import MutableDenseNDimArray
        >>> a = MutableDenseNDimArray.zeros(3, 3)
        >>> a.shape
        (3, 3)

        )rx   r   s    r   r:   zNDimArray.shape  s     {r   c                     | j         S )z
        Returns rank of array.

        Examples
        ========

        >>> from sympy import MutableDenseNDimArray
        >>> a = MutableDenseNDimArray.zeros(3,4,5,6,3)
        >>> a.rank()
        5

        )rF   r   s    r   rankzNDimArray.rank&  s     zr   c                 v    ddl m} |                    dd            ||                                 g|R i |S )a5  
        Calculate the derivative of each element in the array.

        Examples
        ========

        >>> from sympy import ImmutableDenseNDimArray
        >>> from sympy.abc import x, y
        >>> M = ImmutableDenseNDimArray([[x, y], [1, x*y]])
        >>> M.diff(x)
        [[1, 0], [0, y]]

        r   )ArrayDerivativeevaluateT)$sympy.tensor.array.array_derivativesr   
setdefaultas_immutable)r   argsr;   r   s       r   diffzNDimArray.diff5  sY     	IHHHHH*d+++t0022DTDDDVDDDr   c                 4    |                      fd          S )Nc                 .                         |           S r   )r   )xbases    r   <lambda>z,NDimArray._eval_derivative.<locals>.<lambda>I  s    		! r   )	applyfunc)r   r   s    `r   _eval_derivativezNDimArray._eval_derivativeG  s    ~~4444555r   c                 .    t          j        | ||          S r   )r   _eval_derivative_n_times)r   sns      r   r   z"NDimArray._eval_derivative_n_timesK  s    -dAq999r   c                 Z   ddl m} ddlm} t	          | |          rZ t
          j                  dk    rA t          |           fd| j        	                                D             | j
                  S  t          |           t           ||                     | j
                  S )a[  Apply a function to each element of the N-dim array.

        Examples
        ========

        >>> from sympy import ImmutableDenseNDimArray
        >>> m = ImmutableDenseNDimArray([i*2+j for i in range(2) for j in range(2)], (2, 2))
        >>> m
        [[0, 1], [2, 3]]
        >>> m.applyfunc(lambda i: 2*i)
        [[0, 2], [4, 6]]
        r   rt   Flattenc                 L    i | ] \  }} |          d k    | |          !S rh   r#   )r%   r   vrj   s      r   
<dictcomp>z'NDimArray.applyfunc.<locals>.<dictcomp>_  s?    [[[41aQRQRSTQUQUYZQZQZq!!A$$QZQZQZr   )r8   ru   sympy.tensor.array.arrayopr   rC   r   Zerotypery   itemsr:   map)r   rj   ru   r   s    `  r   r   zNDimArray.applyfuncN  s     	766666666666dO,, 	i16a4::[[[[43E3K3K3M3M[[[]a]ghhhtDzz#a//<<<r   c                       fd                                  dk    r                     d                   S   j         j        d j                  S )Nc                 ,    t                    dk    r6dd                    fdt          |          D                       z   dz   S  d         z   dd                     fdt          d                   D                       z   dz   S )Nr(   [z, c                 l    g | ]0}                                         |                             1S r#   )_printrS   )r%   r&   printerr   s     r   rk   z2NDimArray._sympystr.<locals>.f.<locals>.<listcomp>f  s:    %j%j%jYZgnnT$:O:OPQ:R:R5S&T&T%j%j%jr   ]r   c           
      Z    g | ]'} d d         |z  z   |d z   z  z             (S )r(   Nr#   )r%   r&   rj   rJ   rR   
shape_lefts     r   rk   z2NDimArray._sympystr.<locals>.f.<locals>.<listcomp>i  sF    #l#l#lRSAAb*QRR.!AbD&!QqS"H*$M$M#l#l#lr   )r)   joinrG   )rR   r   rJ   jrj   r   r   s   ``` r   rj   zNDimArray._sympystr.<locals>.fd  s    :!##499%j%j%j%j%j^cdegh^i^i%j%j%jkkklooo:a= B#l#l#l#l#l#l#lW\]ghi]jWkWk#l#l#lmmmpsssr   r   r#   )r   r   rD   r:   )r   r   rj   s   ``@r   	_sympystrzNDimArray._sympystrc  sv    	t 	t 	t 	t 	t 	t 	t 99;;!>>$r(+++q$*aAAAr   c                 L      fd  j          j        d j                   S )a?  
        Converting MutableDenseNDimArray to one-dim list

        Examples
        ========

        >>> from sympy import MutableDenseNDimArray
        >>> a = MutableDenseNDimArray([1, 2, 3, 4], (2, 2))
        >>> a
        [[1, 2], [3, 4]]
        >>> b = a.tolist()
        >>> b
        [[1, 2], [3, 4]]
        c                     t          |          dk    rfdt          ||          D             S g }| |d         z  } t          |d                   D ]:}|                     | |dd          ||| z  z   ||dz   | z  z                        ;|S )Nr(   c                 F    g | ]}                     |                   S r#   )rS   )r%   r&   r   s     r   rk   z/NDimArray.tolist.<locals>.f.<locals>.<listcomp>  s,    LLL1T221556LLLr   r   )r)   rG   rN   )rR   r   rJ   r   ro   r&   rj   r   s         r   rj   zNDimArray.tolist.<locals>.f  s    :!##LLLLaLLLLF:a= B:a=)) I IaaJqrrNAadFAqsBhJGGHHHHMr   r   )rD   r:   )r   rj   s   `@r   tolistzNDimArray.tolistp  s@     	 	 	 	 	 	 q$*aAAAr   c                    ddl m} t          |t                    st          S | j        |j        k    rt          d          d t           ||            ||                    D             } t          |           || j                  S )Nr   r   array shape mismatchc                     g | ]
\  }}||z   S r#   r#   r%   rJ   r   s      r   rk   z%NDimArray.__add__.<locals>.<listcomp>       IIIsqqsIIIr   	r   r   rC   r5   NotImplementedr:   rE   r[   r   r   otherr   result_lists       r   __add__zNDimArray.__add__      666666%++ 	"!!:$$3444IIc''$--&H&HIIItDzz+tz222r   c                    ddl m} t          |t                    st          S | j        |j        k    rt          d          d t           ||            ||                    D             } t          |           || j                  S )Nr   r   r   c                     g | ]
\  }}||z
  S r#   r#   r   s      r   rk   z%NDimArray.__sub__.<locals>.<listcomp>  r   r   r   r   s       r   __sub__zNDimArray.__sub__  r   r   c                    ddl m} ddlm} ddlm} t          t          t          |f          rt          d          t                    t          | |          rfj        r t          |           i | j                  S  t          |           fd| j                                        D             | j                  S fd ||           D             } t          |           || j                  S )Nr   ra   rt   r   =scalar expected, use tensorproduct(...) for tensorial productc                 "    i | ]\  }}||z  S r#   r#   r%   r   r   r   s      r   r   z%NDimArray.__mul__.<locals>.<dictcomp>  #    SSSfq!q%'SSSr   c                     g | ]}|z  S r#   r#   r%   rJ   r   s     r   rk   z%NDimArray.__mul__.<locals>.<listcomp>      6661qw666r   rc   rb   r8   ru   r   r   rC   r   r5   rE   r   is_zeror   r:   ry   r   r   r   rb   ru   r   r   s    `    r   __mul__zNDimArray.__mul__     888888666666666666eh	:>?? 	^\]]]dO,, 	a} 2!tDzz"dj1114::SSSS8J8P8P8R8RSSSUYU_```6666666tDzz+tz222r   c                    ddl m} ddlm} ddlm} t          t          t          |f          rt          d          t                    t          | |          rfj        r t          |           i | j                  S  t          |           fd| j                                        D             | j                  S fd ||           D             } t          |           || j                  S )Nr   ra   rt   r   r   c                 "    i | ]\  }}||z  S r#   r#   r   s      r   r   z&NDimArray.__rmul__.<locals>.<dictcomp>  r   r   c                     g | ]}|z  S r#   r#   r   s     r   rk   z&NDimArray.__rmul__.<locals>.<listcomp>  s    6661uQw666r   r   r   s    `    r   __rmul__zNDimArray.__rmul__  r   r   c                    ddl m} ddlm} ddlm} t          t          t          |f          rt          d          t                    t          | |          rQt          j        k    rA t          |           fd| j                                        D             | j                  S fd ||           D             } t          |           || j                  S )Nr   ra   rt   r   zscalar expectedc                 "    i | ]\  }}||z  S r#   r#   r   s      r   r   z)NDimArray.__truediv__.<locals>.<dictcomp>  s#    SSSfq!q!E'SSSr   c                     g | ]}|z  S r#   r#   r   s     r   rk   z)NDimArray.__truediv__.<locals>.<listcomp>  r   r   )rc   rb   r8   ru   r   r   rC   r   r5   rE   r   r   r   r   ry   r   r:   r   s    `    r   __truediv__zNDimArray.__truediv__  s   888888666666666666eh	:>?? 	0.///dO,, 	a!&4::SSSS8J8P8P8R8RSSSUYU_```6666666tDzz+tz222r   c                      t          d          )Nz"unsupported operation on NDimArrayr=   r   r   s     r   __rtruediv__zNDimArray.__rtruediv__  s    !"FGGGr   c                    ddl m} ddlm} t	          | |          r? t          |           d | j                                        D             | j                  S d  ||           D             } t          |           || j                  S )Nr   rt   r   c                     i | ]	\  }}|| 
S r#   r#   )r%   r   r   s      r   r   z%NDimArray.__neg__.<locals>.<dictcomp>  s     NNN!Qq1"NNNr   c                     g | ]}| S r#   r#   rW   s     r   rk   z%NDimArray.__neg__.<locals>.<listcomp>  s    111ar111r   )	r8   ru   r   r   rC   r   ry   r   r:   )r   ru   r   r   s       r   __neg__zNDimArray.__neg__  s    666666666666dO,, 	\4::NN43E3K3K3M3MNNNPTPZ[[[11774==111tDzz+tz222r   c                 "      fd} |            S )Nc               3      K   j         r)t          j         d                   D ]} |          V  d S d         V  d S )Nr   r#   )rx   rG   )rJ   r   s    r   iteratorz$NDimArray.__iter__.<locals>.iterator  sZ      { t{1~.. " "Aq'MMMM" " 2hr   r#   )r   r   s   ` r   __iter__zNDimArray.__iter__  s*    	 	 	 	 	 xzzr   c                 4   ddl m} t          |t                    sdS | j        |j        k    sdS t          | |          r:t          ||          r*t          | j                  t          |j                  k    S t          |           t          |          k    S )a  
        NDimArray instances can be compared to each other.
        Instances equal if they have same shape and data.

        Examples
        ========

        >>> from sympy import MutableDenseNDimArray
        >>> a = MutableDenseNDimArray.zeros(2, 3)
        >>> b = MutableDenseNDimArray.zeros(2, 3)
        >>> a == b
        True
        >>> c = a.reshape(3, 2)
        >>> c == b
        False
        >>> a[0,0] = 1
        >>> b[0,0] = 2
        >>> a == b
        False
        r   rt   F)r8   ru   rC   r5   r:   rz   ry   list)r   r   ru   s      r   __eq__zNDimArray.__eq__  s    * 	766666%++ 	5zU[((5dO,, 	IE?1S1S 	I*++tE4G/H/HHHDzzT%[[((r   c                     | |k     S r   r#   r   s     r   __ne__zNDimArray.__ne__  s    5=  r   c                 t    |                                  dk    rt          d          ddlm}  || d          S )N   zarray rank not 2r(   )permutedims)r(   r   )r   rE   arrayopr   )r   r   s     r   _eval_transposezNDimArray._eval_transpose  sH    99;;!/000(((((({4(((r   c                 *    |                                  S r   )r   r   s    r   	transposezNDimArray.transpose      ##%%%r   c                 j    ddl m} |                     d  ||           D             | j                  S )Nr   r   c                 6    g | ]}|                                 S r#   )	conjugaterW   s     r   rk   z-NDimArray._eval_conjugate.<locals>.<listcomp>  s     ???A!++--???r   )r   r   funcr:   )r   r   s     r   _eval_conjugatezNDimArray._eval_conjugate  sA    666666yy?????LLLr   c                 *    |                                  S r   )r   r   s    r   r   zNDimArray.conjugate  r   r   c                 N    |                                                                  S r   )r   r   r   s    r   _eval_adjointzNDimArray._eval_adjoint   s    ~~))+++r   c                 *    |                                  S r   )r   r   s    r   adjointzNDimArray.adjoint#  s    !!###r   c                     t          |t                    s|fS |                    |          \  }fdt          |z
  z            D             S )Nc                      g | ]
}|z  z   S r#   r#   )r%   rJ   startsteps     r   rk   z+NDimArray._slice_expand.<locals>.<listcomp>*  s!    BBB1$BBBr   )rC   sliceindicesrG   )r   r   rw   stopr   r   s       @@r   _slice_expandzNDimArray._slice_expand&  sa    !U## 	tIIcNNtTBBBBBtEzD.@(A(ABBBBr   c                 j      fdt          | j                  D             }t          j        | }||fS )Nc                 B    g | ]\  }}                     ||          S r#   )r  )r%   rJ   rw   r   s      r   rk   z>NDimArray._get_slice_data_for_array_access.<locals>.<listcomp>-  s-    XXXXad((C00XXXr   )r[   r:   	itertoolsproduct)r   r@   
sl_factorseindicess   `   r    _get_slice_data_for_array_accessz*NDimArray._get_slice_data_for_array_access,  s@    XXXXUDJAWAWXXX
$j18##r   c                     t          |t                    s t          |           |          }|                     |          \  }}d |D             }|||fS )Nc                 Z    g | ](}t          |t                    rt          |          nd )S r   )rC   r   minrW   s     r   rk   zBNDimArray._get_slice_data_for_array_assignment.<locals>.<listcomp>5  s1    UUUQ:a#6#6@QDUUUr   )rC   r5   r   r  )r   r@   rd   r	  r
  slice_offsetss         r   $_get_slice_data_for_array_assignmentz.NDimArray._get_slice_data_for_array_assignment1  sa    %++ 	&DJJu%%E#DDUKK
HUU*UUUh--r   c                     |dk    r"t          |          dk    rt          d          |dk    r"t          |          dk    rt          d          d S d S )Nr#   r(   z*arrays without shape need one scalar valuerh   r   z/if array shape is (0,) there cannot be elements)r)   rE   )r   	flat_listr:   s      r   _check_special_boundszNDimArray._check_special_bounds9  s_    B;;3y>>Q..IJJJD==S^^a//NOOO =//r   c           	         t          |t          t          t          f          r|f}t	          |          |                                 k     rVt          |          t          d t          t	          |          |                                           D                       z   }t	          |          |                                 k    rt          d          |S )Nc              3   4   K   | ]}t          d           V  d S r   )r  rW   s     r   rX   z5NDimArray._check_index_for_getitem.<locals>.<genexpr>F  s(      TTdTTTTTTr   z-Dimension of index greater than rank of array)	rC   r   r
   r  r)   r   rP   rG   rE   r?   s     r   _check_index_for_getitemz"NDimArray._check_index_for_getitem@  s    ej'59:: 	HEu::		##%LLTTU3u::tyy{{5S5STTTTTUE u::		##LMMMr   r   )NN).r.   r/   r0   r1   	_diff_wrt	is_scalarr   rA   rK   rS   r_   re   r2   rr   r   r   propertyr:   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r  r  r  r#   r   r   r5   r5   V   s       2 2h IIB B B BZ Z Z  .  	 	 	& & &
   [$ ,& ,& ,& [,&\      X  E E E$6 6 6: : := = =*B B BB B B6
3 
3 
3
3 
3 
33 3 3"3 3 3"3 3 3H H H3 3 3  ) ) )B! ! !) ) )& & &M M M
& & &, , ,$ $ $C C C$ $ $
. . . P P [P    r   r5   c                   $    e Zd ZdZd Zd Zd ZdS )ImmutableNDimArrayg      &@c                 *    t          j        |           S r   )r   __hash__r   s    r   r  zImmutableNDimArray.__hash__Q  s    ~d###r   c                     | S r   r#   r   s    r   r   zImmutableNDimArray.as_immutableT  s    r   c                      t          d          )Nzabstract methodr=   r   s    r   
as_mutablezImmutableNDimArray.as_mutableW  s    !"3444r   N)r.   r/   r0   _op_priorityr  r   r   r#   r   r   r  r  N  sF        L$ $ $  5 5 5 5 5r   r  )sympy.core.basicr   sympy.core.containersr   r   sympy.core.exprr   sympy.core.kindr   r   r	   sympy.core.numbersr
   sympy.core.singletonr   sympy.core.sympifyr   sympy.external.gmpyr   sympy.printing.defaultsr   r  collections.abcr   r   r5   r  r#   r   r   <module>r,     ss   " " " " " " / / / / / / / /             ; ; ; ; ; ; ; ; ; ; & & & & & & " " " " " " & & & & & & * * * * * * - - - - - -     $ $ $ $ $ $D# D# D# D# D# D# D# D#Nu u u u u	 u u up
5 
5 
5 
5 
5E 
5 
5 
5 
5 
5r   