Skip to content

dtypes

DType dataclass ¤

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

dtypes ¤

Methods:

Attributes:

void ¤

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

index ¤

index: Final[DType] = new(-1, 800, 'index', None)

bool ¤

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

int8 ¤

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

uint8 ¤

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

int16 ¤

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

uint16 ¤

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

int32 ¤

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

uint32 ¤

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

int64 ¤

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

uint64 ¤

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

_uint128 ¤

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

_uint256 ¤

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

fp8e4m3 ¤

fp8e4m3: Final[DType] = new(9, 8, 'float8_e4m3', None)

fp8e5m2 ¤

fp8e5m2: Final[DType] = new(10, 8, 'float8_e5m2', None)

float16 ¤

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

bfloat16 ¤

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

float32 ¤

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

float64 ¤

float64: Final[DType] = new(14, 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

fp8s ¤

fp8s = (fp8e4m3, fp8e5m2)

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

all ¤

all = floats + ints + (bool, index)

is_float ¤

is_float(x: DType) -> bool
Source code in tinygrad/dtype.py 
144
145
146
@staticmethod
@functools.cache
def is_float(x: DType) -> bool: return x.scalar() in dtypes.floats or isinstance(x, ImageDType)

is_int ¤

is_int(x: DType) -> bool
Source code in tinygrad/dtype.py 
147
148
149
@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.scalar() in (dtypes.ints + (dtypes.index,))

is_unsigned ¤

is_unsigned(x: DType) -> bool
Source code in tinygrad/dtype.py 
150
151
152
@staticmethod
@functools.cache
def is_unsigned(x: DType) -> bool: return x.scalar() in dtypes.uints

is_bool ¤

is_bool(x: DType) -> bool
Source code in tinygrad/dtype.py 
153
154
@staticmethod
def is_bool(x: DType) -> bool: return x.scalar() == dtypes.bool

from_py ¤

from_py(x) -> DType
Source code in tinygrad/dtype.py 
155
156
157
158
159
160
161
162
@staticmethod
def from_py(x) -> DType:
  if x.__class__ is float: return dtypes.default_float
  if x.__class__ is int: return dtypes.default_int
  if x.__class__ is bool: return dtypes.bool
  # put this in the last is faster because there are more items than lists/tuples to check
  if x.__class__ is list or x.__class__ is 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)}")

as_const ¤

as_const(
    val: tuple[ConstType, ...] | ConstType, dtype: DType
)
Source code in tinygrad/dtype.py 
163
164
165
166
167
168
169
170
171
172
@staticmethod
def as_const(val: tuple[ConstType, ...]|ConstType, dtype:DType):
  if isinstance(val, tuple):
    assert len(val) == dtype.count, f"mismatch {val} {dtype}"
    return tuple(dtypes.as_const(x, dtype) for x in val)
  if isinstance(val, InvalidType): return val
  # NOTE: float('nan') != float('nan'), so we canonicalize here
  if isinstance(val, float) and math.isnan(val): val = math.nan
  # int is the default. wrap floats in ConstFloat to distinguish -0.0 from 0.0 in cache
  return ConstFloat(float(val)) if dtypes.is_float(dtype) else bool(val) if dtypes.is_bool(dtype) else int(val)

min ¤

min(dtype: DType)
Source code in tinygrad/dtype.py 
173
174
175
176
177
@staticmethod
@functools.cache
def min(dtype:DType):
  if dtypes.is_int(dtype): return 0 if dtypes.is_unsigned(dtype) else -2**(dtype.scalar().bitsize-1)
  return -float("inf") if dtypes.is_float(dtype) else False

max ¤

max(dtype: DType)
Source code in tinygrad/dtype.py 
178
179
180
181
182
@staticmethod
@functools.cache
def max(dtype:DType):
  if dtypes.is_int(dtype): return 2**(dtype.scalar().bitsize)-1+dtypes.min(dtype)
  return float("inf") if dtypes.is_float(dtype) else True

finfo ¤

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

(exponent, mantissa)

Source code in tinygrad/dtype.py 
183
184
185
186
187
188
@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.fp8e5m2: (5, 2), dtypes.fp8e4m3: (4, 3)}[dtype]

imageh ¤

imageh(shp, pitch=-1)
Source code in tinygrad/dtype.py 
216
217
@staticmethod
def imageh(shp, pitch=-1): return ImageDType(100, 16, "imageh", 'e', 1, None, dtypes.float32, AddrSpace.GLOBAL, 1, prod(shp), shp, pitch)

imagef ¤

imagef(shp, pitch=-1)
Source code in tinygrad/dtype.py 
218
219
@staticmethod
def imagef(shp, pitch=-1): return ImageDType(100, 32, "imagef", 'f', 1, None, dtypes.float32, AddrSpace.GLOBAL, 1, prod(shp), shp, pitch)

ConstType module-attribute ¤

ConstType = PyConst | InvalidType