Class array

warp/_src/types.py:3044–4526

A fixed-size multi-dimensional array containing values of the same type. Attributes: dtype (DType): The data type of the array. ndim (int): The number of array dimensions. size (int): The number of items in the array. capacity (int): The amount of memory in bytes

class array(Array[DType, NDim]):
    """A fixed-size multi-dimensional array containing values of the same type.

    Attributes:
        dtype (DType): The data type of the array.
        ndim (int): The number of array dimensions.
        size (int): The number of items in the array.
        capacity (int): The amount of memory in bytes allocated for this array.
        shape (tuple[int]): Dimensions of the array.
        strides (tuple[int]): Number of bytes in each dimension between successive elements of the array.
        ptr (int): Pointer to underlying memory allocation backing the array.
        device (Device): The device where the array's memory allocation resides.
        pinned (bool): Indicates whether the array was allocated in pinned host memory.
        is_contiguous (bool): Indicates whether this array has a contiguous memory layout.
        deleter (Callable[[int, int], None]): A function to be called when the array is deleted,
            taking two arguments: pointer and size. If ``None``, then no function is called.
    """

    @classmethod
    def __class_getitem__(cls, params):
        """Support ``wp.array[dtype]`` and ``wp.array[dtype, Literal[ndim]]`` syntax."""
        return _parse_array_subscript(cls, params)

    def __new__(cls, *args, **kwargs):
        instance = super().__new__(cls)
        instance.deleter = None
        return instance

    def __init__(
        self,
        data: list | tuple | npt.NDArray | None = None,
        dtype: Any = Any,
        shape: int | tuple[int, ...] | list[int] | None = None,
        strides: tuple[int, ...] | None = None,
        ptr: int | None = None,
        capacity: int | None = None,
        device: warp.DeviceLike = None,
        pinned: builtins.bool = False,
        copy: builtins.bool = True,
        deleter: Callable[[int, int], None] | None = None,
        ndim: int | None = None,
        grad: array | None = None,
        requires_grad: builtins.bool = False,
        retain_grad: builtins.bool = False,
    ):
        """Construct a new Warp array object.

        When the ``data`` argument is a valid list, tuple, or ndarray the array will be constructed from this object's data.
        For objects that are not stored sequentially in memory (e.g.: a list), then the data will first
        be flattened before being transferred to the memory space given by device.

        The second construction path occurs when the ``ptr`` argument is a non-zero uint64 value representing the
        start address in memory where existing array data resides, e.g.: from an external or C-library. The memory
        allocation should reside on the same device given by the device argument, and the user should set the length
        and dtype parameter appropriately.

        If neither ``data`` nor ``ptr`` are specified, the ``shape`` argument is checked next.
        This construction path can be used to create new uninitialized arrays, but users are encouraged to call