IcgdZddlmZddlZddlmZddlmZddlm Z m Z m Z m Z m Z mZmZmZmZddlmZmZmZmZmZmZddlZerdd lmZmZmZmZddlmZddl Z!dd l m"Z"Gd d Z#y) al Wrapper class around the ndarray object for the array API standard. The array API standard defines some behaviors differently than ndarray, in particular, type promotion rules are different (the standard has no value-based casting). The standard also specifies a more limited subset of array methods and functionalities than are implemented on ndarray. Since the goal of the array_api namespace is to be a minimal implementation of the array API standard, we need to define a separate wrapper class for the array_api namespace. The standard compliant class is only a wrapper class. It is *not* a subclass of ndarray. ) annotationsN)IntEnum)asarray) _all_dtypes_boolean_dtypes_integer_dtypes_integer_or_boolean_dtypes_floating_dtypes_complex_floating_dtypes_numeric_dtypes _result_type_dtype_categories) TYPE_CHECKINGOptionalTupleUnionAny SupportsIndex)r PyCapsuleDeviceDtype) array_apic eZdZUdZded<efdZdZdSdZdSdZ dTdUd Z dVd Z d Z e dWd Zd ZdXdZdYdZdZdZdd d[dZd\dZd]dZddd^dZd_dZd`dZdadZdYdZdYdZ dbdZdYdZdcdZdcdZdXd Z dYd!Z!ddd"Z"dYd#Z#ded$Z$dYd%Z%dYd&Z&d`d'Z'dXd(Z(dZd)Z)dXd*Z*dYd+Z+ddd,Z, dfd-Z-dYd.Z.dgd/Z/dZd0Z0dYd1Z1dYd2Z2dZd3Z3dZd4Z4dYd5Z5dYd6Z6ddd7Z7ddd8Z8ded9Z9ded:Z:dYd;Z;dYd<ZZ>dZd?Z?dZd@Z@dYdAZAdYdBZBdddCZCdddDZDdYdEZEdYdFZFdgdGZGdgdHZHdZdIZIdZdJZJdTdhdKZKeLdidLZMeLdjdMZNeLdkdNZOeLdldOZPeLdmdPZQeLdldQZReLdkdRZSxZTS)nArraya) n-d array object for the array API namespace. See the docstring of :py:obj:`np.ndarray ` for more information. This is a wrapper around numpy.ndarray that restricts the usage to only those things that are required by the array API namespace. Note, attributes on this object that start with a single underscore are not part of the API specification and should only be used internally. This object should not be constructed directly. Rather, use one of the creation functions, such as asarray(). znp.ndarray[Any, Any]_arrayct||}t|tjrtj |}|j tvrtd|j d||_ |S)a This is a private method for initializing the array API Array object. Functions outside of the array_api submodule should not use this method. Use one of the creation functions instead, such as ``asarray``. z4The array_api namespace does not support the dtype '') super__new__ isinstancenpgenericrdtyper TypeErrorr)clsxobj __class__s X/var/www/html/bid-api/venv/lib/python3.12/site-packages/numpy/array_api/_array_object.py_newz Array._new@segoc" a $ 1 A 77+ %FqwwiqQ   ctd)Nz{The array_api Array object should not be instantiated directly. Use an array creation function, such as asarray(), instead.)r%)r&argskwargss r*r z Array.__new__Xs J  r,cV|jjjddS)z1 Performs the operation __str__. arrayr)r__str__replaceselfs r*r2z Array.__str__`s${{""$,,Wg>>r,cd|jjd}d|jvrd}t|j}n%d}t j |j d||}||z|zS)z2 Performs the operation __repr__. z, dtype=)rzempty(zArray(z, ) separatorprefixsuffix)r$nameshapestrr" array2stringr)r5r:r9mids r*__repr__zArray.__repr__fseDJJOO,A.  ?Fdjj/CF//$++fU[\C|f$$r,NcDtj|j|S)z Warning: this method is NOT part of the array API spec. Implementers of other libraries need not include it, and users should not assume it will be present in other implementations. )r$)r"rr)r5r$s r* __array__zArray.__array__uszz$++U33r,c|jt|vrtd|d|t|tt t tfr|j|}n >eN#33J2$OP P ec7E48 9((/E u %{{"3N"CC%'77Nrd STT! ! !U[[9 == DJJ&%bTtzzl% }U r,ct|tr|jtvrt dt|t r|jtvr t d|jt vrtj|j}|j|cxkr|jks|tdtdt|tr|jtvrCt dt|tr|jtvrt dt dt j#tj$||jS)aR Returns a promoted version of a Python scalar appropriate for use with operations on self. This may raise an OverflowError in cases where the scalar is an integer that is too large to fit in a NumPy integer dtype, or TypeError when the scalar type is incompatible with the dtype of self. z9Python bool scalars can only be promoted with bool arraysz6Python int scalars cannot be promoted with bool arrayszLPython int scalars must be within the bounds of the dtype for integer arrayszEPython float scalars can only be promoted with floating-point arrays.zOPython complex scalars can only be promoted with complex floating-point arrays.z 'scalar' must be a Python scalar)r!rIr$rr%rFr r"iinfominmax OverflowErrorrHr rGr rr+r1)r5scalarinfos r*rJzArray._promote_scalars, fd #zz0O $zz_,Lzz_,xx +F6dhh6'f7'f &zz!11[ (zz!99e>? ?zz"((64::677r,c|jdk(r5|jdk7r&tj|jd}||fS|jdk(r1|jdk7r"tj|jd}||fS)a Normalize inputs to two arg functions to fix type promotion rules NumPy deviates from the spec type promotion rules in cases where one argument is 0-dimensional and the other is not. For example: >>> import numpy as np >>> a = np.array([1.0], dtype=np.float32) >>> b = np.array(1.0, dtype=np.float64) >>> np.add(a, b) # The spec says this should be float64 array([2.], dtype=float32) To fix this, we add a dimension to the 0-dimension array before passing it through. This works because a dimension would be added anyway from broadcasting, so the resulting shape is the same, but this prevents NumPy from not promoting the dtype. rN)ndimrr+r)x1x2s r*_normalize_two_argszArray._normalize_two_argssr2 77a\} }t|t rt|tjr2|t k(s<| } n| J|j|| z z } |j d| |j | dz} t%|| D]\}} t|tr| dk(rd }n d | d| dz d}|j&F t)j*|j&}| |cxkr| ksntd|d|d|d| d |j. t)j*|j.}| |cxkr| krntd|d|d|d| d t|t r|jtvr;t|dk7r-t|tsJtd|dt|d|jt0vsB|jdk7sStd|dt|tsttd|dy#t,$rYwxYw#t,$rYwxYw)a Validate an index according to the array API. The array API specification only requires a subset of indices that are supported by NumPy. This function will reject any index that is allowed by NumPy but not required by the array API specification. We always raise ``IndexError`` on such indices (the spec does not require any specific behavior on them, but this makes the NumPy array API namespace a minimal implementation of the spec). See https://data-apis.org/array-api/latest/API_specification/indexing.html for the full list of required indexing behavior This function raises IndexError if the index ``key`` is invalid. It only raises ``IndexError`` on indices that are not already rejected by NumPy, as NumPy will already raise the appropriate error on such indices. ``shape`` may be None, in which case, only cases that are independent of the array shape are checked. The following cases are allowed by NumPy, but not specified by the array API specification: - Indices to not include an implicit ellipsis at the end. That is, every axis of an array must be explicitly indexed or an ellipsis included. This behaviour is sometimes referred to as flat indexing. - The start and stop of a slice may not be out of bounds. In particular, for a slice ``i:j:k`` on an axis of size ``n``, only the following are allowed: - ``i`` or ``j`` omitted (``None``). - ``-n <= i <= max(0, n - 1)``. - For ``k > 0`` or ``k`` omitted (``None``), ``-n <= j <= n``. - For ``k < 0``, ``-n - 1 <= j <= max(0, n - 1)``. - Boolean array indices are not allowed as part of a larger tuple index. - Integer array indices are not allowed (with the exception of 0-D arrays, which are treated the same as scalars). Additionally, it should be noted that indices that would return a scalar in NumPy will return a 0-D array. Array scalars are not allowed in the specification, only 0-D arrays. This is done in the ``Array._new`` constructor, not this function. NzSingle-axes index z has type(i)=z, but only integers, slices (:), ellipsis (...), newaxis (None), zero-dimensional integer arrays and boolean arrays are specified in the Array API.rFTrz self.ndim=z*, but the multi-axes index only specifies z dimensions. If this was intentional, add a trailing ellipsis (...) which expands into as many slices (:) as necessary - this is what np.ndarray arrays implicitly do, but such flat indexing behaviour is not specified in the Array API.z 0 (or None)z between -rEz (or None)zSlice z contains start=z, but should be z for an axis of size z: (out-of-bounds starts are not specified in the Array API)z contains stop=z9 (out-of-bounds stops are not specified in the Array API)z! is a boolean array and len(key)=zR, but masking is only specified in the Array API when the array is the sole index.zj is a non-zero-dimensional integer array, but advanced integer indexing is not specified in the Array API.zI is a tuple, but nested tuple indices are not specified in the Array API.)r!tuplerIrsliceEllipsisrr"ndarray IndexErrortypeappendr$rlenrZr< enumeratezipstartoperatorindexr%stopr )r5key_keyinonexpanding_key single_axes n_ellipsis key_has_mask n_single_axes indexed_shapeellipsis_startpos ellipsis_endsidef_rangerirls r*_validate_indexzArray._validate_indexs^!e,s3&A!T"1m,a'=9a'a, (>a ;66    A} ''*a':a+Dww/1'+ &&q)H}"a #**1-K( >  1_ MDII$= !tyyl"L$o&22 ? JJM!N#$45Q"1e, 1bjj0IH}), 6 "- --99 (FGL ?N+djj.GG ; 6GAt!U#19+G )$uTAXJjIG77&  (qww 7"& 6$ 6","(+`. See its docstring for more information. )rr$r4s r*r$z Array.dtype3{{   r,cy)Nrr4s r*rz Array.device<sr,cddlm}||S)Nr)matrix_transpose)linalgr)r5rs r*mTzArray.mTAs,%%r,c.|jjS)z Array API compatible wrapper for :py:meth:`np.ndarray.ndim `. See its docstring for more information. )rrZr4s r*rZz Array.ndimF{{r,c.|jjS)z Array API compatible wrapper for :py:meth:`np.ndarray.shape `. See its docstring for more information. )rr<r4s r*r<z Array.shapeOrr,c.|jjS)z Array API compatible wrapper for :py:meth:`np.ndarray.size `. See its docstring for more information. )rsizer4s r*r"z Array.sizeXrr,c|jdk7r td|jj|jj S)z Array API compatible wrapper for :py:meth:`np.ndarray.T `. See its docstring for more information. zwx.T requires x to have 2 dimensions. Use x.mT to transpose stacks of matrices and permute_dims() to permute dimensions.)rZrr)r+rTr4s r*r%zArray.TasA 99>WX X~~""4;;==11r,)r5rreturnr=)N)r$zNone | np.dtype[Any]r&znpt.NDArray[Any])rMzbool | int | float | ArrayrNr=rOr=r&r)r&zTuple[Array, Array])r5rr&r)r5rrMzUnion[int, float, Array]r&r)r5rrMzUnion[int, bool, Array]r&r)r5rrz Optional[str]r&ztypes.ModuleType)r5rr&rI)r5rr&rG)r5rrNoner&r)r5rr&zTuple[IntEnum, int])r5rrMUnion[int, float, bool, Array]r&r)r5rr&rH)r5rrmzQUnion[int, slice, ellipsis, Tuple[Union[int, slice, ellipsis, None], ...], Array]r&r)r5rr&rF)r5rrMzUnion[int, Array]r&r)r5rrMrr&r)rmzKUnion[int, slice, ellipsis, Tuple[Union[int, slice, ellipsis], ...], Array]rr(r&r')r5rrMzUnion[float, Array]r&r)rr'r5rrrr&r)r&r)r&r)r&r)r&rF)r&zTuple[int, ...])U__name__ __module__ __qualname____doc____annotations__ classmethodr+r r2r@rBrQrJ staticmethodr]r{r}rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r r rrrpropertyr$rrrZr<r"r% __classcell__)r)s@r*rr-st  ! . ? %4'T08d  HbL( ( (9=(5 6:5 / (  ( (  . ( ( ( ( ( ( ( ( (( ((   (< < . < <& ( ( ( ( ( ( ( ( ( ( ( (   ( ( ( (;!!&&  !!   2 2r,r)$r, __future__rrjenumr_creation_functionsr_dtypesrrr r r r r rrtypingrrrrrrtypes_typingrrr numpy.typingnptnumpyr"rrrr,r*r<sQ #(   ML 66@2@2r,