Enum DType 

#[non_exhaustive]
pub enum DType {
    Bool,
    U8,
    U16,
    U32,
    U64,
    U128,
    I8,
    I16,
    I32,
    I64,
    I128,
    I256,
    F32,
    F64,
    Complex32,
    Complex64,
    DateTime64(TimeUnit),
    Timedelta64(TimeUnit),
    Struct(&'static [FieldDescriptor]),
    FixedAscii(usize),
    FixedUnicode(usize),
    RawBytes(usize),
}

Runtime descriptor for the element type stored in an array.

Mirrors the set of types implementing Element.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Bool

bool

U8

u8

U16

u16

U32

u32

U64

u64

U128

u128

I8

i8

I16

i16

I32

i32

I64

i64

I128

i128

I256

I256 — 256-bit two’s-complement signed integer. Used as the promoted type for mixed u128 + i128 arithmetic (no native Rust type can hold that union losslessly).

F32

f32

F64

f64

Complex32

Complex<f32>

Complex64

Complex<f64>

DateTime64(TimeUnit)

datetime64[unit] — calendar instant as i64 ticks since the Unix epoch, with the TimeUnit tagging the meaning of one tick. Backed by the DateTime64 element type.

Timedelta64(TimeUnit)

timedelta64[unit] — duration as i64 ticks. Backed by the Timedelta64 element type.

Struct(&'static [FieldDescriptor])

Structured (record) dtype holding a static descriptor for each field (#342). Mirrors numpy’s structured dtype:

np.dtype([('x', 'f4'), ('y', 'f4')])

The slice is &'static so that DType stays Copy. The FerrayRecord derive macro emits exactly this shape via Type::field_descriptors() -> &'static [FieldDescriptor], so the typical construction site is:

let dt = DType::Struct(<Point as FerrayRecord>::field_descriptors());

Dynamically-constructed descriptors must be leaked into a &'static [FieldDescriptor] (e.g. via Box::leak); ferray-core does not allocate field descriptors at runtime.

FixedAscii(usize)

Fixed-width ASCII string with n bytes per element. Mirrors numpy’s 'S{n}' dtype family. Backed by [u8; n] rows in a flat byte buffer; trailing zeros pad short strings (#741).

FixedUnicode(usize)

Fixed-width Unicode string with n codepoints per element stored as UCS-4 (4 * n bytes per element). Mirrors numpy’s 'U{n}' dtype family (#741).

RawBytes(usize)

Fixed-width raw byte / void dtype with n bytes per element. Mirrors numpy’s 'V{n}' dtype family — opaque fixed-size byte payloads with no UTF-8 / ASCII assumption (#741).

Implementations

impl DType

pub fn size_of(self) -> usize

Size in bytes of one element of this dtype.

Note: lost const-ness when Self::Struct was added (#342) — computing struct size requires iterating field descriptors, which stable const fn doesn’t support yet.

pub fn alignment(self) -> usize

Required alignment in bytes for this dtype.

Note: lost const-ness with Self::Struct (#342) — struct alignment is the max of field alignments, which requires iterating field descriptors.

pub const fn is_float(self) -> bool

true if the dtype is a floating-point type (f16, bf16, f32, f64).

pub const fn is_integer(self) -> bool

true if the dtype is an integer type (signed or unsigned, including bool).

pub const fn is_complex(self) -> bool

true if the dtype is a complex type.

pub const fn is_signed(self) -> bool

true if the dtype is a signed numeric type.

Trait Implementations

impl Clone for DType

fn clone(&self) -> DType

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DType

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Display for DType

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Hash for DType

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for DType

fn eq(&self, other: &DType) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for DType

impl Eq for DType

impl StructuralPartialEq for DType