Array object ¶
Array API specification for array object attributes and methods.
A conforming implementation of the array API standard must provide and support an array object having the following attributes and methods adhering to the following conventions.

Positional parameters must be positionalonly parameters. Positionalonly parameters have no externallyusable name. When a method accepting positionalonly parameters is called, positional arguments are mapped to these parameters based solely on their order.

Optional parameters must be keywordonly arguments.

Broadcasting semantics must follow the semantics defined in Broadcasting .

Unless stated otherwise, methods must support the data types defined in Data Types .

Unless stated otherwise, methods must adhere to the type promotion rules defined in Type Promotion Rules .

Unless stated otherwise, floatingpoint operations must adhere to IEEE 7542019.
Operators ¶
A conforming implementation of the array API standard must provide and support an array object supporting the following Python operators:

x1 < x2
:__lt__(x1, x2)

x1 <= x2
:__le__(x1, x2)

x1 > x2
:__gt__(x1, x2)

x1 >= x2
:__ge__(x1, x2)

x1 == x2
:__eq__(x1, x2)

x1 != x2
:__ne__(x1, x2)

+x
:__pos__(x)

x
:__neg__(x)

x1 + x2
:__add__(x1, x2)

x1  x2
:__sub__(x1, x2)

x1 * x2
:__mul__(x1, x2)

x1 / x2
:__truediv__(x1, x2)

x1 // x2
:__floordiv__(x1, x2)

x1 % x2
:__mod__(x1, x2)

x1 ** x2
:__pow__(x1, x2)

x1 @ x2
:__matmul__(x1, x2)

~x
:__invert__(x)

x1 & x2
:__and__(x1, x2)

x1  x2
:__or__(x1, x2)

x1 ^ x2
:__xor__(x1, x2)

x1 << x2
:__lshift__(x1, x2)

x1 >> x2
:__rshift__(x1, x2)
Inplace Operators ¶
A conforming implementation of the array API standard must provide and support an array object supporting the following inplace Python operators:

+=
. May be implemented via__iadd__
. 
=
. May be implemented via__isub__
. 
*=
. May be implemented via__imul__
. 
/=
. May be implemented via__itruediv__
. 
//=
. May be implemented via__ifloordiv__
. 
**=
. May be implemented via__ipow__
. 
@=
. May be implemented via__imatmul__
. 
%=
. May be implemented via__imod__
. 
&=
. May be implemented via__iand__
. 
=
. May be implemented via__ior__
. 
^=
. May be implemented via__ixor__
. 
<<=
. May be implemented via__ilshift__
. 
>>=
. May be implemented via__irshift__
.
An inplace operation must not change the dtype or shape of the inplace array as a result of Type Promotion Rules or Broadcasting .
Note
Inplace operators must be supported as discussed in Copyview behaviour and mutability .
Reflected Operators ¶
A conforming implementation of the array API standard must provide and support an array object supporting the following reflected operators:

__radd__

__rsub__

__rmul__

__rtruediv__

__rfloordiv__

__rpow__

__rmatmul__

__rmod__

__rand__

__ror__

__rxor__

__rlshift__

__rrshift__
The results of applying reflected operators must match their nonreflected equivalents.
Note
All operators for which
array
<op>
scalar
is implemented must have an equivalent reflected operator implementation.
Attributes ¶
dtype ¶
Data type of the array elements.
Returns ¶

out : <dtype>

array data type.

device ¶
Hardware device the array data resides on.
Returns ¶

out : <device>

a
device
object (see Device support ).

mT ¶
Transpose of a matrix (or a stack of matrices).
If an array instance has fewer than two dimensions, an error should be raised.
Returns ¶

out : <array>

array whose last two dimensions (axes) are permuted in reverse order relative to original array (i.e., for an array instance having shape
(..., M, N)
, the returned array must have shape(..., N, M)
). The returned array must have the same data type as the original array.

ndim ¶
Number of array dimensions (axes).
Returns ¶

out : int

number of array dimensions (axes).

TODO: need to more carefully consider this in order to accommodate, e.g., graph tensors where the number of dimensions may be dynamic.
shape ¶
Array dimensions.
Returns ¶

out : Union[ Tuple[ int, …], <shape> ]

array dimensions as either a tuple or a custom shape object. If a shape object, the object must be immutable and must support indexing for dimension retrieval.

TODO: need to more carefully consider this in order to accommodate, e.g., graph tensors where a shape may be dynamic.
size ¶
Number of elements in an array. This must equal the product of the array’s dimensions.
Returns ¶

out : int

number of elements in an array.

TODO: need to more carefully consider this in order to accommodate, e.g., graph tensors where the number of elements may be dynamic.
T ¶
Transpose of the array.
The array instance must be twodimensional. If the array instance is not twodimensional, an error should be raised.
Note
Limiting the transpose to twodimensional arrays (matrices) deviates from the NumPy et al practice of reversing all axes for arrays having more than twodimensions. This is intentional, as reversing all axes was found to be problematic (e.g., conflicting with the mathematical definition of a transpose which is limited to matrices; not operating on batches of matrices; et cetera). In order to reverse all axes, one is recommended to use the functional
permute_dims
interface found in this specification.
Returns ¶

out : <array>

twodimensional array whose first and last dimensions (axes) are permuted in reverse order relative to original array. The returned array must have the same data type as the original array.

Methods ¶
__abs__(self, /) ¶
Calculates the absolute value for each element of an array instance (i.e., the elementwise result has the same magnitude as the respective element but has positive sign).
Note
For signed integer data types, the absolute value of the minimum representable integer is implementationdependent.
Special Cases ¶
For floatingpoint operands, let
self
equal
x
.

If
x_i
isNaN
, the result isNaN
. 
If
x_i
is0
, the result is+0
. 
If
x_i
isinfinity
, the result is+infinity
.
Parameters ¶

self : <array>

array instance. Should have a numeric data type.

Returns ¶

out : <array>

an array containing the elementwise absolute value. The returned array must have the same data type as
self
.

Note
Elementwise results must equal the results returned by the equivalent elementwise function
abs(x)
.
__add__(self, other, /) ¶
Calculates the sum for each element of an array instance with the respective element of the array
other
.
Special Cases ¶
For floatingpoint operands, let
self
equal
x1
and
other
equal
x2
.

If either
x1_i
orx2_i
isNaN
, the result isNaN
. 
If
x1_i
is+infinity
andx2_i
isinfinity
, the result isNaN
. 
If
x1_i
isinfinity
andx2_i
is+infinity
, the result isNaN
. 
If
x1_i
is+infinity
andx2_i
is+infinity
, the result is+infinity
. 
If
x1_i
isinfinity
andx2_i
isinfinity
, the result isinfinity
. 
If
x1_i
is+infinity
andx2_i
is a finite number, the result is+infinity
. 
If
x1_i
isinfinity
andx2_i
is a finite number, the result isinfinity
. 
If
x1_i
is a finite number andx2_i
is+infinity
, the result is+infinity
. 
If
x1_i
is a finite number andx2_i
isinfinity
, the result isinfinity
. 
If
x1_i
is0
andx2_i
is0
, the result is0
. 
If
x1_i
is0
andx2_i
is+0
, the result is+0
. 
If
x1_i
is+0
andx2_i
is0
, the result is+0
. 
If
x1_i
is+0
andx2_i
is+0
, the result is+0
. 
If
x1_i
is either+0
or0
andx2_i
is a nonzero finite number, the result isx2_i
. 
If
x1_i
is a nonzero finite number andx2_i
is either+0
or0
, the result isx1_i
. 
If
x1_i
is a nonzero finite number andx2_i
isx1_i
, the result is+0
. 
In the remaining cases, when neither
infinity
,+0
,0
, nor aNaN
is involved, and the operands have the same mathematical sign or have different magnitudes, the sum must be computed and rounded to the nearest representable value according to IEEE 7542019 and a supported round mode. If the magnitude is too large to represent, the operation overflows and the result is aninfinity
of appropriate mathematical sign.
Note
Floatingpoint addition is a commutative operation, but not always associative.
Parameters ¶

self : <array>

array instance (augend array). Should have a numeric data type.


other : Union[ int, float, <array> ]

addend array. Must be compatible with
self
(see Broadcasting ). Should have a numeric data type.

Returns ¶

out : <array>

an array containing the elementwise sums. The returned array must have a data type determined by Type Promotion Rules .

Note
Elementwise results must equal the results returned by the equivalent elementwise function
add(x1,
x2)
.
__and__(self, other, /) ¶
Evaluates
self_i
&
other_i
for each element of an array instance with the respective element of the array
other
.
Parameters ¶

self : <array>

array instance. Should have an integer or boolean data type.


other : Union[ int, bool, <array> ]

other array. Must be compatible with
self
(see Broadcasting ). Should have an integer or boolean data type.

Returns ¶

out : <array>

an array containing the elementwise results. The returned array must have a data type determined by Type Promotion Rules .

Note
Elementwise results must equal the results returned by the equivalent elementwise function
bitwise_and(x1,
x2)
.
__array_namespace__(self, /, *, api_version=None) ¶
Returns an object that has all the array API functions on it.
Parameters ¶

self : <array>

array instance.


api_version : <Optional[str]>

string representing the version of the array API specification to be returned, in
'YYYY.MM'
form, for example,'2020.10'
. If it isNone
, it should return the namespace corresponding to latest version of the array API specification. If the given version is invalid or not implemented for the given module, an error should be raised. Default:None
.

Returns ¶

out : <object>

an object representing the array API namespace. It should have every toplevel function defined in the specification as an attribute. It may contain other public names as well, but it is recommended to only include those names that are part of the specification.

__bool__(self, /) ¶
Converts a zerodimensional boolean array to a Python
bool
object.
Parameters ¶

self : <array>

zerodimensional array instance. Must have a boolean data type.

Returns ¶

out : <bool>

a Python
bool
object representing the single element of the array.

__dlpack__(self, /, *, stream=None) ¶
Exports the array for consumption by from_dlpack(x, /) as a DLPack capsule.
Parameters ¶

self : <array>

array instance.


stream : Optional[ Union[ int, Any ]]

for CUDA and ROCm, a Python integer representing a pointer to a stream, on devices that support streams.
stream
is provided by the consumer to the producer to instruct the producer to ensure that operations can safely be performed on the array (e.g., by inserting a dependency between streams via “wait for event”). The pointer must be a positive integer or1
. Ifstream
is1
, the value may be used by the consumer to signal “producer must not perform any synchronization”. The ownership of the stream stays with the consumer.On CPU and other device types without streams, only
None
is accepted.For other device types which do have a stream, queue or similar synchronization mechanism, the most appropriate type to use for
stream
is not yet determined. E.g., for SYCL one may want to use an object containing an inordercl::sycl::queue
. This is allowed when libraries agree on such a convention, and may be standardized in a future version of this API standard.Devicespecific notes:
CUDA

None
: producer must assume the legacy default stream (default). 
1
: the legacy default stream. 
2
: the perthread default stream. 
> 2
: stream number represented as a Python integer.
0
is disallowed due to its ambiguity:0
could mean eitherNone
,1
, or2
.ROCm

None
: producer must assume the legacy default stream (default). 
0
: the default stream. 
> 2
: stream number represented as a Python integer.
Using
1
and2
is not supported.Tip
It is recommended that implementers explicitly handle streams. If they use the legacy default stream, specifying
1
(CUDA) or0
(ROCm) is preferred.None
is a safe default for developers who do not want to think about stream handling at all, potentially at the cost of more synchronization than necessary. 

Returns ¶

capsule : <PyCapsule>

a DLPack capsule for the array. See Data interchange mechanisms for details.

__dlpack_device__(self, /) ¶
Returns device type and device ID in DLPack format. Meant for use within from_dlpack(x, /) .
Parameters ¶

self : <array>

array instance.

Returns ¶

device : Tuple[enum.IntEnum, int]

a tuple
(device_type, device_id)
in DLPack format. Valid device type enum members are:CPU = 1 CUDA = 2 CPU_PINNED = 3 OPENCL = 4 VULKAN = 7 METAL = 8 VPI = 9 ROCM = 10

__eq__(self, other, /) ¶
Computes the truth value of
self_i
==
other_i
for each element of an array instance with the respective element of the array
other
.
Parameters ¶

self : <array>

array instance. May have any data type.


other : Union[ int, float, bool, <array> ]

other array. Must be compatible with
self
(see Broadcasting ). May have any data type.

Returns ¶

out : <array>

an array containing the elementwise results. The returned array must have a data type of
bool
.

Note
Elementwise results must equal the results returned by the equivalent elementwise function
equal(x1,
x2)
.
__float__(self, /) ¶
Converts a zerodimensional floatingpoint array to a Python
float
object.
Parameters ¶

self : <array>

zerodimensional array instance. Must have a floatingpoint data type.

Returns ¶

out : <float>

a Python
float
object representing the single element of the array instance.

__floordiv__(self, other, /) ¶
Evaluates
self_i
//
other_i
for each element of an array instance with the respective element of the array
other
.
Parameters ¶

self : <array>

array instance. Should have a numeric data type.


other : Union[ int, float, <array> ]

other array. Must be compatible with
self
(see Broadcasting ). Should have a numeric data type.

Returns ¶

out : <array>

an array containing the elementwise results. The returned array must have a data type determined by Type Promotion Rules .

Note
Elementwise results must equal the results returned by the equivalent elementwise function
floor_divide(x1,
x2)
.
__ge__(self, other, /) ¶
Computes the truth value of
self_i
>=
other_i
for each element of an array instance with the respective element of the array
other
.
Parameters ¶

self : <array>

array instance. Should have a numeric data type.


other : Union[ int, float, <array> ]

other array. Must be compatible with
self
(see Broadcasting ). Should have a numeric data type.

Returns ¶

out : <array>

an array containing the elementwise results. The returned array must have a data type of
bool
.

Note
Elementwise results must equal the results returned by the equivalent elementwise function
greater_equal(x1,
x2)
.
__getitem__(self, key, /) ¶
Returns
self[key]
.
Parameters ¶

self : <array>

array instance.


key : Union[ int, slice, ellipsis, Tuple[ Union[ int, slice, ellipsis ], … ], <array> ]

index key.

Returns ¶

out : <array>

an array containing the accessed value(s). The returned array must have the same data type as
self
.

__gt__(self, other, /) ¶
Computes the truth value of
self_i
>
other_i
for each element of an array instance with the respective element of the array
other
.
Parameters ¶

self : <array>

array instance. Should have a numeric data type.


other : Union[ int, float, <array> ]

other array. Must be compatible with
self
(see Broadcasting ). Should have a numeric data type.

Returns ¶

out : <array>

an array containing the elementwise results. The returned array must have a data type of
bool
.

Note
Elementwise results must equal the results returned by the equivalent elementwise function
greater(x1,
x2)
.
__index__(self, /) ¶
Converts a zerodimensional integer array to a Python
int
object.
Note
This method is called to implement
operator.index()
. See also
PEP 357
.
Parameters ¶

self : <array>

zerodimensional array instance. Must have an integer data type.

Returns ¶

out : <int>

a Python
int
object representing the single element of the array instance.

__int__(self, /) ¶
Converts a zerodimensional integer array to a Python
int
object.
Parameters ¶

self : <array>

zerodimensional array instance. Must have an integer data type.

Returns ¶

out : <int>

a Python
int
object representing the single element of the array instance.

__invert__(self, /) ¶
Evaluates
~self_i
for each element of an array instance.
Parameters ¶

self : <array>

array instance. Should have an integer or boolean data type.

Returns ¶

out : <array>

an array containing the elementwise results. The returned array must have the same data type as
self
.

Note
Elementwise results must equal the results returned by the equivalent elementwise function
bitwise_invert(x)
.
__le__(self, other, /) ¶
Computes the truth value of
self_i
<=
other_i
for each element of an array instance with the respective element of the array
other
.
Parameters ¶

self : <array>

array instance. Should have a numeric data type.


other : Union[ int, float, <array> ]

other array. Must be compatible with
self
(see Broadcasting ). Should have a numeric data type.

Returns ¶

out : <array>

an array containing the elementwise results. The returned array must have a data type of
bool
.

Note
Elementwise results must equal the results returned by the equivalent elementwise function
less_equal(x1,
x2)
.
__len__(self, /) ¶
TODO: need to more carefully consider this in order to accommodate, e.g., graph tensors where a shape may be dynamic. Furthermore, not clear whether this should be implemented, as, e.g., NumPy’s behavior of returning the size of the first dimension is not necessarily intuitive, as opposed to, say, the total number of elements.
__lshift__(self, other, /) ¶
Evaluates
self_i
<<
other_i
for each element of an array instance with the respective element of the array
other
.
Parameters ¶

self : <array>

array instance. Should have an integer data type.


other : Union[ int, <array> ]

other array. Must be compatible with
self
(see Broadcasting ). Should have an integer data type. Each element must be greater than or equal to0
.

Returns ¶

out : <array>

an array containing the elementwise results. The returned array must have the same data type as
self
.

Note
Elementwise results must equal the results returned by the equivalent elementwise function
bitwise_left_shift(x1,
x2)
.
__lt__(self, other, /) ¶
Computes the truth value of
self_i
<
other_i
for each element of an array instance with the respective element of the array
other
.
Parameters ¶

self : <array>

array instance. Should have a numeric data type.


other : Union[ int, float, <array> ]

other array. Must be compatible with
self
(see Broadcasting ). Should have a numeric data type.

Returns ¶

out : <array>

an array containing the elementwise results. The returned array must have a data type of
bool
.

Note
Elementwise results must equal the results returned by the equivalent elementwise function
less(x1,
x2)
.
__matmul__(self, other, /) ¶
Computes the matrix product.
Note
The
matmul
function must implement the same semantics as the builtin
@
operator (see
PEP 465
).
Parameters ¶

self : <array>

array instance. Should have a numeric data type. Must have at least one dimension. If
self
is onedimensional having shape(M)
andother
has more than one dimension,self
must be promoted to a twodimensional array by prepending1
to its dimensions (i.e., must have shape(1, M)
). After matrix multiplication, the prepended dimensions in the returned array must be removed. Ifself
has more than one dimension (including after vectortomatrix promotion),self
must be compatible withother
(see Broadcasting ). Ifself
has shape(..., M, K)
, the innermost two dimensions form matrices on which to perform matrix multiplication.


other : <array>

other array. Should have a numeric data type. Must have at least one dimension. If
other
is onedimensional having shape(N)
andself
has more than one dimension,other
must be promoted to a twodimensional array by appending1
to its dimensions (i.e., must have shape(N, 1)
). After matrix multiplication, the appended dimensions in the returned array must be removed. Ifother
has more than one dimension (including after vectortomatrix promotion),other
must be compatible withself
(see Broadcasting ). Ifother
has shape(..., K, N)
, the innermost two dimensions form matrices on which to perform matrix multiplication.

Returns ¶

out : <array>

if both
self
andother
are onedimensional arrays having shape(N)
, a zerodimensional array containing the inner product as its only element. 
if
self
is a twodimensional array having shape(M, K)
andother
is a twodimensional array having shape(K, N)
, a twodimensional array containing the conventional matrix product and having shape(M, N)
. 
if
self
is a onedimensional array having shape(K)
andother
is an array having shape(..., K, N)
, an array having shape(..., N)
(i.e., prepended dimensions during vectortomatrix promotion must be removed) and containing the conventional matrix product . 
if
self
is an array having shape(..., M, K)
andother
is a onedimensional array having shape(K)
, an array having shape(..., M)
(i.e., appended dimensions during vectortomatrix promotion must be removed) and containing the conventional matrix product . 
if
self
is a twodimensional array having shape(M, K)
andother
is an array having shape(..., K, N)
, an array having shape(..., M, N)
and containing the conventional matrix product for each stacked matrix. 
if
self
is an array having shape(..., M, K)
andother
is a twodimensional array having shape(K, N)
, an array having shape(..., M, N)
and containing the conventional matrix product for each stacked matrix. 
if either
self
orother
has more than two dimensions, an array having a shape determined by Broadcastingself
againstother
and containing the conventional matrix product for each stacked matrix.
The returned array must have a data type determined by Type Promotion Rules .
Note
Results must equal the results returned by the equivalent function
matmul(x1, x2)
. 
Raises ¶

if either
self
orother
is a zerodimensional array. 
if
self
is a onedimensional array having shape(N)
,other
is a onedimensional array having shape(M)
, andN != M
. 
if
self
is an array having shape(..., M, K)
,other
is an array having shape(..., L, N)
, andK != L
.
__mod__(self, other, /) ¶
Evaluates
self_i
%
other_i
for each element of an array instance with the respective element of the array
other
.
Parameters ¶

self : <array>

array instance. Should have a numeric data type.


other : Union[ int, float, <array> ]

other array. Must be compatible with
self
(see Broadcasting ). Should have a numeric data type.

Returns ¶

out : <array>

an array containing the elementwise results. Each elementwise result must have the same sign as the respective element
other_i
. The returned array must have a floatingpoint data type determined by Type Promotion Rules .

Note
Elementwise results must equal the results returned by the equivalent elementwise function
remainder(x1,
x2)
.
__mul__(self, other, /) ¶
Calculates the product for each element of an array instance with the respective element of the array
other
.
Special Cases ¶
For floatingpoint operands, let
self
equal
x1
and
other
equal
x2
.

If either
x1_i
orx2_i
isNaN
, the result isNaN
. 
If
x1_i
is either+infinity
orinfinity
andx2_i
is either+0
or0
, the result isNaN
. 
If
x1_i
is either+0
or0
andx2_i
is either+infinity
orinfinity
, the result isNaN
. 
If
x1_i
andx2_i
have the same mathematical sign, the result has a positive mathematical sign, unless the result isNaN
. If the result isNaN
, the “sign” ofNaN
is implementationdefined. 
If
x1_i
andx2_i
have different mathematical signs, the result has a negative mathematical sign, unless the result isNaN
. If the result isNaN
, the “sign” ofNaN
is implementationdefined. 
If
x1_i
is either+infinity
orinfinity
andx2_i
is either+infinity
orinfinity
, the result is a signed infinity with the mathematical sign determined by the rule already stated above. 
If
x1_i
is either+infinity
orinfinity
andx2_i
is a nonzero finite number, the result is a signed infinity with the mathematical sign determined by the rule already stated above. 
If
x1_i
is a nonzero finite number andx2_i
is either+infinity
orinfinity
, the result is a signed infinity with the mathematical sign determined by the rule already stated above. 
In the remaining cases, where neither
infinity
norNaN
is involved, the product must be computed and rounded to the nearest representable value according to IEEE 7542019 and a supported rounding mode. If the magnitude is too large to represent, the result is aninfinity
of appropriate mathematical sign. If the magnitude is too small to represent, the result is a zero of appropriate mathematical sign.
Note
Floatingpoint multiplication is not always associative due to finite precision.
Parameters ¶

self : <array>

array instance. Should have a numeric data type.


other : Union[ int, float, <array> ]

other array. Must be compatible with
self
(see Broadcasting ). Should have a numeric data type.

Returns ¶

out : <array>

an array containing the elementwise products. The returned array must have a data type determined by Type Promotion Rules .

Note
Elementwise results must equal the results returned by the equivalent elementwise function
multiply(x1,
x2)
.
__ne__(self, other, /) ¶
Computes the truth value of
self_i
!=
other_i
for each element of an array instance with the respective element of the array
other
.
Parameters ¶

self : <array>

array instance. May have any data type.


other : Union[ int, float, bool, <array> ]

other array. Must be compatible with
self
(see Broadcasting ). May have any data type.

Returns ¶

out : <array>

an array containing the elementwise results. The returned array must have a data type of
bool
(i.e., must be a boolean array).

Note
Elementwise results must equal the results returned by the equivalent elementwise function
not_equal(x1,
x2)
.
__neg__(self, /) ¶
Evaluates
self_i
for each element of an array instance.
Note
For signed integer data types, the numerical negative of the minimum representable integer is implementationdependent.
Parameters ¶

self : <array>

array instance. Should have a numeric data type.

Returns ¶

out : <array>

an array containing the evaluated result for each element in
self
. The returned array must have a data type determined by Type Promotion Rules .

Note
Elementwise results must equal the results returned by the equivalent elementwise function
negative(x)
.
__or__(self, other, /) ¶
Evaluates
self_i

other_i
for each element of an array instance with the respective element of the array
other
.
Parameters ¶

self : <array>

array instance. Should have an integer or boolean data type.


other : Union[ int, bool, <array> ]

other array. Must be compatible with
self
(see Broadcasting ). Should have an integer or boolean data type.

Returns ¶

out : <array>

an array containing the elementwise results. The returned array must have a data type determined by Type Promotion Rules .

Note
Elementwise results must equal the results returned by the equivalent elementwise function
bitwise_or(x1,
x2)
.
__pos__(self, /) ¶
Evaluates
+self_i
for each element of an array instance.
Parameters ¶

self : <array>

array instance. Should have a numeric data type.

Returns ¶

out : <array>

an array containing the evaluated result for each element. The returned array must have the same data type as
self
.

Note
Elementwise results must equal the results returned by the equivalent elementwise function
positive(x)
.
__pow__(self, other, /) ¶
Calculates an implementationdependent approximation of exponentiation by raising each element (the base) of an array instance to the power of
other_i
(the exponent), where
other_i
is the corresponding element of the array
other
.
Special Cases ¶
For floatingpoint operands, let
self
equal
x1
and
other
equal
x2
.

If
x1_i
is not equal to1
andx2_i
isNaN
, the result isNaN
. 
If
x2_i
is+0
, the result is1
, even ifx1_i
isNaN
. 
If
x2_i
is0
, the result is1
, even ifx1_i
isNaN
. 
If
x1_i
isNaN
andx2_i
is not equal to0
, the result isNaN
. 
If
abs(x1_i)
is greater than1
andx2_i
is+infinity
, the result is+infinity
. 
If
abs(x1_i)
is greater than1
andx2_i
isinfinity
, the result is+0
. 
If
abs(x1_i)
is1
andx2_i
is+infinity
, the result is1
. 
If
abs(x1_i)
is1
andx2_i
isinfinity
, the result is1
. 
If
x1_i
is1
andx2_i
is notNaN
, the result is1
. 
If
abs(x1_i)
is less than1
andx2_i
is+infinity
, the result is+0
. 
If
abs(x1_i)
is less than1
andx2_i
isinfinity
, the result is+infinity
. 
If
x1_i
is+infinity
andx2_i
is greater than0
, the result is+infinity
. 
If
x1_i
is+infinity
andx2_i
is less than0
, the result is+0
. 
If
x1_i
isinfinity
andx2_i
is greater than0
, the result isinfinity
. 
If
x1_i
isinfinity
,x2_i
is greater than0
, andx2_i
is not an odd integer value, the result is+infinity
. 
If
x1_i
isinfinity
,x2_i
is less than0
, andx2_i
is an odd integer value, the result is0
. 
If
x1_i
isinfinity
,x2_i
is less than0
, andx2_i
is not an odd integer value, the result is+0
. 
If
x1_i
is+0
andx2_i
is greater than0
, the result is+0
. 
If
x1_i
is+0
andx2_i
is less than0
, the result is+infinity
. 
If
x1_i
is0
,x2_i
is greater than0
, andx2_i
is an odd integer value, the result is0
. 
If
x1_i
is0
,x2_i
is greater than0
, andx2_i
is not an odd integer value, the result is+0
. 
If
x1_i
is0
,x2_i
is less than0
, andx2_i
is an odd integer value, the result isinfinity
. 
If
x1_i
is0
,x2_i
is less than0
, andx2_i
is not an odd integer value, the result is+infinity
. 
If
x1_i
is less than0
,x1_i
is a finite number,x2_i
is a finite number, andx2_i
is not an integer value, the result isNaN
.
Parameters ¶

self : <array>

array instance whose elements correspond to the exponentiation base. Should have a numeric data type.


other : Union[ int, float, <array> ]

other array whose elements correspond to the exponentiation exponent. Must be compatible with
self
(see Broadcasting ). Should have a numeric data type.

Returns ¶

out : <array>

an array containing the elementwise results. The returned array must have a data type determined by Type Promotion Rules .

Note
Elementwise results must equal the results returned by the equivalent elementwise function
pow(x1,
x2)
.
__rshift__(self, other, /) ¶
Evaluates
self_i
>>
other_i
for each element of an array instance with the respective element of the array
other
.
Parameters ¶

self : <array>

array instance. Should have an integer data type.


other : Union[ int, <array> ]

other array. Must be compatible with
self
(see Broadcasting ). Should have an integer data type. Each element must be greater than or equal to0
.

Returns ¶

out : <array>

an array containing the elementwise results. The returned array must have the same data type as
self
.

Note
Elementwise results must equal the results returned by the equivalent elementwise function
bitwise_right_shift(x1,
x2)
.
__setitem__(self, key, value, /) ¶
Sets
self[key]
to
value
.
Parameters ¶

self : <array>

array instance.


key : Union[ int, slice, ellipsis, Tuple[ Union[ int, slice, ellipsis ], … ], <array> ]

index key.


value : Union[ int, float, bool, <array> ]

value(s) to set. Must be compatible with
self[key]
(see Broadcasting ).

Note
Setting array values must not affect the data type of
self
.
When
value
is a Python scalar (i.e.,
int
,
float
,
bool
), behavior must follow specification guidance on mixing arrays with Python scalars (see
Type Promotion Rules
).
When
value
is an
array
of a different data type than
self
, how values are cast to the data type of
self
is implementation defined.
__sub__(self, other, /) ¶
Calculates the difference for each element of an array instance with the respective element of the array
other
. The result of
self_i

other_i
must be the same as
self_i
+
(other_i)
and must be governed by the same floatingpoint rules as addition (see
__add__()
).
Parameters ¶

self : <array>

array instance (minuend array). Should have a numeric data type.


other : Union[ int, float, <array> ]

subtrahend array. Must be compatible with
self
(see Broadcasting ). Should have a numeric data type.

Returns ¶

out : <array>

an array containing the elementwise differences. The returned array must have a data type determined by Type Promotion Rules .

Note
Elementwise results must equal the results returned by the equivalent elementwise function
subtract(x1,
x2)
.
__truediv__(self, other, /) ¶
Evaluates
self_i
/
other_i
for each element of an array instance with the respective element of the array
other
.
Special Cases ¶
For floatingpoint operands, let
self
equal
x1
and
other
equal
x2
.

If either
x1_i
orx2_i
isNaN
, the result isNaN
. 
If
x1_i
is either+infinity
orinfinity
andx2_i
is either+infinity
orinfinity
, the result isNaN
. 
If
x1_i
is either+0
or0
andx2_i
is either+0
or0
, the result isNaN
. 
If
x1_i
is+0
andx2_i
is greater than0
, the result is+0
. 
If
x1_i
is0
andx2_i
is greater than0
, the result0
. 
If
x1_i
is+0
andx2_i
is less than0
, the result is0
. 
If
x1_i
is0
andx2_i
is less than0
, the result is+0
. 
If
x1_i
is greater than0
andx2_i
is+0
, the result is+infinity
. 
If
x1_i
is greater than0
andx2_i
is0
, the result isinfinity
. 
If
x1_i
is less than0
andx2_i
is+0
, the result isinfinity
. 
If
x1_i
is less than0
andx2_i
is0
, the result is+infinity
. 
If
x1_i
is+infinity
andx2_i
is a positive (i.e., greater than0
) finite number, the result is+infinity
. 
If
x1_i
is+infinity
andx2_i
is a negative (i.e., less than0
) finite number, the result isinfinity
. 
If
x1_i
isinfinity
andx2_i
is a positive (i.e., greater than0
) finite number, the result isinfinity
. 
If
x1_i
isinfinity
andx2_i
is a negative (i.e., less than0
) finite number, the result is+infinity
. 
If
x1_i
is a positive (i.e., greater than0
) finite number andx2_i
is+infinity
, the result is+0
. 
If
x1_i
is a positive (i.e., greater than0
) finite number andx2_i
isinfinity
, the result is0
. 
If
x1_i
is a negative (i.e., less than0
) finite number andx2_i
is+infinity
, the result is0
. 
If
x1_i
is a negative (i.e., less than0
) finite number andx2_i
isinfinity
, the result is+0
. 
If
x1_i
andx2_i
have the same mathematical sign and are both nonzero finite numbers, the result has a positive mathematical sign. 
If
x1_i
andx2_i
have different mathematical signs and are both nonzero finite numbers, the result has a negative mathematical sign. 
In the remaining cases, where neither
infinity
,+0
,0
, norNaN
is involved, the quotient must be computed and rounded to the nearest representable value according to IEEE 7542019 and a supported rounding mode. If the magnitude is too larger to represent, the operation overflows and the result is aninfinity
of appropriate mathematical sign. If the magnitude is too small to represent, the operation underflows and the result is a zero of appropriate mathematical sign.
Parameters ¶

self : <array>

array instance. Should have a numeric data type.


other : Union[ int, float, <array> ]

other array. Must be compatible with
self
(see Broadcasting ). Should have a numeric data type.

Returns ¶

out : <array>

an array containing the elementwise results. The returned array must have a data type determined by Type Promotion Rules .

Note
Elementwise results must equal the results returned by the equivalent elementwise function
divide(x1,
x2)
.
__xor__(self, other, /) ¶
Evaluates
self_i
^
other_i
for each element of an array instance with the respective element of the array
other
.
Parameters ¶

self : <array>

array instance. Should have an integer or boolean data type.


other : Union[ int, bool, <array> ]

other array. Must be compatible with
self
(see Broadcasting ). Should have an integer or boolean data type.

Returns ¶

out : <array>

an array containing the elementwise results. The returned array must have a data type determined by Type Promotion Rules .

Note
Elementwise results must equal the results returned by the equivalent elementwise function
bitwise_xor(x1,
x2)
.
to_device(self, device, /) ¶
Move the array to the given device.
Parameters ¶

self : <array>

array instance.


device : <device>

a
device
object (see Device support ).

Returns ¶

out : <array>

an array with the same data and dtype, located on the specified device.
