Mojo struct

DType

@register_passable(trivial) struct DType

Represents a data type specification and provides methods for working with it.

DType defines a set of compile-time constant that specify the precise numeric representation of data in order to prevent runtime errors by catching type mismatches at compile time. It directly maps to CPU/GPU instruction sets, allowing the compiler to generate optimal SIMD and vector operations.

DType behaves like an enum rather than a typical object. You don't instantiate it, but instead use its compile-time constants (aliases) to declare data types for SIMD vectors, tensors, and other data structures.

Key usage patterns:

Type specification: Use aliases like DType.float32 to specify types for SIMD vectors, tensors, and other data structures
Type parameters: Pass DType values as compile-time parameters to parameterized types like SIMD[dtype, size]
Type introspection: Call methods like .bit_width(), .is_floating_point() to query type properties at compile time
Type conversion: Use in casting operations to convert between different numeric representations

Note: Not all data types are supported on all platforms. For example, DType.bfloat16 is currently not supported on Apple Silicon.

Example:

var data = SIMD[DType.float16, 4](1.5, 2.5, 3.5, 4.5)
var dtype = data.dtype

print("Is float:", dtype.is_floating_point())  # True
print("Bit width:", dtype.bit_width())          # 16
print("Is signed:", dtype.is_signed())         # True

Implemented traits

AnyType, Copyable, EqualityComparable, Hashable, Identifiable, ImplicitlyCopyable, Movable, Representable, Stringable, UnknownDestructibility, Writable

Aliases

`copyinitis_trivial`

alias __copyinit__is_trivial = True

`delis_trivial`

alias __del__is_trivial = True

`moveinitis_trivial`

alias __moveinit__is_trivial = True

`bfloat16`

alias bfloat16 = DType.bfloat16

Represents a brain floating point value whose bitwidth is 16.

`bool`

alias bool = DType.bool

Represents a boolean data type.

`float16`

alias float16 = DType.float16

Represents an IEEE754-2008 binary16 floating point value.

`float32`

alias float32 = DType.float32

Represents an IEEE754-2008 binary32 floating point value.

`float64`

alias float64 = DType.float64

Represents an IEEE754-2008 binary64 floating point value.

`float8_e3m4`

alias float8_e3m4 = DType.float8_e3m4

Represents an 8-bit e3m4 floating point format, encoded as s.eee.mmmm:

(s)ign: 1 bit
(e)xponent: 3 bits
(m)antissa: 4 bits
exponent bias: 3
nan: {0,1}.111.1111
fn: finite (no inf or -inf encodings)
-0: 1.000.0000

`float8_e4m3fn`

alias float8_e4m3fn = DType.float8_e4m3fn

Represents the 8-bit E4M3 floating point format defined in the OFP8 standard.

This type is named differently across libraries and vendors, for example:

Mojo, PyTorch, JAX, and LLVM refer to it as e4m3fn.
OCP, NVIDIA CUDA, and AMD ROCm refer to it as e4m3.

In these contexts, they are all referring to the same finite type specified in the OFP8 standard above, encoded as s.eeee.mmm:

(s)ign: 1 bit
(e)xponent: 4 bits
(m)antissa: 3 bits
exponent bias: 7
nan: {0,1}.1111.111
fn: finite (no inf or -inf encodings)
-0: 1.0000.000

`float8_e4m3fnuz`

alias float8_e4m3fnuz = DType.float8_e4m3fnuz

Represents an 8-bit e4m3fnuz floating point format (ref), encoded as s.eeee.mmm:

(s)ign: 1 bit
(e)xponent: 4 bits
(m)antissa: 3 bits
exponent bias: 8
nan: 1.0000.000
fn: finite (no inf or -inf encodings)
uz: unsigned zero (no -0 encoding)

`float8_e5m2`

alias float8_e5m2 = DType.float8_e5m2

Represents the 8-bit E5M2 floating point format defined in the OFP8 standard, encoded as s.eeeee.mm:

(s)ign: 1 bit
(e)xponent: 5 bits
(m)antissa: 2 bits
exponent bias: 15
nan: {0,1}.11111.{01,10,11}
inf: {0,1}.11111.00
-0: 1.00000.00

`float8_e5m2fnuz`

alias float8_e5m2fnuz = DType.float8_e5m2fnuz

Represents an 8-bit e5m2fnuz floating point format (ref), encoded as s.eeeee.mm:

(s)ign: 1 bit
(e)xponent: 5 bits
(m)antissa: 2 bits
exponent bias: 16
nan: 1.00000.00
fn: finite (no inf or -inf encodings)
uz: unsigned zero (no -0 encoding)

`index`

alias index = DType.index

Represents an integral type whose bitwidth is the maximum integral value on the system.

`int128`

alias int128 = DType.int128

Represents a signed integer type whose bitwidth is 128.

`int16`

alias int16 = DType.int16

Represents a signed integer type whose bitwidth is 16.

`int256`

alias int256 = DType.int256

Represents a signed integer type whose bitwidth is 256.

`int32`

alias int32 = DType.int32

Represents a signed integer type whose bitwidth is 32.

`int64`

alias int64 = DType.int64

Represents a signed integer type whose bitwidth is 64.

`int8`

alias int8 = DType.int8

Represents a signed integer type whose bitwidth is 8.

`invalid`

alias invalid = DType.invalid

Represents an invalid or unknown data type.

`uint128`

alias uint128 = DType.uint128

Represents an unsigned integer type whose bitwidth is 128.

`uint16`

alias uint16 = DType.uint16

Represents an unsigned integer type whose bitwidth is 16.

`uint256`

alias uint256 = DType.uint256

Represents an unsigned integer type whose bitwidth is 256.

`uint32`

alias uint32 = DType.uint32

Represents an unsigned integer type whose bitwidth is 32.

`uint64`

alias uint64 = DType.uint64

Represents an unsigned integer type whose bitwidth is 64.

`uint8`

alias uint8 = DType.uint8

Represents an unsigned integer type whose bitwidth is 8.

Methods

`init`

__init__(*, mlir_value: dtype) -> Self

Construct a DType from MLIR dtype.

Args:

mlir_value (dtype): The MLIR dtype.

`eq`

__eq__(self, rhs: Self) -> Bool

Compares one DType to another for equality.

Args:

rhs (Self): The DType to compare against.

Returns:

Bool: True if the DTypes are the same and False otherwise.

`ne`

__ne__(self, rhs: Self) -> Bool

Compares one DType to another for inequality.

Args:

rhs (Self): The DType to compare against.

Returns:

Bool: False if the DTypes are the same and True otherwise.

`is`

__is__(self, rhs: Self) -> Bool

Compares one DType to another for equality.

Args:

rhs (Self): The DType to compare against.

Returns:

Bool: True if the DTypes are the same and False otherwise.

`str`

__str__(self) -> String

Gets the name of the DType.

Returns:

String: The name of the dtype.

`write_to`

write_to(self, mut writer: T)

Formats this dtype to the provided Writer.

Args:

writer (T): The object to write to.

`repr`

__repr__(self) -> String

Gets the representation of the DType e.g. "DType.float32".

Returns:

String: The representation of the dtype.

`get_value`

get_value(self) -> dtype

Gets the associated internal kgen.dtype value.

Returns:

dtype: The kgen.dtype value.

`hash`

__hash__[H: Hasher](self, mut hasher: H)

Updates hasher with this DType value.

Parameters:

H (Hasher): The hasher type.

Args:

hasher (H): The hasher instance.

`is_unsigned`

is_unsigned(self) -> Bool

Returns True if the type parameter is unsigned and False otherwise.

Returns:

Bool: Returns True if the input type parameter is unsigned.

`is_signed`

is_signed(self) -> Bool

Returns True if the type parameter is signed and False otherwise.

Returns:

Bool: Returns True if the input type parameter is signed.

`is_integral`

is_integral(self) -> Bool

Returns True if the type parameter is an integer and False otherwise.

Returns:

Bool: Returns True if the input type parameter is an integer.

`is_floating_point`

is_floating_point(self) -> Bool

Returns True if the type parameter is a floating-point and False otherwise.

Returns:

Bool: Returns True if the input type parameter is a floating-point.

`is_float8`

is_float8(self) -> Bool

Returns True if the dtype is a 8bit-precision floating point type, e.g. float8_e5m2, float8_e5m2fnuz, float8_e4m3fn and float8_e4m3fnuz.

Returns:

Bool: True if the dtype is a 8bit-precision float, false otherwise.

`is_half_float`

is_half_float(self) -> Bool

Returns True if the dtype is a half-precision floating point type, e.g. either fp16 or bf16.

Returns:

Bool: True if the dtype is a half-precision float, false otherwise..

`is_numeric`

is_numeric(self) -> Bool

Returns True if the type parameter is numeric (i.e. you can perform arithmetic operations on).

Returns:

Bool: Returns True if the input type parameter is either integral or floating-point.

`size_of`

size_of(self) -> Int

Returns the size in bytes of the current DType.

Returns:

Int: Returns the size in bytes of the current DType.

`bit_width`

bit_width(self) -> Int

Returns the size in bits of the current DType.

Returns:

Int: Returns the size in bits of the current DType.

`mantissa_width`

static mantissa_width[dtype: Self]() -> Int

Returns the mantissa width of a floating point type.

Parameters:

dtype (Self): The DType.

Returns:

Int: The mantissa width.

`max_exponent`

static max_exponent[dtype: Self]() -> Int

Returns the max exponent of a floating point dtype without accounting for inf representations. This is not the maximum representable exponent, which is generally equal to the exponent_bias.

Parameters:

dtype (Self): The DType.

Returns:

Int: The max exponent.

`exponent_width`

static exponent_width[dtype: Self]() -> Int

Returns the exponent width of a floating point type.

Parameters:

dtype (Self): The DType.

Returns:

Int: The exponent width.

`exponent_bias`

static exponent_bias[dtype: Self]() -> Int

Returns the exponent bias of a floating point type.

Parameters:

dtype (Self): The DType.

Returns:

Int: The exponent bias.

`dispatch_integral`

dispatch_integral[func: fn[DType]() capturing -> None](self)

Dispatches an integral function corresponding to the current DType.

Constraints:

DType must be integral.

Parameters:

func (fn[DType]() capturing -> None): A parametrized on dtype function to dispatch.

`dispatch_floating`

dispatch_floating[func: fn[DType]() capturing -> None](self)

Dispatches a floating-point function corresponding to the current DType.

Constraints:

DType must be floating-point or integral.

Parameters:

func (fn[DType]() capturing -> None): A parametrized on dtype function to dispatch.

`dispatch_arithmetic`

dispatch_arithmetic[func: fn[DType]() capturing -> None](self)

Dispatches a function corresponding to the current DType.

Parameters:

func (fn[DType]() capturing -> None): A parametrized on dtype function to dispatch.

`__mlir_type`

__mlir_type(self) -> !kgen.deferred

Returns the MLIR type of the current DType as an MLIR type.

Returns:

!kgen.deferred: The MLIR type of the current DType.

`get_dtype`

static get_dtype[T: AnyType, size: Int = 1]() -> Self

Get the DType if the given Type is a SIMD[_, size] of a DType.

Parameters:

T (AnyType): AnyType.
size (Int): The SIMD size to compare against.

Returns:

Self: The DType if matched, otherwise DType.invalid.

`is_scalar`

static is_scalar[T: AnyType]() -> Bool

Whether the given Type is a Scalar of a DType.

Parameters:

T (AnyType): AnyType.

Returns:

Bool: The result.

View source

Was this page helpful?

Thank you! We'll create more content like this.

Thank you for helping us improve!

Implemented traits​

Aliases​

__copyinit__is_trivial​

__del__is_trivial​

__moveinit__is_trivial​

bfloat16​

bool​

float16​

float32​

float64​

float8_e3m4​

float8_e4m3fn​

float8_e4m3fnuz​

float8_e5m2​

float8_e5m2fnuz​

index​

int128​

int16​

int256​

int32​

int64​

int8​

invalid​

uint128​

uint16​

uint256​

uint32​

uint64​

uint8​

Methods​

__init__​

__eq__​

__ne__​

__is__​

__str__​

write_to​

__repr__​

get_value​

__hash__​

is_unsigned​

is_signed​

is_integral​

is_floating_point​

is_float8​

is_half_float​

is_numeric​

size_of​

bit_width​

mantissa_width​

max_exponent​

exponent_width​

exponent_bias​

dispatch_integral​

dispatch_floating​

dispatch_arithmetic​

__mlir_type​

get_dtype​

is_scalar​

Implemented traits

Aliases

`copyinitis_trivial`

`delis_trivial`

`moveinitis_trivial`

`bfloat16`

`bool`

`float16`

`float32`

`float64`

`float8_e3m4`

`float8_e4m3fn`

`float8_e4m3fnuz`

`float8_e5m2`

`float8_e5m2fnuz`

`index`

`int128`

`int16`

`int256`

`int32`

`int64`

`int8`

`invalid`

`uint128`

`uint16`

`uint256`

`uint32`

`uint64`

`uint8`

Methods

`init`

`eq`

`ne`

`is`

`str`

`write_to`

`repr`

`get_value`

`hash`

`is_unsigned`

`is_signed`

`is_integral`

`is_floating_point`

`is_float8`

`is_half_float`

`is_numeric`

`size_of`

`bit_width`

`mantissa_width`

`max_exponent`

`exponent_width`

`exponent_bias`

`dispatch_integral`

`dispatch_floating`

`dispatch_arithmetic`

`__mlir_type`

`get_dtype`

`is_scalar`