
    sgeJ                         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y
)    )Basic)DictTuple)Expr)Kind
NumberKindUndefinedKind)Integer)S)sympify)
SYMPY_INTS)	PrintableN)Iterablec                   >     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                 6    t         |   | |      }||_        |S N)super__new__element_kind)clsr   obj	__class__s      P/var/www/html/venv/lib/python3.12/site-packages/sympy/tensor/array/ndim_array.pyr   zArrayKind.__new__D   s     goc<0'
    c                      d| j                   z  S )NzArrayKind(%s))r   selfs    r   __repr__zArrayKind.__repr__I   s    !2!222r   c                     |D ch c]  }|j                    }}t        |      dk(  r|\  }t        |      S t        }t        |      S c c}w )N   )kindlenr	   r   )r   kindse
elem_kindselemkinds        r   _unionzArrayKind._unionL   sP    &+,aff,
,z?a"IH "" %H"" -s   A)returnr   )
__name__
__module____qualname____doc__r   r   r   classmethodr(   __classcell__)r   s   @r   r   r      s,    3h #- 
3 # #r   r   c                   (   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-y)-	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.arrayr3   )r   iterableshapekwargsr3   s        r   r   zNDimArray.__new__   s    >&xA&AAr   c                     t        d      )Nz4A subclass of NDimArray should implement __getitem__NotImplementedErrorr   indexs     r   __getitem__zNDimArray.__getitem__   s    !"XYYr   c                    t        |t        t        f      r|| j                  k\  rt	        d      |S | j                  dk(  rt	        d      t        |      | j                  k7  rt	        d      d}t        | j                        D ]l  }||   | j                  |   k\  s||   | j                  |    k  rt	        dt        |      z   dz         ||   dk  r|dz  }|| j                  |   z  ||   z   }n |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ranger6   str)r   r<   
real_indexis       r   _parse_indexzNDimArray._parse_index   s    ej'23' !ABBL??aBCCu:#9::
tzz" 	=AaDJJqM)uQx4::a=./H CJ!69I!IJJQx!|a
#DJJqM1E!H<J	= r   c                     g }t        | j                        D ]  }|j                  ||z         ||z  } |j                          t	        |      S r   )reversedr6   appendreversetuple)r   integer_indexr<   shs       r   _get_tuple_indexzNDimArray._get_tuple_index   sO    4::& 	!BLL+,b M	! 	U|r   c                     t        |t              r|n|f}t        d |D              rHt        || j                        D ]   \  }}|dk  dk(  s	||k\  dk(  st        d       ddlm}  || g| S y )Nc              3   Z   K   | ]#  }t        |t              xr |j                    % y wr   )r?   r   	is_number.0rF   s     r   	<genexpr>z2NDimArray._check_symbolic_index.<locals>.<genexpr>   s%     Pq
1d#9Q[[9Ps   )+r   Tzindex out of range)Indexed)r?   rL   anyzipr6   rA   sympy.tensorrV   )r   r<   tuple_indexrF   nth_dimrV   s         r   _check_symbolic_indexzNDimArray._check_symbolic_index   sz     *5% 8uuhPKPP!+tzz: ;
7UtO!w,4)?$%9::; -4.+..r   c                 J    ddl m} t        |t        |t        f      rt
        y )Nr   
MatrixBase)sympy.matrices.matrixbaser_   r?   r   r1   r:   )r   valuer_   s      r   _setter_iterable_checkz NDimArray._setter_iterable_check   s"    8eh
I>?%% @r   c                     fd |      S )Nc                 :   t        | t              s| gdfS t        |       dk(  rg dfS g }t        | D cg c]
  } |       c} \  }}t        t	        |            dk7  rt        d      |D ]  }|j                  |        |t        |      f|d   z   fS c c}w )N r   r   r!   z'could not determine shape unambiguously)r?   r   r#   rX   setrA   extend)pointerresultrF   elemsshapesfs        r   rm   z)NDimArray._scan_iterable_shape.<locals>.f   s    gx0y"}$7|q 4xF!81!A$!89ME63v;1$ !JKK !a !CK>&)333 "9s   Bre   )r   r5   rm   s     @r   _scan_iterable_shapezNDimArray._scan_iterable_shape   s    	4 {r   c                    ddl m} ddlm} ||d}d}nt	        ||      r|j
                  |j                  fS t	        |t              r|j                  }nCt	        |t              r| j                  |      \  }}nt	        ||      r|j                  }nd}|f}t	        |t        t        f      r[|Y|j                         }|D ]D  }t	        |t        t        f      sd}t!        |      D ]  \  }	}
|||	   z  |
z   } ||   ||<   ||= F t	        |t"        t$        f      r|f}t'        d |D              st)        d      t        |      |fS )Nr   r^   SparseNDimArrayre   c              3   H   K   | ]  }t        |t        t        f        y wr   )r?   r   r
   )rT   dims     r   rU   z<NDimArray._handle_ndarray_creation_inputs.<locals>.<genexpr>  s     Kc:cJ#89Ks    "z#Shape should contain integers only.)r`   r_   r4   rq   r?   _shape_sparse_arrayr1   r6   r   rn   r   dictcopyrL   r   	enumerater   r
   all	TypeError)r   r5   r6   r7   r_   rq   new_dictknew_keyrF   idxs              r   _handle_ndarray_creation_inputsz)NDimArray._handle_ndarray_creation_inputs   sT   86=Ho6(>(>>> Hi0  Hh/"%":":8"D% Hj1  $;ht-%2C}}H $a%0G"+A, ;3")E!H"4s":;(0HW% $ ej'23HEKUKKA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

        )r@   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)

        )rt   r   s    r   r6   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

        )rB   r   s    r   rankzNDimArray.rank&  s     zzr   c                 f    ddl m} |j                  dd        || j                         g|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   argsr7   r   s       r   diffzNDimArray.diff5  s6     	I*d+t002DTDVDDr   c                 ,    | j                  fd      S )Nc                 &    j                  |       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55r   c                 0    t        j                  | ||      S r   )r   _eval_derivative_n_times)r   sns      r   r   z"NDimArray._eval_derivative_n_timesK  s    --dAq99r   c           
      |   ddl m} ddlm} t	        | |      rs |t
        j                        dk(  rZ t        |       | j                  j                         D ci c]  \  }} ||      dk7  s| ||       c}}| j                        S  t        |       t        | ||             | j                        S c c}}w )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   rp   Flatten)r4   rq   sympy.tensor.array.arrayopr   r?   r   Zerotyperu   itemsr6   map)r   rm   rq   r   r|   vs         r   r   zNDimArray.applyfuncN  s     	76dO,166a4:43E3E3K3K3M[41aQRSTQUYZQZq!A$w[]a]g]ghhtDz#a/<< \s   B8
.B8
c                       fd j                         dk(  rj                   d         S   j                   j                  d j                        S )Nc                 |   t        |      dk(  rPddj                  t        ||      D cg c]%  }j                  j	                  |               ' c}      z   dz   S | |d   z  } ddj                  t        |d         D cg c]  } | |dd  ||| z  z   ||dz   | z  z         ! c}      z   dz   S c c}w c c}w )Nr!   [z, ]r   )r#   joinrC   _printrO   )rN   
shape_leftrF   jr%   rm   printerr   s        r   rm   zNDimArray._sympystr.<locals>.fd  s    :!#499^cdegh^i%jYZgnnT$:O:OPQ:R5S&T%jkklooo:a= BW\]ghi]jWk#lRSAb*QR.!AbD&!QqS"H*$M#lmmpsss &k $ms   *B4
$B9
r   re   )r   r   r@   r6   )r   r   rm   s   ``@r   	_sympystrzNDimArray._sympystrc  sI    	t 99;!>>$r(++$**aAAr   c                 d      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,t        ||      D cg c]  }j                  |          c}S g }| |d   z  } t        |d         D ].  }|j                   | |dd  ||| z  z   ||dz   | z  z                0 |S c c}w )Nr!   r   )r#   rC   rO   rJ   )rN   r   rF   r   r%   rj   rm   r   s         r   rm   zNDimArray.tolist.<locals>.f  s    :!#@EaL1T22156LLF:a= B:a=) IaJqrNAadFAqsBhJGHIM Ms   Br   )r@   r6   )r   rm   s   `@r   tolistzNDimArray.tolistp  s'     	 $**aAAr   c                     ddl m} t        |t              st        S | j
                  |j
                  k7  rt        d      t         ||        ||            D cg c]
  \  }}||z    }}} t        |       || j
                        S c c}}w Nr   r   zarray shape mismatch	r   r   r?   r1   NotImplementedr6   rA   rX   r   r   otherr   rF   r   result_lists         r   __add__zNDimArray.__add__  x    6%+!!::$344&)'$-&HIsqqsIItDz+tzz22 J   B
c                     ddl m} t        |t              st        S | j
                  |j
                  k7  rt        d      t         ||        ||            D cg c]
  \  }}||z
   }}} t        |       || j
                        S c c}}w 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        | |      rs|j                  r t        |       i | j                        S  t        |       | j                  j                         D ci c]  \  }}|||z   c}}| j                        S  ||       D cg c]  }||z  	 }} t        |       || j                        S c c}}w c c}w Nr   r^   rp   r   z=scalar expected, use tensorproduct(...) for tensorial productr`   r_   r4   rq   r   r   r?   r   r1   rA   r   is_zeror   r6   ru   r   	r   r   r_   rq   r   r|   r   rF   r   s	            r   __mul__zNDimArray.__mul__  s    866eh	:>?\]]dO,}}!tDz"djj114:8J8J8P8P8RSfq!q%'zSUYU_U_``(/61qw66tDz+tzz22 T6   C3
	C9c           	         ddl m} ddlm} ddlm} t        |t        t        |f      rt        d      t        |      }t        | |      rs|j                  r t        |       i | j                        S  t        |       | j                  j                         D ci c]  \  }}|||z   c}}| j                        S  ||       D cg c]  }||z  	 }} t        |       || j                        S c c}}w c c}w r   r   r   s	            r   __rmul__zNDimArray.__rmul__  s    866eh	:>?\]]dO,}}!tDz"djj114:8J8J8P8P8RSfq!q%'zSUYU_U_``(/61uQw66tDz+tzz22 T6r   c           	         ddl m} ddlm} ddlm} t        |t        t        |f      rt        d      t        |      }t        | |      r^|t        j                  k7  rK t        |       | j                  j                         D ci c]  \  }}|||z   c}}| j                         S  ||       D cg c]  }||z  	 }} t        |       || j                         S c c}}w c c}w )Nr   r^   rp   r   zscalar expected)r`   r_   r4   rq   r   r   r?   r   r1   rA   r   r   r   r   ru   r   r6   r   s	            r   __truediv__zNDimArray.__truediv__  s    866eh	:>?.//dO,!&&4:8J8J8P8P8RSfq!q!E'zSUYU_U_``(/61qw66tDz+tzz22 T6s   C
4C$c                     t        d      )Nz"unsupported operation on NDimArrayr9   r   r   s     r   __rtruediv__zNDimArray.__rtruediv__  s    !"FGGr   c                 >   ddl m} ddlm} t	        | |      rI t        |       | j                  j                         D ci c]	  \  }}||  c}}| j                        S  ||       D cg c]  }|  }} t        |       || j                        S c c}}w c c}w )Nr   rp   r   )	r4   rq   r   r   r?   r   ru   r   r6   )r   rq   r   r|   r   rF   r   s          r   __neg__zNDimArray.__neg__  s    66dO,4:43E3E3K3K3MN!Qq1"uNPTPZPZ[[#*4=1ar11tDz+tzz22 O1s   B
,
Bc                       fd} |       S )Nc               3   ~   K   j                   r%t        j                   d         D ]	  } |      y d    y w)Nr   re   )rt   rC   )rF   r   s    r   iteratorz$NDimArray.__iter__.<locals>.iterator  s>     {{t{{1~. "Aq'M" 2hs   :=re   )r   r   s   ` r   __iter__zNDimArray.__iter__  s    	 zr   c                    ddl m} t        |t              sy| j                  |j                  k(  syt        | |      r7t        ||      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   rp   F)r4   rq   r?   r1   r6   rv   ru   list)r   r   rq   s      r   __eq__zNDimArray.__eq__  sn    * 	7%+zzU[[(dO,E?1S**+tE4G4G/HHHDzT%[((r   c                     | |k(   S r   re   r   s     r   __ne__zNDimArray.__ne__  s    5=  r   c                 \    | j                         dk7  rt        d      ddlm}  || d      S )N   zarray rank not 2r!   )permutedims)r!   r   )r   rA   arrayopr   )r   r   s     r   _eval_transposezNDimArray._eval_transpose  s,    99;!/00(4((r   c                 "    | j                         S r   )r   r   s    r   	transposezNDimArray.transpose      ##%%r   c                     ddl m} | j                   ||       D cg c]  }|j                          c}| j                        S c c}w )Nr   r   )r   r   func	conjugater6   )r   r   rF   s      r   _eval_conjugatezNDimArray._eval_conjugate  s2    6yy?A!++-?LL?s   Ac                 "    | j                         S r   )r   r   s    r   r   zNDimArray.conjugate  r   r   c                 >    | j                         j                         S r   )r   r   r   s    r   _eval_adjointzNDimArray._eval_adjoint   s    ~~))++r   c                 "    | j                         S r   )r   r   s    r   adjointzNDimArray.adjoint#  s    !!##r   c                     t        |t              s|fS |j                  |      \  }}}t        ||z
  |z        D cg c]
  }|||z  z    c}S c c}w r   )r?   sliceindicesrC   )r   r   rs   startstopsteprF   s          r   _slice_expandzNDimArray._slice_expand&  sQ    !U#tIIcNtT(-tEzD.@(AB1$BBBs   Ac                     t        || j                        D cg c]  \  }}| j                  ||       }}}t        j                  | }||fS c c}}w r   )rX   r6   r   	itertoolsproduct)r   r<   rF   rs   
sl_factorseindicess         r    _get_slice_data_for_array_accessz*NDimArray._get_slice_data_for_array_access,  sR    ADUDJJAWXXad((C0X
X$$j18## Ys   Ac                     t        |t              s t        |       |      }| j                  |      \  }}|D cg c]  }t        |t              rt        |      nd ! }}|||fS c c}w r   )r?   r1   r   r   r   min)r   r<   ra   r   r   rF   slice_offsetss          r   $_get_slice_data_for_array_assignmentz.NDimArray._get_slice_data_for_array_assignment1  si    %+DJu%E#DDUK
HJTUQ:a#6QD@UUh-- Vs   $A%c                 ~    |dk(  rt        |      dk7  rt        d      |dk(  rt        |      dkD  rt        d      y y )Nre   r!   z*arrays without shape need one scalar valuerf   r   z/if array shape is (0,) there cannot be elements)r#   rA   )r   	flat_listr6   s      r   _check_special_boundszNDimArray._check_special_bounds9  sE    B;3y>Q.IJJD=S^a/NOO 0=r   c           	      F   t        |t        t        t        f      r|f}t	        |      | j                         k  r?t        |      t        d t        t	        |      | j                               D              z   }t	        |      | j                         kD  rt        d      |S )Nc              3   2   K   | ]  }t        d         y wr   )r   rS   s     r   rU   z5NDimArray._check_index_for_getitem.<locals>.<genexpr>F  s     TdTs   z-Dimension of index greater than rank of array)	r?   r   r
   r   r#   r   rL   rC   rA   r;   s     r   _check_index_for_getitemz"NDimArray._check_index_for_getitem@  s    ej'59:HEu:		#%LTU3u:tyy{5STTUE u:		#LMMr   r   )NN).r*   r+   r,   r-   	_diff_wrt	is_scalarr   r=   rG   rO   r\   rb   r.   rn   r   r   propertyr6   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   re   r   r   r1   r1   V   s   2h IIBZ.	&
  $ ,& ,&\   E$6:=*BB6
3
33"3"3H3)B!)&M
&,$C$
. P Pr   r1   c                   "    e Zd ZdZd Zd Zd Zy)ImmutableNDimArrayg      &@c                 ,    t        j                  |       S r   )r   __hash__r   s    r   r  zImmutableNDimArray.__hash__Q  s    ~~d##r   c                     | S r   re   r   s    r   r   zImmutableNDimArray.as_immutableT  s    r   c                     t        d      )Nzabstract methodr9   r   s    r   
as_mutablezImmutableNDimArray.as_mutableW  s    !"344r   N)r*   r+   r,   _op_priorityr  r   r  re   r   r   r   r   N  s    L$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   r1   r   re   r   r   <module>r     sU    " /   ; ; & " & * -  $D# D#Nu	 up
5E 
5r   