Enum DType 

pub enum DType {
    Bool,
    Int8,
    Int16,
    Int32,
    Int64,
    Uint8,
    Uint16,
    Uint32,
    Uint64,
    Fp16,
    Fp32,
    Fp64,
    Bf16,
    Others,
}

Enumeration of all supported data types for tensor elements.

This enum represents the various numeric types that can be stored in tensors, including integers, floating-point numbers, and boolean values. Each variant corresponds to a specific Rust primitive type or half-precision type.

Examples

use slsl::DType;

let dtype = DType::Fp32;
assert_eq!(dtype.size_in_bytes(), 4);
assert!(dtype.is_float());

let int_dtype = DType::Int32;
assert_eq!(int_dtype.size_in_bytes(), 4);
assert!(!int_dtype.is_float());

Variants

Bool

Boolean type (bool)

Int8

8-bit signed integer (i8)

Int16

16-bit signed integer (i16)

Int32

32-bit signed integer (i32)

Int64

64-bit signed integer (i64)

Uint8

8-bit unsigned integer (u8)

Uint16

16-bit unsigned integer (u16)

Uint32

32-bit unsigned integer (u32)

Uint64

64-bit unsigned integer (u64)

Fp16

16-bit floating-point number (half-precision)

Fp32

32-bit floating-point number (single-precision)

Fp64

64-bit floating-point number (double-precision)

Bf16

16-bit brain floating-point number

Others

Placeholder variant - should not be used in practice, use _

Implementations

impl DType

pub fn size_in_bytes(self) -> usize

Returns the size in bytes of this data type.

This method returns the memory footprint of a single element of this data type, which is useful for memory allocation and layout calculations.

Returns

The size in bytes as a usize.

Panics

Panics if called on DType::Others, as this is a placeholder variant and does not correspond to a concrete type.

Examples

use slsl::DType;

assert_eq!(DType::Bool.size_in_bytes(), 1);
assert_eq!(DType::Int32.size_in_bytes(), 4);
assert_eq!(DType::Fp64.size_in_bytes(), 8);
assert_eq!(DType::Fp16.size_in_bytes(), 2);

pub fn is_float(self) -> bool

Checks if this data type represents a floating-point number.

Returns true for all floating-point variants (including half-precision and brain floating-point types), and false for integer and boolean types.

Returns

true if the data type is floating-point, false otherwise.

Examples

use slsl::DType;

// Floating-point types
assert!(DType::Fp16.is_float());
assert!(DType::Fp32.is_float());
assert!(DType::Fp64.is_float());
assert!(DType::Bf16.is_float());

// Non-floating-point types
assert!(!DType::Int32.is_float());
assert!(!DType::Bool.is_float());
assert!(!DType::Uint8.is_float());

pub fn is_integer(self) -> bool

Checks if this data type represents an integer number.

Returns true for all signed and unsigned integer variants, and false for floating-point and boolean types.

Returns

true if the data type is an integer, false otherwise.

Examples

use slsl::DType;

// Integer types
assert!(DType::Int8.is_integer());
assert!(DType::Int32.is_integer());
assert!(DType::Uint16.is_integer());
assert!(DType::Uint64.is_integer());

// Non-integer types
assert!(!DType::Fp32.is_integer());
assert!(!DType::Bool.is_integer());

pub fn is_signed_integer(self) -> bool

Checks if this data type represents a signed integer.

Returns true only for signed integer variants.

Returns

true if the data type is a signed integer, false otherwise.

Examples

use slsl::DType;

// Signed integer types
assert!(DType::Int8.is_signed_integer());
assert!(DType::Int32.is_signed_integer());
assert!(DType::Int64.is_signed_integer());

// Non-signed integer types
assert!(!DType::Uint32.is_signed_integer());
assert!(!DType::Fp32.is_signed_integer());
assert!(!DType::Bool.is_signed_integer());

pub fn is_unsigned_integer(self) -> bool

Checks if this data type represents an unsigned integer.

Returns true only for unsigned integer variants.

Returns

true if the data type is an unsigned integer, false otherwise.

Examples

use slsl::DType;

// Unsigned integer types
assert!(DType::Uint8.is_unsigned_integer());
assert!(DType::Uint32.is_unsigned_integer());
assert!(DType::Uint64.is_unsigned_integer());

// Non-unsigned integer types
assert!(!DType::Int32.is_unsigned_integer());
assert!(!DType::Fp32.is_unsigned_integer());
assert!(!DType::Bool.is_unsigned_integer());

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

Formats the value using the given formatter.

impl Ord for DType

fn cmp(&self, other: &DType) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

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 PartialOrd for DType

fn partial_cmp(&self, other: &DType) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for DType

impl Eq for DType

impl StructuralPartialEq for DType