Raised when a Hurray tensor descriptor fails validation. Subclass of :exc:ValueError.

Raised for buffer size or alignment errors. Subclass of :exc:ValueError.

.. note:: This is hurray.BufferError, distinct from the built-in builtins.BufferError used by the DLPack protocol for non-representable element types.

Raised when copy=False is passed to __array__ but a copy is required (e.g. a dtype cast is needed). Subclass of :exc:ValueError.

This follows the NumPy 2.0 __array__ convention (NEP 47): the caller requested zero-copy but the conversion cannot be done without copying.

Raised when an element type, memory layout, or device combination is not supported by the current Hurray version. Subclass of :exc:NotImplementedError.

Raised when an unexpected Rust panic is caught by the binding layer. Subclass of :exc:RuntimeError.

If you see this exception, please file a bug report.

Raised by hurray.load() and hurray.save() for file-level errors: file not found, permission denied, corrupt HRRYFILE container, unexpected EOF. Subclass of :exc:OSError.

Raised by the streaming reader/writer for framing errors: frame corruption mid-stream, unexpected stream termination. Subclass of :exc:OSError.

A Hurray element type descriptor.

Dtype objects are singletons: hurray.float32 is hurray.dtype.float32. They are immutable (frozen) and hashable — safe to use as dict keys.

Tier classification

Examples (Python)

import hurray

assert hurray.float32.name == "float32"
assert hurray.float32.is_array_api
assert hurray.float32 is hurray.dtype.float32   # singleton identity

assert hurray.dtype.int4.bit_width == 4
assert not hurray.dtype.int4.is_array_api
assert not hasattr(hurray, "int4")              # Tier 2: no top-level alias

# Usable as a dict key.
dtypes = {hurray.float32: "fp32", hurray.dtype.int4: "i4"}
assert dtypes[hurray.float32] == "fp32"

The number of bytes a buffer needs to hold count elements of dtype.

Not count * dtype.bit_width // 8: sub-byte types pack, and the packing rules differ per width (memory-layout.md § Sub-byte packing). int4 fits two elements per byte and rounds up; bool fits eight; the 6-bit float types pack four elements into three bytes. Getting this wrong produces a buffer that is one byte short of the last element, which the descriptor validator catches and the caller then has to debug.

Examples

import hurray

assert hurray.buffer_size_bytes(hurray.float32, 100) == 400
assert hurray.buffer_size_bytes(hurray.dtype.int4, 7) == 4        # ceil(7 / 2)
assert hurray.buffer_size_bytes(hurray.bool, 9) == 2              # ceil(9 / 8)
assert hurray.buffer_size_bytes(hurray.dtype.float6_e2m3, 100) == 75  # ceil(100/4)*3
assert hurray.buffer_size_bytes(hurray.float32, 0) == 0

Errors

• hurray.InvalidDescriptorError — dtype is a private extension type. Its width is not in the dtype but in the descriptor's extension type section, so the answer lives on hurray.ExtensionType.buffer_size_bytes instead:

import hurray

try:
    hurray.buffer_size_bytes(hurray.Dtype.from_tag(0xF2), 10)
except hurray.InvalidDescriptorError:
    pass

assert hurray.ExtensionType(bit_width=24).buffer_size_bytes(10) == 30

A Hurray device descriptor: a (kind, device_id, memory_class) triple.

Device objects are immutable (frozen) and hashable — safe to use as dict keys.

Constructor

hurray.Device(kind, device_id=0, memory_class="standard")

Examples (Python)

import hurray

cpu = hurray.Device("cpu")
assert cpu.kind == "cpu"
assert cpu.device_id == 0
assert cpu.memory_class == "standard"

gpu = hurray.Device("cuda", 1)
assert gpu.kind == "cuda"
assert gpu.device_id == 1

# Well-known constants
assert hurray.Device("cpu") == hurray.device.cpu

# Hashable
d = {hurray.device.cpu: "cpu0"}
assert d[hurray.Device("cpu")] == "cpu0"

A Hurray tensor: element type, shape, device, and a data buffer.

Construction

hurray.Tensor(buffer, dtype, shape, device=None)

Zero-copy interop

Use hurray.from_numpy or hurray.from_torch to create tensors that share the source buffer without copying. The Tensor holds a strong Python reference to the source object so its buffer remains valid.

Examples (Python)

import struct, hurray

buf = struct.pack("6f", 1.0, 2.0, 3.0, 4.0, 5.0, 6.0)
t = hurray.Tensor(buf, hurray.float32, [2, 3])

assert t.shape == (2, 3)
assert t.ndim == 2
assert t.size == 6
assert t.dtype == hurray.float32
assert t.device.kind == "cpu"

Wrap a NumPy ndarray as a hurray.Tensor, sharing its buffer when the format permits it.

When the array's base address meets the format's 64-byte alignment floor, the returned Tensor borrows the buffer and holds a strong Python reference to the source ndarray so it stays valid for the Tensor's entire lifetime. When it does not, the bytes are copied into an aligned allocation — see copy below.

Requirements

• The array MUST be C-contiguous (row-major). Pass numpy.ascontiguousarray(arr) first if the array is Fortran-order or has non-contiguous strides (D5).
• The array dtype MUST map to a Hurray Tier 1 element type.
• The array MUST reside on CPU (device 0).

The copy argument (ADR-037 § 6)

buffer-protocol.md § Alignment requires every non-empty buffer to start on a 64-byte boundary, and NumPy does not promise one. A large array served by a fresh mmap never has one — glibc puts a 16-byte chunk header before the pointer — and any other array's address is a matter of heap history. Either way the caller cannot arrange for it, which is why this decision is made per call rather than assumed.

• copy=None (default) — copy only when the source is under-aligned.
• copy=False — never copy; raise hurray.BufferError naming the alignment the source actually has, so the cost is visible rather than a silent memcpy.
• copy=True — always copy.

Errors

• hurray.UnsupportedError — array is not C-contiguous (D5).
• hurray.UnsupportedError — dtype has no Hurray equivalent.
• hurray.BufferError — cannot extract buffer pointer from the array, or copy=False was requested for an under-aligned array.

Examples

import numpy as np, hurray

arr = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype=np.float32)
t = hurray.from_numpy(arr)
assert t.shape == (2, 3)
assert t.dtype == hurray.float32
assert t.device.kind == "cpu"
assert t.buffer_handles[0].alignment >= hurray.MIN_BUFFER_ALIGNMENT

Wrap a torch.Tensor as a hurray.Tensor, sharing its buffer when the format permits it (via DLPack).

torch is resolved at call time — import hurray does not require PyTorch (D7).

copy means what it means in from_numpy, and applies to the array DLPack hands back: PyTorch's CPU allocator is 64-byte aligned for most tensors, so copy=False usually succeeds here where it usually fails for arrays NumPy allocated.

Errors

• ImportError — PyTorch is not installed.
• builtins.BufferError — element type not representable in DLPack.
• hurray.BufferError — copy=False was requested for an under-aligned tensor.

Examples

import torch, hurray

t_torch = torch.zeros(2, 3, dtype=torch.float32)
t = hurray.from_torch(t_torch)
assert t.shape == (2, 3)
assert t.dtype == hurray.float32

Which category of the layout tag space tag falls in.

Returns "named", "reserved", "private", or "invalid".

The four call for different reactions, which is the whole reason to ask. A named tag is one this build understands. A reserved tag is one a future version of the format may assign — most likely the producer is newer than this reader, so relaying the tensor on is reasonable while interpreting its bytes is not. A private tag (0xF0–0xFE) belongs to an out-of-band agreement between a particular producer and consumer. An invalid tag can never appear in a conformant descriptor, so it means corruption or a framing error.

One function rather than the four predicates hurray-core exposes: a caller wants to branch on the answer, not ask four yes/no questions in sequence.

Examples

import hurray

assert hurray.layout_tag_kind(0x07) == "named"      # CSR
assert hurray.layout_tag_kind(0x10) == "reserved"
assert hurray.layout_tag_kind(0xF3) == "private"
assert hurray.layout_tag_kind(0x00) == "invalid"

# What a relay does with a tag it does not recognise:
tag = 0x10
if hurray.layout_tag_kind(tag) == "reserved":
    pass    # pass the tensor on; do not touch its buffer

The memory layout of a tensor: a tag plus that layout's parameters.

Layout is the base of every layout class and is not constructible from Python — there is no layout that is only "a layout". It is returned directly only as the fallback for a layout tag this build of hurray does not yet bind, in which case tag and name are still available.

Examples (Python)

import hurray

t = hurray.Tensor(bytes(16), hurray.float32, [4])
assert isinstance(t.layout, hurray.Layout)
assert isinstance(t.layout, hurray.RowMajorLayout)
assert t.layout.name == "row_major"
assert t.layout.tag == 0x01

Row-major (C-order) layout. Tag 0x01.

The default: element [i, j] is at offset i * ncols + j.

Examples (Python)

import hurray

t = hurray.Tensor(bytes(16), hurray.float32, [4])
assert t.layout == hurray.RowMajorLayout()

Column-major (Fortran-order) layout. Tag 0x02.

Examples (Python)

import hurray

assert hurray.ColMajorLayout().name == "col_major"

Strided layout with explicit per-dimension strides. Tag 0x03.

Strides are in logical elements, not bytes, and may be negative (a reversed axis) or zero (a broadcast axis). A reader arriving from NumPy, whose strides are in bytes, will otherwise read them wrongly.

Examples (Python)

import hurray

l = hurray.StridedLayout([4, 1])
assert l.strides == (4, 1)
assert l.name == "strided"

Tiled (blocked) layout. Tag 0x04.

Elements are grouped into fixed-size tiles; outer_layout orders the tiles and inner_layout orders the elements within a tile. A tiled layout may nest another tiled layout as its inner layout, up to the depth bound core enforces.

Examples (Python)

import hurray

l = hurray.TiledLayout([4, 4], inner_layout="col_major")
assert l.tile_shape == (4, 4)
assert l.outer_layout == "row_major"
assert l.inner_layout == "col_major"

Morton (Z-order curve) layout. Tag 0x05.

morton_bits[k] is the number of index bits interleaved for dimension k, so dimension k may be at most 2 ** morton_bits[k] long.

Examples (Python)

import hurray

l = hurray.MortonLayout([3, 3])
assert l.morton_bits == (3, 3)

Hilbert curve layout. Tag 0x40.

Every dimension must be exactly 2 ** hilbert_order long, and hilbert_rank must equal the tensor's rank.

Examples (Python)

import hurray

l = hurray.HilbertLayout(3, 2)
assert l.hilbert_order == 3
assert l.hilbert_rank == 2

Coordinate-list sparse layout. Tag 0x06. Two buffers: values, then indices.

Examples (Python)

import hurray

l = hurray.CooLayout(nnz=2, is_sorted=True)
assert l.nnz == 2
assert l.is_sorted
assert l.buffer_count == 2

Compressed-sparse-row layout. Tag 0x07. Rank 2 only.

Three buffers: values, column indices, row pointers.

Examples (Python)

import hurray

l = hurray.CsrLayout(nnz=4)
assert l.nnz == 4
assert l.buffer_count == 3

Compressed-sparse-column layout. Tag 0x08. Rank 2 only.

Three buffers: values, row indices, column pointers.

Examples (Python)

import hurray

l = hurray.CscLayout(nnz=4)
assert l.nnz == 4
assert l.name == "csc"

Compressed-sparse-fiber layout. Tag 0x09. Rank 3 and above.

The rank-N generalisation of CSR/CSC: a tree of rank levels, each contributing a pos and a crd buffer, plus one values buffer — 2 * rank + 1 in total. Those buffers have no named accessors on hurray.Tensor; reach them with t.buffer(index), in the order this layout describes.

Examples (Python)

import hurray

l = hurray.CsfLayout(nnz=5, mode_order=[0, 1, 2])
assert l.mode_order == (0, 1, 2)
assert l.buffer_count == 7

Block-paged indirect layout for a PagedAttention KV cache. Tag 0x0A.

Three buffers: the page pool, the block table, and the sequence lengths. They have no named accessors on hurray.Tensor; reach them with t.buffer(index).

Examples (Python)

import hurray

l = hurray.BlockPagedLayout(page_size=16, num_pages=64, paged_axis=0, num_seqs=2)
assert l.page_size == 16
assert l.kv_role == "key"
assert l.buffer_count == 3

Composite (virtual) head. Tag 0x0B. Owns no buffers.

A composite head presents one logical view over an ordered set of member tensors bound by stream adjacency. It is readable here so that a head decoded from a stream reports its own layout truthfully; building a hurray.Tensor with it raises hurray.UnsupportedError, because the Python Tensor cannot yet represent a tensor that owns no buffers.

Examples (Python)

import hurray

l = hurray.CompositeLayout("overlay", member_count=3, combine_op="add")
assert l.composition_rule == "overlay"
assert l.combine_op == "add"
assert l.buffer_count == 0
assert l.is_virtual

An implementation-private layout. Tags 0xF0–0xFE.

The buffer count is unknown, so a tensor built with this layout skips the buffer-size check every other layout gets: nothing in the descriptor says how large its buffers should be. That hole is intrinsic to a private tag.

Examples (Python)

import hurray

l = hurray.PrivateExtensionLayout(0xF0, extension_layout_id=7, extension_data=b"\x01")
assert l.tag == 0xF0
assert l.extension_layout_id == 7
assert l.buffer_count is None

A layout tag this implementation does not recognise, accepted in permissive mode.

Constructible so that a permissive relay can rebuild a descriptor it decoded and write it back out unchanged. Like a private layout, its buffer count is unknown, so a tensor built with it skips the buffer-size check.

Examples (Python)

import hurray

l = hurray.UnknownLayout(0x0C, b"\x00\x01")
assert l.tag == 0x0C
assert l.raw_bytes == b"\x00\x01"
assert l.name == "extension"

Construct a COO Tensor from packed component arrays, zero-copy.

values is a 1-D array of nnz elements. indices is a 2-D uint64 array of shape [nnz, rank] giving each non-zero's coordinates in row-major (C-contiguous) order — Hurray's packed COO layout. shape is the dense tensor shape; its length is the rank and must equal indices.shape[1].

Both arrays are shared without copying; the returned tensor holds strong references to keep them alive. scipy.sparse.coo_matrix stores row/col as two arrays, so it is not accepted directly — repack first: indices = numpy.stack([m.row, m.col], axis=1).astype(numpy.uint64).

Examples

import numpy as np, hurray

values = np.array([5.0, 7.0], dtype=np.float32)
indices = np.array([[0, 0], [1, 1]], dtype=np.uint64)  # [nnz, rank]
t = hurray.sparse_coo(values, indices, [2, 2])
assert t.layout == "coo"
assert t.nnz == 2

Wrap a scipy.sparse matrix as a hurray.Tensor without copying.

Supported formats

COO format is not supported via zero-copy from_scipy because SciPy stores COO row/col as two separate arrays while Hurray requires a single packed [nnz, rank] uint64 index buffer (D19). Repack first:

indices = np.stack([m.row, m.col], axis=1).astype(np.uint64)

Then construct the hurray.Tensor directly from the component buffers.

Index dtype requirement (D16)

Hurray's CSR/CSC spec requires uint64 index arrays. SciPy typically uses int32 or int64. If the index arrays are not already uint64, this function raises hurray.UnsupportedError with a cast instruction.

Errors

• ImportError — SciPy is not installed.
• hurray.UnsupportedError — unsupported matrix format (BSR, DIA, LIL, DOK).
• hurray.UnsupportedError — COO format (see above, D19).
• hurray.UnsupportedError — index arrays are not uint64 (D16).
• hurray.UnsupportedError — values dtype has no Hurray equivalent.
• hurray.CopyRequiredError — copy=False and a component array is under-aligned.

The copy argument (ADR-037 § 6)

As in from_numpy, and applied to each of .data, .indices and .indptr independently: copy=None (default) copies only the components whose address misses the format's 64-byte floor, copy=False refuses instead of copying, copy=True copies all three.

Examples

import numpy as np, scipy.sparse, hurray

m = scipy.sparse.csr_matrix(
    np.array([[1.0, 0.0], [0.0, 2.0]], dtype=np.float32)
)
# Cast index arrays to uint64 first (D16).
m.indices = m.indices.astype(np.uint64)
m.indptr  = m.indptr.astype(np.uint64)

sparse = hurray.from_scipy(m)
assert sparse.layout == "csr"
assert sparse.nnz == 2

Reads tensors from a Hurray stream, one at a time.

Iterating yields a hurray.Tensor per tensor on the wire and stops at a clean end of stream. Nothing buffers the whole input: a tensor is available as soon as its descriptor and buffers have arrived, which is the property the streaming format exists for.

Sources

A filesystem path, an object with fileno() (a socket, a pipe, an open file), or bytes. An object with no descriptor — io.BytesIO — should be passed as .getvalue().

Examples (Python)

import hurray

for tensor in hurray.StreamReader("tensors.hrry"):
    print(tensor.shape, tensor.dtype)

Writes tensors to a Hurray stream, one at a time.

finish flushes the transport, and a caller who forgets it loses whatever was still buffered — so the writer is a context manager and closing is automatic on the happy path. finish() is also available explicitly, and is idempotent.

Destinations

A filesystem path, an object with fileno(), or nothing at all — in which case the stream is built in memory and returned by getvalue().

Examples (Python)

import hurray

with hurray.StreamWriter() as writer:
    writer.write(hurray.Tensor(bytes(16), hurray.float32, [4]))
# writer.getvalue() holds the encoded stream

Accept any object whose __hurray__() returns a valid "hurray_tensor" capsule and return a new hurray.Tensor that shares the buffer without copying.

Protocol

1. Calls obj.__hurray__() to obtain the capsule.
2. Verifies the capsule name is "hurray_tensor" and the ABI version matches.
3. Renames the capsule to "used_hurray_tensor" (prevents double-destroy).
4. Extracts the data pointer and byte size from the HurrayBuffer handle.
5. Calls hurray_buffer_destroy (frees the handle; no release callback was set).
6. Decodes the TensorDescriptor from the capsule context.
7. Creates a new Tensor with BufferStore::Borrowed whose base keeps the source Tensor alive (D-NB3).

Errors

• TypeError — obj does not expose __hurray__.
• hurray.BufferError — capsule is null, malformed, or already consumed.
• hurray.UnsupportedError — ABI version mismatch between producer and consumer.
• hurray.InvalidDescriptorError — descriptor bytes could not be decoded.

Examples

import hurray

t = hurray.Tensor(bytes(16), hurray.float32, [4])
t2 = hurray.from_hurray(t)
assert t2.shape == t.shape
assert t2.dtype == t.dtype

Allocate NumPy arrays 64-byte aligned for the duration of a with block.

Arrays allocated inside the block satisfy the format's alignment floor, so hurray.from_numpy(arr, copy=False) shares their buffer instead of copying it. Arrays allocated outside are untouched.

The handler is stored per array, so an array allocated inside the block is freed through the matching deallocator long after the block exits. It is also thread- and context-local, so installing it cannot leak into unrelated code — with one consequence worth knowing: a thread started inside the block does not inherit it, and arrays that thread allocates get NumPy's default allocator and will be copied on ingest like any other.

Blocks nest: each restores the handler that was in place when it was entered.

Errors

• hurray.UnsupportedError — NumPy is older than 1.22, which predates NEP 49.

Examples

import numpy as np, hurray

with hurray.aligned_allocator():
    weights = np.zeros((512, 512), dtype=np.float32)

tensor = hurray.from_numpy(weights, copy=False)
assert tensor.buffer_handles[0].alignment >= hurray.MIN_BUFFER_ALIGNMENT

The context manager returned by aligned_allocator.

Examples

import numpy as np, hurray

with hurray.aligned_allocator():
    arr = np.zeros(1 << 20, dtype=np.float32)

assert arr.__array_interface__["data"][0] % hurray.MIN_BUFFER_ALIGNMENT == 0
t = hurray.from_numpy(arr, copy=False)      # no copy, and none was needed

One row of a tensor's buffer table: what a buffer declares about itself.

Not constructible from Python — there is no field a caller could supply that the buffers do not already settle (ADR-037 § 4).

Examples (Python)

import hurray

t = hurray.Tensor(bytes(16), hurray.float32, [4])
handle = t.buffer_handles[0]

assert handle.byte_size == 16
assert handle.alignment >= hurray.MIN_BUFFER_ALIGNMENT
assert handle.sync_mode == "producer_synced"
assert handle.device is t.device        # colocation: one device per descriptor

A composite tensor: a head presenting one logical view over ordered members.

Examples (Python)

import hurray, struct

tile = hurray.Tensor(bytes(128), hurray.float32, [8, 4], shard=hurray.Shard([8, 8], [0, 0]))
other = hurray.Tensor(bytes(128), hurray.float32, [8, 4], shard=hurray.Shard([8, 8], [0, 4]))

composite = hurray.Composite(
    "partition", shape=[8, 8], dtype=hurray.float32, members=[tile, other]
)
assert composite.member_count == 2
assert composite.layout.composition_rule == "partition"

Return a new tensor of the given shape, filled with zeros.

Default dtype is float64. Strict mode only.

Examples

import hurray

t = hurray.zeros([3, 4])
assert t.shape == (3, 4)
assert t.dtype == hurray.float64

Return a new tensor of the given shape, filled with ones.

Default dtype is float64. Strict mode only.

Examples

import hurray

t = hurray.ones([2, 3], dtype=hurray.float32)
assert t.shape == (2, 3)
assert t.dtype == hurray.float32

Return a new tensor of the given shape, filled with fill_value.

If dtype is None, it is inferred from fill_value (bool→Bool, complex→Complex128, float→Float64, int→Int64). Strict mode only.

Examples

import hurray

t = hurray.full([2, 2], 3.14, dtype=hurray.float32)
assert t.shape == (2, 2)
assert t.dtype == hurray.float32

Return a new uninitialized tensor of the given shape and type.

The buffer is zero-initialized (the contents of an "empty" tensor are unspecified). Default dtype is float64. Tier 1 only.

Examples

import hurray

t = hurray.empty([4, 4], dtype=hurray.float64)
assert t.shape == (4, 4)

Return a zeros tensor with the same shape and dtype as x.

dtype and device override the source tensor's values when given.

Examples

import hurray

src = hurray.ones([3, 3], dtype=hurray.float32)
z = hurray.zeros_like(src)
assert z.shape == (3, 3)
assert z.dtype == hurray.float32

Return an all-ones tensor with the same shape and dtype as x.

dtype and device override the source tensor's values when given.

Examples

import hurray

src = hurray.zeros([2, 2], dtype=hurray.int32)
o = hurray.ones_like(src)
assert o.shape == (2, 2)
assert o.dtype == hurray.int32

Return a tensor filled with fill_value with the same shape and dtype as x.

dtype and device override the source tensor's values when given.

Examples

import hurray

src = hurray.zeros([4], dtype=hurray.float32)
f = hurray.full_like(src, 7.0)
assert f.shape == (4,)
assert f.dtype == hurray.float32

Return an uninitialized tensor with the same shape and dtype as x.

dtype and device override the source tensor's values when given.

Examples

import hurray

src = hurray.ones([3], dtype=hurray.float64)
e = hurray.empty_like(src)
assert e.shape == (3,)
assert e.dtype == hurray.float64

Return evenly spaced values over a given interval.

arange(stop) → values [0, 1, …, stop). arange(start, stop, step) → values [start, start+step, …).

Dtype is inferred as int64 if all of start, stop, step are Python integers; float64 otherwise. Pass an explicit dtype to override.

Examples

import hurray

t = hurray.arange(5)
assert t.shape == (5,)
assert t.dtype == hurray.int64

t2 = hurray.arange(0.0, 1.0, 0.25)
assert t2.shape == (4,)
assert t2.dtype == hurray.float64

Return num evenly spaced values in the closed interval [start, stop].

Default dtype is float64. Pass endpoint=False to exclude stop. Strict mode only.

Examples

import hurray

t = hurray.linspace(0.0, 1.0, 5)
assert t.shape == (5,)
assert t.dtype == hurray.float64

Return a 2-D tensor with ones on the k-th diagonal and zeros elsewhere.

Default dtype is float64. Strict mode only.

Examples

import hurray

t = hurray.eye(3)
assert t.shape == (3, 3)
assert t.dtype == hurray.float64

Convert an object to a hurray.Tensor.

Input types handled:

• hurray.Tensor — returned as-is (or copied if copy=True).
• NumPy arrays — wrapped zero-copy via from_numpy.
• Objects with __dlpack__ — wrapped zero-copy via DLPack.
• Python lists, tuples, scalars — converted via numpy.asarray first.

Errors

• hurray.UnsupportedError — copy=False and a copy would be required.
• hurray.UnsupportedError — bfloat16 dtype requested (NumPy does not support bfloat16 natively; use from_numpy on a pre-converted array).

Examples

import numpy as np, hurray

t = hurray.asarray([1.0, 2.0, 3.0])
assert t.shape == (3,)
assert t.dtype == hurray.float64