Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://data-apis.org/array-api/latest/API_specification/array_object.html below:

Array object — Python array API standard 2024.12 documentation

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.

Furthermore, a conforming implementation of the array API standard must support, at minimum, array objects of rank (i.e., number of dimensions) 0, 1, 2, 3, and 4 and must explicitly document their maximum supported rank N.

Note

Conforming implementations must support zero-dimensional arrays.

Apart from array object attributes, such as ndim, device, and dtype, all operations in this standard return arrays (or tuples of arrays), including those operations, such as mean, var, and std, from which some common array libraries (e.g., NumPy) return scalar values.

Rationale: always returning arrays is necessary to (1) support accelerator libraries where non-array return values could force device synchronization and (2) support delayed execution models where an array represents a future value.

A conforming implementation of the array API standard must provide and support an array object supporting the following Python operators.

A conforming implementation of the array API standard must provide and support an array object supporting the following Python arithmetic operators.

• +x: array.__pos__()

  • operator.pos(x)

  • operator.__pos__(x)

• -x: array.__neg__()

  • operator.neg(x)

  • operator.__neg__(x)

• x1 + x2: array.__add__()

  • operator.add(x1, x2)

  • operator.__add__(x1, x2)

• x1 - x2: array.__sub__()

  • operator.sub(x1, x2)

  • operator.__sub__(x1, x2)

• x1 * x2: array.__mul__()

  • operator.mul(x1, x2)

  • operator.__mul__(x1, x2)

• x1 / x2: array.__truediv__()

  • operator.truediv(x1,x2)

  • operator.__truediv__(x1, x2)

• x1 // x2: array.__floordiv__()

  • operator.floordiv(x1, x2)

  • operator.__floordiv__(x1, x2)

• x1 % x2: array.__mod__()

  • operator.mod(x1, x2)

  • operator.__mod__(x1, x2)

• x1 ** x2: array.__pow__()

  • operator.pow(x1, x2)

  • operator.__pow__(x1, x2)

Arithmetic operators should be defined for arrays having real-valued data types.

A conforming implementation of the array API standard must provide and support an array object supporting the following Python array operators.

• x1 @ x2: array.__matmul__()

  • operator.matmul(x1, x2)

  • operator.__matmul__(x1, x2)

The matmul @ operator should be defined for arrays having numeric data types.

A conforming implementation of the array API standard must provide and support an array object supporting the following Python bitwise operators.

• ~x: array.__invert__()

  • operator.inv(x)

  • operator.invert(x)

  • operator.__inv__(x)

  • operator.__invert__(x)

• x1 & x2: array.__and__()

  • operator.and(x1, x2)

  • operator.__and__(x1, x2)

• x1 | x2: array.__or__()

  • operator.or(x1, x2)

  • operator.__or__(x1, x2)

• x1 ^ x2: array.__xor__()

  • operator.xor(x1, x2)

  • operator.__xor__(x1, x2)

• x1 << x2: array.__lshift__()

  • operator.lshift(x1, x2)

  • operator.__lshift__(x1, x2)

• x1 >> x2: array.__rshift__()

  • operator.rshift(x1, x2)

  • operator.__rshift__(x1, x2)

Bitwise operators should be defined for arrays having integer and boolean data types.

A conforming implementation of the array API standard must provide and support an array object supporting the following Python comparison operators.

• x1 < x2: array.__lt__()

  • operator.lt(x1, x2)

  • operator.__lt__(x1, x2)

• x1 <= x2: array.__le__()

  • operator.le(x1, x2)

  • operator.__le__(x1, x2)

• x1 > x2: array.__gt__()

  • operator.gt(x1, x2)

  • operator.__gt__(x1, x2)

• x1 >= x2: array.__ge__()

  • operator.ge(x1, x2)

  • operator.__ge__(x1, x2)

• x1 == x2: array.__eq__()

  • operator.eq(x1, x2)

  • operator.__eq__(x1, x2)

• x1 != x2: array.__ne__()

  • operator.ne(x1, x2)

  • operator.__ne__(x1, x2)

array.__lt__(), array.__le__(), array.__gt__(), array.__ge__() are only defined for arrays having real-valued data types. Other comparison operators should be defined for arrays having any data type. For backward compatibility, conforming implementations may support complex numbers; however, inequality comparison of complex numbers is unspecified and thus implementation-dependent (see Complex Number Ordering).

A conforming implementation of the array API standard must provide and support an array object supporting the following “in-place” Python operators.

Note

This specification refers to the following operators as “in-place” as that is what these operators are called in Python <https://docs.python.org/3/library/operator.html#in-place-operators>. However, conforming array libraries which do not support array mutation may choose to not explicitly implement in-place Python operators. When a library does not implement a method corresponding to an in-place Python operator, Python falls back to the equivalent method for the corresponding binary arithmetic operation.

An in-place operation must not change the data type or shape of the in-place array as a result of Type Promotion Rules or Broadcasting.

Let x1 += x2 be a representative in-place operation. If, after applying type promotion (see Type Promotion Rules) to in-place operands x1 and x2, the resulting data type is equal to the data type of the array on the left-hand side of the operation (i.e., x1), then an in-place operation must have the same behavior (including special cases) as the respective binary (i.e., two operand, non-assignment) operation. In this case, for the in-place addition x1 += x2, the modified array x1 must always equal the result of the equivalent binary arithmetic operation x1[...] = x1 + x2.

If, however, after applying type promotion (see Type Promotion Rules) to in-place operands, the resulting data type is not equal to the data type of the array on the left-hand side of the operation, then a conforming implementation may return results which differ from the respective binary operation due to casting behavior and selection of the operation’s intermediate precision. The choice of casting behavior and intermediate precision is unspecified and thus implementation-defined.

Note

Let x1 be the operand on the left-hand side and x2 be the operand on the right-hand side of an in-place operation. Consumers of the array API standard are advised of the following considerations when using in-place operations:

1. In-place operations do not guarantee in-place mutation. A conforming library may or may not support in-place mutation.

2. If, after applying broadcasting (see Broadcasting) to in-place operands, the resulting shape is not equal to the shape of x1, in-place operators may raise an exception.

3. If, after applying type promotion (see Type Promotion Rules) to in-place operands, the resulting data type is not equal to the data type of x1, the resulting data type may not equal the data type of x1 and the operation’s intermediate precision may be that of x1, even if the promoted data type between x1 and x2 would have higher precision.

In general, for in-place operations, consumers of the array API standard are advised to ensure operands have the same data type and broadcast to the shape of the operand on the left-hand side of the operation in order to maximize portability.

• +=. 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 __imod__.

• @=. May be implemented via __imatmul__.

• &=. 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__.

A conforming implementation of the array API standard must provide and support an array object supporting the following reflected operators.

The results of applying reflected operators must match their non-reflected equivalents.

Note

All operators for which array <op> scalar is implemented must have an equivalent reflected operator implementation.

• __radd__

• __rsub__

• __rmul__

• __rtruediv__

• __rfloordiv__

• __rpow__

• __rmod__

• __rmatmul__

• __rand__

• __ror__

• __rxor__

• __rlshift__

• __rrshift__

array.__abs__()

Calculates the absolute value for each element of an array instance.

array.__add__(other, /)

Calculates the sum for each element of an array instance with the respective element of the array other.

array.__and__(other, /)

Evaluates self_i & other_i for each element of an array instance with the respective element of the array other.

array.__array_namespace__(*, api_version=None)

Returns an object that has all the array API functions on it.

array.__bool__()

Converts a zero-dimensional array to a Python bool object.

array.__complex__()

Converts a zero-dimensional array to a Python complex object.

array.__dlpack__(*, stream=None, max_version=None, dl_device=None, copy=None)

Exports the array for consumption by from_dlpack() as a DLPack capsule.

array.__dlpack_device__()

Returns device type and device ID in DLPack format.

array.__eq__(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.

array.__float__()

Converts a zero-dimensional array to a Python float object.

array.__floordiv__(other, /)

Evaluates self_i // other_i for each element of an array instance with the respective element of the array other.

array.__ge__(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.

array.__getitem__(key, /)

Returns self[key].

array.__gt__(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.

array.__index__()

Converts a zero-dimensional integer array to a Python int object.

array.__int__()

Converts a zero-dimensional array to a Python int object.

array.__invert__()

Evaluates ~self_i for each element of an array instance.

array.__le__(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.

array.__lshift__(other, /)

Evaluates self_i << other_i for each element of an array instance with the respective element of the array other.

array.__lt__(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.

array.__matmul__(other, /)

Computes the matrix product.

array.__mod__(other, /)

Evaluates self_i % other_i for each element of an array instance with the respective element of the array other.

array.__mul__(other, /)

Calculates the product for each element of an array instance with the respective element of the array other.

array.__ne__(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.

array.__neg__()

Evaluates -self_i for each element of an array instance.

array.__or__(other, /)

Evaluates self_i | other_i for each element of an array instance with the respective element of the array other.

array.__pos__()

Evaluates +self_i for each element of an array instance.

array.__pow__(other, /)

Calculates an implementation-dependent 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.

array.__rshift__(other, /)

Evaluates self_i >> other_i for each element of an array instance with the respective element of the array other.

array.__setitem__(key, value, /)

Sets self[key] to value.

array.__sub__(other, /)

Calculates the difference for each element of an array instance with the respective element of the array other.

array.__truediv__(other, /)

Evaluates self_i / other_i for each element of an array instance with the respective element of the array other.

array.__xor__(other, /)

Evaluates self_i ^ other_i for each element of an array instance with the respective element of the array other.

array.to_device(device, /, *, stream=None)

Copy the array from the device on which it currently resides to the specified device.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4