dtypes

DType dataclass

DType(
    priority: int,
    bitsize: int,
    name: str,
    fmt: FmtStr | None,
)

dtypes

Methods:

• is_float –
• is_int –
• is_unsigned –
• is_bool –
• from_py –
• finfo –

  (exponent, mantissa)

Attributes:

• void (Final[DType]) –
• weakint (Final[DType]) –
• index (Final[DType]) –
• bool (Final[DType]) –
• int8 (Final[DType]) –
• uint8 (Final[DType]) –
• int16 (Final[DType]) –
• uint16 (Final[DType]) –
• int32 (Final[DType]) –
• uint32 (Final[DType]) –
• int64 (Final[DType]) –
• uint64 (Final[DType]) –
• _uint128 (Final[DType]) –
• _uint256 (Final[DType]) –
• weakfloat (Final[DType]) –
• fp8e4m3 (Final[DType]) –
• fp8e5m2 (Final[DType]) –
• fp8e4m3fnuz (Final[DType]) –
• fp8e5m2fnuz (Final[DType]) –
• float16 (Final[DType]) –
• bfloat16 (Final[DType]) –
• float32 (Final[DType]) –
• float64 (Final[DType]) –
• half –
• float –
• double –
• uchar –
• ushort –
• uint –
• ulong –
• char –
• short –
• int –
• long –
• default_float (DType) –
• default_int (DType) –
• fp8_ocp –
• fp8_fnuz –
• fp8s –
• floats –
• int8s –
• int16s –
• int32s –
• int64s –
• uints –
• sints –
• ints –
• weaks –
• all –

void

void: Final[DType] = DType.new(-1, 0, 'void', None)

weakint

weakint: Final[DType] = DType.new(0, 800, 'weakint', None)

index

index: Final[DType] = DType.new(0, 800, 'index', None)

bool

bool: Final[DType] = DType.new(0, 1, 'bool', '?')

int8

int8: Final[DType] = DType.new(1, 8, 'signed char', 'b')

uint8

uint8: Final[DType] = DType.new(2, 8, 'unsigned char', 'B')

int16

int16: Final[DType] = DType.new(3, 16, 'short', 'h')

uint16

uint16: Final[DType] = DType.new(
    4, 16, "unsigned short", "H"
)

int32

int32: Final[DType] = DType.new(5, 32, 'int', 'i')

uint32

uint32: Final[DType] = DType.new(6, 32, "unsigned int", "I")

int64

int64: Final[DType] = DType.new(7, 64, 'long', 'q')

uint64

uint64: Final[DType] = DType.new(
    8, 64, "unsigned long", "Q"
)

_uint128

_uint128: Final[DType] = DType.new(8, 128, 'uint128', None)

_uint256

_uint256: Final[DType] = DType.new(8, 256, 'uint256', None)

weakfloat

weakfloat: Final[DType] = DType.new(
    9, 800, "weakfloat", None
)

fp8e4m3

fp8e4m3: Final[DType] = DType.new(
    10, 8, "float8_e4m3", None
)

fp8e5m2

fp8e5m2: Final[DType] = DType.new(
    11, 8, "float8_e5m2", None
)

fp8e4m3fnuz

fp8e4m3fnuz: Final[DType] = DType.new(
    10, 8, "float8_e4m3fnuz", None
)

fp8e5m2fnuz

fp8e5m2fnuz: Final[DType] = DType.new(
    11, 8, "float8_e5m2fnuz", None
)

float16

float16: Final[DType] = DType.new(12, 16, 'half', 'e')

bfloat16

bfloat16: Final[DType] = DType.new(13, 16, '__bf16', None)

float32

float32: Final[DType] = DType.new(14, 32, 'float', 'f')

float64

float64: Final[DType] = DType.new(15, 64, 'double', 'd')

half

half = float16

float

float = float32

double

double = float64

uchar

uchar = uint8

ushort

ushort = uint16

uint

uint = uint32

ulong

ulong = uint64

char

char = int8

short

short = int16

int

int = int32

long

long = int64

default_float

default_float: DType = float32

default_int

default_int: DType = int32

fp8_ocp

fp8_ocp = (fp8e4m3, fp8e5m2)

fp8_fnuz

fp8_fnuz = (fp8e4m3fnuz, fp8e5m2fnuz)

fp8s

fp8s = fp8_ocp + fp8_fnuz

floats

floats = fp8s + (float16, bfloat16, float32, float64)

int8s

int8s = (uint8, int8)

int16s

int16s = (uint16, int16)

int32s

int32s = (uint32, int32)

int64s

int64s = (uint64, int64)

uints

uints = (uint8, uint16, uint32, uint64)

sints

sints = (int8, int16, int32, int64)

ints

ints = uints + sints

weaks

weaks = (weakint, weakfloat)

all

all = floats + ints + (bool,)

is_float

is_float(x: DType) -> bool

Source code in tinygrad/dtype.py

@staticmethod
@functools.cache
def is_float(x: DType) -> bool: return x in (dtypes.floats + (dtypes.weakfloat,))

is_int

is_int(x: DType) -> bool

Source code in tinygrad/dtype.py

@staticmethod # static methods on top, or bool in the type info will refer to dtypes.bool
@functools.cache
def is_int(x: DType) -> bool: return x in (dtypes.ints + (dtypes.weakint, dtypes.index))

is_unsigned

is_unsigned(x: DType) -> bool

Source code in tinygrad/dtype.py

@staticmethod
@functools.cache
def is_unsigned(x: DType) -> bool: return x in dtypes.uints

is_bool

is_bool(x: DType) -> bool

Source code in tinygrad/dtype.py

@staticmethod
def is_bool(x: DType) -> bool: return x == dtypes.bool

from_py

from_py(x) -> DType

Source code in tinygrad/dtype.py

@staticmethod
def from_py(x) -> DType:
  # NOTE: isinstance(True, int) is True, so bool must be checked before int
  if isinstance(x, (bool, InvalidType)): return dtypes.bool
  if isinstance(x, float): return dtypes.default_float
  if isinstance(x, int): return dtypes.default_int
  # put this in the last is faster because there are more items than lists/tuples to check
  if isinstance(x, (list, tuple)): return max(dtypes.from_py(xi) for xi in x) if x else dtypes.default_float
  raise RuntimeError(f"Could not infer dtype of {x} with type {type(x)}")

finfo

finfo(dtype: DType) -> tuple[int, int]

(exponent, mantissa)

Source code in tinygrad/dtype.py

@staticmethod
def finfo(dtype:DType) -> tuple[int, int]:
  """(exponent, mantissa)"""
  if not dtypes.is_float(dtype): raise ValueError(f"{dtype} is not a floating point type")
  return {dtypes.float16: (5, 10), dtypes.bfloat16: (8, 7), dtypes.float32: (8, 23), dtypes.float64: (11, 52),
          dtypes.fp8e4m3: (4, 3), dtypes.fp8e5m2: (5, 2), dtypes.fp8e4m3fnuz: (4, 3), dtypes.fp8e5m2fnuz: (5, 2)}[dtype]

ConstType module-attribute

ConstType = PyConst | InvalidType