Elementwise

Elementwise ops operate on a per element basis. They don't change the shape of the tensor.

Unary Ops (math)

logical_not

logical_not() -> Self

Computes the logical NOT of the tensor element-wise.

print(Tensor([False, True]).logical_not().numpy())

[ True False]

Source code in tinygrad/mixin/elementwise.py

def logical_not(self) -> Self:
  """
  Computes the logical NOT of the tensor element-wise.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([False, True]).logical_not().numpy())
  ```
  """
  return self.cast(dtypes.bool).ne(True)

neg

neg() -> Self

Negates the tensor element-wise.

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).neg().numpy())

[ 3.  2.  1. -0. -1. -2. -3.]

Source code in tinygrad/mixin/elementwise.py

def neg(self) -> Self:
  """
  Negates the tensor element-wise.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).neg().numpy())
  ```
  """
  return self.logical_not() if self.dtype == dtypes.bool else self * (-1)

log

log() -> Self

Computes the natural logarithm element-wise.

See: https://en.wikipedia.org/wiki/Logarithm

print(Tensor([1., 2., 4., 8.]).log().numpy())

[0.     0.6931 1.3863 2.0794]

Source code in tinygrad/mixin/elementwise.py

def log(self) -> Self:
  """
  Computes the natural logarithm element-wise.

  See: https://en.wikipedia.org/wiki/Logarithm

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([1., 2., 4., 8.]).log().numpy())
  ```
  """
  return self.log2()*math.log(2)

log2

log2() -> Self

Computes the base-2 logarithm element-wise.

See: https://en.wikipedia.org/wiki/Logarithm

print(Tensor([1., 2., 4., 8.]).log2().numpy())

[0. 1. 2. 3.]

Source code in tinygrad/mixin/elementwise.py

def log2(self) -> Self:
  """
  Computes the base-2 logarithm element-wise.

  See: https://en.wikipedia.org/wiki/Logarithm

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([1., 2., 4., 8.]).log2().numpy())
  ```
  """
  return self.alu(Ops.LOG2)

log10

log10() -> Self

Computes the base-10 logarithm element-wise.

See: https://en.wikipedia.org/wiki/Logarithm

print(Tensor([1., 2., 4., 8.]).log10().numpy())

[0.     0.301  0.6021 0.9031]

Source code in tinygrad/mixin/elementwise.py

def log10(self) -> Self:
  """
  Computes the base-10 logarithm element-wise.

  See: https://en.wikipedia.org/wiki/Logarithm

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([1., 2., 4., 8.]).log10().numpy())
  ```
  """
  return self.log2()*math.log10(2)

exp

exp() -> Self

Computes the exponential function element-wise.

See: https://en.wikipedia.org/wiki/Exponential_function

print(Tensor([0., 1., 2., 3.]).exp().numpy())

[ 1.      2.7183  7.3891 20.0855]

Source code in tinygrad/mixin/elementwise.py

def exp(self) -> Self:
  """
  Computes the exponential function element-wise.

  See: https://en.wikipedia.org/wiki/Exponential_function

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([0., 1., 2., 3.]).exp().numpy())
  ```
  """
  self = self.cast(least_upper_float(self.dtype))
  return self.cast(least_upper_dtype(self.dtype, dtypes.float32)).mul(1/math.log(2)).exp2().cast(self.dtype)

exp2

exp2() -> Self

Computes the base-2 exponential function element-wise.

See: https://en.wikipedia.org/wiki/Exponential_function

print(Tensor([0., 1., 2., 3.]).exp2().numpy())

[1. 2. 4. 8.]

Source code in tinygrad/mixin/elementwise.py

def exp2(self) -> Self:
  """
  Computes the base-2 exponential function element-wise.

  See: https://en.wikipedia.org/wiki/Exponential_function

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([0., 1., 2., 3.]).exp2().numpy())
  ```
  """
  return self.alu(Ops.EXP2)

sqrt

sqrt() -> Self

Computes the square root of the tensor element-wise.

print(Tensor([1., 2., 3., 4.]).sqrt().numpy())

[1.     1.4142 1.7321 2.    ]

Source code in tinygrad/mixin/elementwise.py

def sqrt(self) -> Self:
  """
  Computes the square root of the tensor element-wise.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([1., 2., 3., 4.]).sqrt().numpy())
  ```
  """
  return self.alu(Ops.SQRT)

rsqrt

rsqrt() -> Self

Computes the reciprocal of the square root of the tensor element-wise.

print(Tensor([1., 2., 3., 4.]).rsqrt().numpy())

[1.     0.7071 0.5774 0.5   ]

Source code in tinygrad/mixin/elementwise.py

def rsqrt(self) -> Self:
  """
  Computes the reciprocal of the square root of the tensor element-wise.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([1., 2., 3., 4.]).rsqrt().numpy())
  ```
  """
  return self.sqrt().reciprocal()

sin

sin() -> Self

Computes the sine of the tensor element-wise.

print(Tensor([0., math.pi/2, math.pi, 3*math.pi/2, 2*math.pi]).sin().numpy())

[ 0.  1. -0. -1.  0.]

Source code in tinygrad/mixin/elementwise.py

def sin(self) -> Self:
  """
  Computes the sine of the tensor element-wise.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([0., math.pi/2, math.pi, 3*math.pi/2, 2*math.pi]).sin().numpy())
  ```
  """
  return self.alu(Ops.SIN)

cos

cos() -> Self

Computes the cosine of the tensor element-wise.

print(Tensor([0., math.pi/2, math.pi, 3*math.pi/2, 2*math.pi]).cos().numpy())

[ 1.0000e+00  0.0000e+00 -1.0000e+00 -2.3842e-07  1.0000e+00]

Source code in tinygrad/mixin/elementwise.py

def cos(self) -> Self:
  """
  Computes the cosine of the tensor element-wise.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([0., math.pi/2, math.pi, 3*math.pi/2, 2*math.pi]).cos().numpy())
  ```
  """
  self = self.cast(least_upper_float(self.dtype))
  return ((math.pi/2)-self.cast(least_upper_dtype(self.dtype, dtypes.float32))).sin().cast(self.dtype)

tan

tan() -> Self

Computes the tangent of the tensor element-wise.

print(Tensor([0., math.pi/4, math.pi/2, 3*math.pi/4, math.pi]).tan().numpy())

[ 0.  1. inf -1.  0.]

Source code in tinygrad/mixin/elementwise.py

def tan(self) -> Self:
  """
  Computes the tangent of the tensor element-wise.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([0., math.pi/4, math.pi/2, 3*math.pi/4, math.pi]).tan().numpy())
  ```
  """
  return self.sin() / self.cos()

asin

asin() -> Self

Computes the inverse sine (arcsine) of the tensor element-wise.

print(Tensor([-0.9, -0.6, -0.3, 0., 0.3, 0.6, 0.9]).asin().numpy())

[-1.1198 -0.6435 -0.3047  0.      0.3047  0.6435  1.1198]

Source code in tinygrad/mixin/elementwise.py

def asin(self) -> Self:
  """
  Computes the inverse sine (arcsine) of the tensor element-wise.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-0.9, -0.6, -0.3, 0., 0.3, 0.6, 0.9]).asin().numpy())
  ```
  """
  # https://personal.math.ubc.ca/~cbm/aands/page_81.htm 4.4.46
  coefficients = [-0.0012624911, 0.0066700901, -0.0170881256, 0.0308918810, -0.0501743046, 0.0889789874, -0.2145988016, 1.5707963050]
  x = math.pi / 2 - (1.0 - self.abs()).sqrt() * polyN(self.abs(), coefficients)
  return self.sign() * x

acos

acos() -> Self

Computes the inverse cosine (arccosine) of the tensor element-wise.

print(Tensor([-0.9, -0.6, -0.3, 0., 0.3, 0.6, 0.9]).acos().numpy())

[2.6906 2.2143 1.8755 1.5708 1.2661 0.9273 0.451 ]

Source code in tinygrad/mixin/elementwise.py

def acos(self) -> Self:
  """
  Computes the inverse cosine (arccosine) of the tensor element-wise.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-0.9, -0.6, -0.3, 0., 0.3, 0.6, 0.9]).acos().numpy())
  ```
  """
  return math.pi / 2 - self.asin()

atan

atan() -> Self

Computes the inverse tangent (arctan) of the tensor element-wise.

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).atan().numpy())

[-1.249  -1.1071 -0.7854  0.      0.7854  1.1071  1.249 ]

Source code in tinygrad/mixin/elementwise.py

def atan(self) -> Self:
  """
  Computes the inverse tangent (arctan) of the tensor element-wise.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).atan().numpy())
  ```
  """
  return (self / (1 + self * self).sqrt()).asin()

trunc

trunc() -> Self

Truncates the tensor element-wise.

print(Tensor([-3.5, -2.5, -1.5, -0.5, 0.5, 1.5, 2.5, 3.5]).trunc().numpy())

[-3. -2. -1. -0.  0.  1.  2.  3.]

Source code in tinygrad/mixin/elementwise.py

def trunc(self) -> Self:
  """
  Truncates the tensor element-wise.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3.5, -2.5, -1.5, -0.5, 0.5, 1.5, 2.5, 3.5]).trunc().numpy())
  ```
  """
  return self.alu(Ops.TRUNC)

ceil

ceil() -> Self

Rounds the tensor element-wise towards positive infinity.

print(Tensor([-3.5, -2.5, -1.5, -0.5, 0.5, 1.5, 2.5, 3.5]).ceil().numpy())

[-3. -2. -1. -0.  1.  2.  3.  4.]

Source code in tinygrad/mixin/elementwise.py

def ceil(self) -> Self:
  """
  Rounds the tensor element-wise towards positive infinity.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3.5, -2.5, -1.5, -0.5, 0.5, 1.5, 2.5, 3.5]).ceil().numpy())
  ```
  """
  return (self > (b := self.trunc())).where(b+1, b)

floor

floor() -> Self

Rounds the tensor element-wise towards negative infinity.

print(Tensor([-3.5, -2.5, -1.5, -0.5, 0.5, 1.5, 2.5, 3.5]).floor().numpy())

[-4. -3. -2. -1.  0.  1.  2.  3.]

Source code in tinygrad/mixin/elementwise.py

def floor(self) -> Self:
  """
  Rounds the tensor element-wise towards negative infinity.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3.5, -2.5, -1.5, -0.5, 0.5, 1.5, 2.5, 3.5]).floor().numpy())
  ```
  """
  return (self < (b := self.trunc())).where(b-1, b)

round

round() -> Self

Rounds the tensor element-wise with rounding half to even.

print(Tensor([-3.5, -2.5, -1.5, -0.5, 0.5, 1.5, 2.5, 3.5]).round().numpy())

[-4. -2. -2.  0.  0.  2.  2.  4.]

Source code in tinygrad/mixin/elementwise.py

def round(self) -> Self:
  """
  Rounds the tensor element-wise with rounding half to even.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3.5, -2.5, -1.5, -0.5, 0.5, 1.5, 2.5, 3.5]).round().numpy())
  ```
  """
  return ((self > 0).eq((b := self.trunc() / 2.0).trunc().eq(b))).where((self - 0.5).ceil(), (self + 0.5).floor())

isinf

isinf(
    detect_positive: bool = True,
    detect_negative: bool = True,
) -> Self

Checks the tensor element-wise to return True where the element is infinity, otherwise returns False

print(Tensor([1, float('inf'), 2, float('-inf'), float('nan')]).isinf().numpy())

[False  True False  True False]

Source code in tinygrad/mixin/elementwise.py

def isinf(self, detect_positive: bool = True, detect_negative: bool = True) -> Self:
  """
  Checks the tensor element-wise to return True where the element is infinity, otherwise returns False

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([1, float('inf'), 2, float('-inf'), float('nan')]).isinf().numpy())
  ```
  """
  return self.eq(float("inf")) * detect_positive + self.eq(float("-inf")) * detect_negative

isnan

isnan() -> Self

Checks the tensor element-wise to return True where the element is NaN, otherwise returns False

print(Tensor([1, float('inf'), 2, float('-inf'), float('nan')]).isnan().numpy())

[False False False False  True]

Source code in tinygrad/mixin/elementwise.py

def isnan(self) -> Self:
  """
  Checks the tensor element-wise to return True where the element is NaN, otherwise returns False

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([1, float('inf'), 2, float('-inf'), float('nan')]).isnan().numpy())
  ```
  """
  return self != self

isfinite

isfinite() -> Self

Checks the tensor element-wise to return True where the element is finite, otherwise returns False

print(Tensor([1, float('inf'), 2, float('-inf'), float('nan')]).isfinite().numpy())

[ True False  True False False]

Source code in tinygrad/mixin/elementwise.py

def isfinite(self) -> Self:
  """
  Checks the tensor element-wise to return True where the element is finite, otherwise returns False

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([1, float('inf'), 2, float('-inf'), float('nan')]).isfinite().numpy())
  ```
  """
  return (self.isinf() | self.isnan()).logical_not()

lerp

lerp(end: Self, weight: Self | ConstType) -> Self

Linearly interpolates between self and end by weight.

print(Tensor([1., 2., 3.]).lerp(Tensor([4., 5., 6.]), 0.5).numpy())

[2.5 3.5 4.5]

Source code in tinygrad/mixin/elementwise.py

def lerp(self, end: Self, weight: Self | ConstType) -> Self:
  """
  Linearly interpolates between `self` and `end` by `weight`.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([1., 2., 3.]).lerp(Tensor([4., 5., 6.]), 0.5).numpy())
  ```
  """
  if self.dtype == dtypes.uint8 and not isinstance(weight, ConstType):
    w_i = (weight * (1<<(W_PREC:=7)) + 0.5).cast(dtypes.int16)
    return (self+(((end - self).cast(dtypes.int8) * w_i + (1<<W_PREC-1)).cast(dtypes.uint16) >> W_PREC)).cast(dtypes.uint8)
  return self + (end - self) * weight

square

square() -> Self

Squares the tensor element-wise. Equivalent to self*self.

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).square().numpy())

[9. 4. 1. 0. 1. 4. 9.]

Source code in tinygrad/mixin/elementwise.py

def square(self) -> Self:
  """
  Squares the tensor element-wise.
  Equivalent to `self*self`.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).square().numpy())
  ```
  """
  return self * self

clamp

clamp(min_=None, max_=None) -> Self

Clips (clamps) the values in the tensor between min_ and max_ element-wise. If min_ is None, there is no lower bound. If max_ is None, there is no upper bound.

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).clip(-1, 1).numpy())

[-1. -1. -1.  0.  1.  1.  1.]

Source code in tinygrad/mixin/elementwise.py

def clamp(self, min_=None, max_=None) -> Self:
  """
  Clips (clamps) the values in the tensor between `min_` and `max_` element-wise.
  If `min_` is `None`, there is no lower bound. If `max_` is None, there is no upper bound.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).clip(-1, 1).numpy())
  ```
  """
  if min_ is None and max_ is None: raise RuntimeError("at least one of 'min_' or 'max_' must not be None")
  ret = (self < min_).where(min_, self) if min_ is not None else self
  return (ret > max_).where(max_, ret) if max_ is not None else ret

clip

clip(min_=None, max_=None) -> Self

Alias for Tensor.clamp.

Source code in tinygrad/mixin/elementwise.py

def clip(self, min_=None, max_=None) -> Self:
  """Alias for `Tensor.clamp`."""
  return self.clamp(min_, max_)

sign

sign() -> Self

Returns the sign of the tensor element-wise.

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).sign().numpy())

[-1. -1. -1.  0.  1.  1.  1.]

Source code in tinygrad/mixin/elementwise.py

def sign(self) -> Self:
  """
  Returns the sign of the tensor element-wise.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).sign().numpy())
  ```
  """
  return self.ne(0).where((self < 0).where(self.const_like(-1), self.const_like(1)), self.const_like(0))

abs

abs() -> Self

Computes the absolute value of the tensor element-wise.

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).abs().numpy())

[3. 2. 1. 0. 1. 2. 3.]

Source code in tinygrad/mixin/elementwise.py

def abs(self) -> Self:
  """
  Computes the absolute value of the tensor element-wise.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).abs().numpy())
  ```
  """
  return self * self.sign()

reciprocal

reciprocal() -> Self

Computes 1/x element-wise.

print(Tensor([1., 2., 3., 4.]).reciprocal().numpy())

[1.     0.5    0.3333 0.25  ]

Source code in tinygrad/mixin/elementwise.py

def reciprocal(self) -> Self:
  """
  Computes `1/x` element-wise.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([1., 2., 3., 4.]).reciprocal().numpy())
  ```
  """
  return self.alu(Ops.RECIPROCAL)

Unary Ops (activation)

relu

relu() -> Self

Applies the Rectified Linear Unit (ReLU) function element-wise.

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).relu().numpy())

[0. 0. 0. 0. 1. 2. 3.]

Source code in tinygrad/mixin/elementwise.py

def relu(self) -> Self:
  """
  Applies the Rectified Linear Unit (ReLU) function element-wise.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).relu().numpy())
  ```
  """
  # NOTE: if you write this as self.maximum(0) the gradient is wrong, passing through half when self is 0
  return (self > 0).where(self, 0)

sigmoid

sigmoid() -> Self

Applies the Sigmoid function element-wise.

• Described: https://en.wikipedia.org/wiki/Sigmoid_function

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).sigmoid().numpy())

[0.0474 0.1192 0.2689 0.5    0.7311 0.8808 0.9526]

Source code in tinygrad/mixin/elementwise.py

def sigmoid(self) -> Self:
  """
  Applies the Sigmoid function element-wise.

  - Described: https://en.wikipedia.org/wiki/Sigmoid_function

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).sigmoid().numpy())
  ```
  """
  return (1 + (self * (-1/math.log(2))).exp2()).reciprocal()

logsigmoid

logsigmoid() -> Self

Applies the LogSigmoid function element-wise.

• See: https://docs.pytorch.org/docs/stable/generated/torch.nn.functional.logsigmoid.html

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).logsigmoid().numpy())

[-3.0486 -2.1269 -1.3133 -0.6931 -0.3133 -0.1269 -0.0486]

Source code in tinygrad/mixin/elementwise.py

def logsigmoid(self) -> Self:
  """
  Applies the LogSigmoid function element-wise.

  - See: https://docs.pytorch.org/docs/stable/generated/torch.nn.functional.logsigmoid.html

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).logsigmoid().numpy())
  ```
  """
  return -(-self).softplus()

hardsigmoid

hardsigmoid(
    alpha: float = 1 / 6, beta: float = 0.5
) -> Self

Applies the Hardsigmoid function element-wise. NOTE: default alpha and beta values are taken from torch

• See: https://pytorch.org/docs/stable/generated/torch.nn.functional.hardsigmoid.html

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).hardsigmoid().numpy())

[0.     0.1667 0.3333 0.5    0.6667 0.8333 1.    ]

Source code in tinygrad/mixin/elementwise.py

def hardsigmoid(self, alpha: float = 1/6, beta: float = 0.5) -> Self:
  """
  Applies the Hardsigmoid function element-wise.
  NOTE: default `alpha` and `beta` values are taken from torch

  - See: https://pytorch.org/docs/stable/generated/torch.nn.functional.hardsigmoid.html

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).hardsigmoid().numpy())
  ```
  """
  return (alpha * self + beta).relu() - (alpha * self + beta - 1).relu()

elu

elu(alpha=1.0) -> Self

Applies the Exponential Linear Unit (ELU) function element-wise.

• Paper: https://arxiv.org/abs/1511.07289v5

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).elu().numpy())

[-0.9502 -0.8647 -0.6321  0.      1.      2.      3.    ]

Source code in tinygrad/mixin/elementwise.py

def elu(self, alpha=1.0) -> Self:
  """
  Applies the Exponential Linear Unit (ELU) function element-wise.

  - Paper: https://arxiv.org/abs/1511.07289v5

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).elu().numpy())
  ```
  """
  return self.relu() - alpha*(1-self.exp()).relu()

celu

celu(alpha=1.0) -> Self

Applies the Continuously differentiable Exponential Linear Unit (CELU) function element-wise.

• Paper: https://arxiv.org/abs/1704.07483

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).celu().numpy())

[-0.9502 -0.8647 -0.6321  0.      1.      2.      3.    ]

Source code in tinygrad/mixin/elementwise.py

def celu(self, alpha=1.0) -> Self:
  """
  Applies the Continuously differentiable Exponential Linear Unit (CELU) function element-wise.

  - Paper: https://arxiv.org/abs/1704.07483

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).celu().numpy())
  ```
  """
  return self.maximum(0) + (alpha * ((self / alpha).exp() - 1)).minimum(0)

selu

selu(alpha=1.67326, gamma=1.0507) -> Self

Applies the Scaled Exponential Linear Unit (SELU) function element-wise.

• Paper: https://arxiv.org/abs/1706.02515v5

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).selu().numpy())

[-1.6706 -1.5202 -1.1113  0.      1.0507  2.1014  3.1521]

Source code in tinygrad/mixin/elementwise.py

def selu(self, alpha=1.67326, gamma=1.0507) -> Self:
  """
  Applies the Scaled Exponential Linear Unit (SELU) function element-wise.

  - Paper: https://arxiv.org/abs/1706.02515v5

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).selu().numpy())
  ```
  """
  return gamma * (self >= 0).where(self, alpha * (self.exp() - 1))

swish

swish() -> Self

See .silu()

• Paper: https://arxiv.org/abs/1710.05941v1

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).swish().numpy())

[-0.1423 -0.2384 -0.2689  0.      0.7311  1.7616  2.8577]

Source code in tinygrad/mixin/elementwise.py

def swish(self) -> Self:
  """
  See `.silu()`

  - Paper: https://arxiv.org/abs/1710.05941v1

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).swish().numpy())
  ```
  """
  return self * self.sigmoid()

silu

silu() -> Self

Applies the Sigmoid Linear Unit (SiLU) function element-wise.

• Paper: https://arxiv.org/abs/1606.08415

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).silu().numpy())

[-0.1423 -0.2384 -0.2689  0.      0.7311  1.7616  2.8577]

Source code in tinygrad/mixin/elementwise.py

def silu(self) -> Self:
  """
  Applies the Sigmoid Linear Unit (SiLU) function element-wise.

  - Paper: https://arxiv.org/abs/1606.08415

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).silu().numpy())
  ```
  """
  return self.swish()  # The SiLU function is also known as the swish function.

relu6

relu6() -> Self

Applies the ReLU6 function element-wise.

• Paper: https://arxiv.org/abs/1704.04861v1

print(Tensor([-9., -6., -3., 0., 3., 6., 9.]).relu6().numpy())

[0. 0. 0. 0. 3. 6. 6.]

Source code in tinygrad/mixin/elementwise.py

def relu6(self) -> Self:
  """
  Applies the ReLU6 function element-wise.

  - Paper: https://arxiv.org/abs/1704.04861v1

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-9., -6., -3., 0., 3., 6., 9.]).relu6().numpy())
  ```
  """
  return self.relu() - (self-6).relu()

hardswish

hardswish() -> Self

Applies the Hardswish function element-wise.

• Paper: https://arxiv.org/abs/1905.02244v5

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).hardswish().numpy())

[-0.     -0.3333 -0.3333  0.      0.6667  1.6667  3.    ]

Source code in tinygrad/mixin/elementwise.py

def hardswish(self) -> Self:
  """
  Applies the Hardswish function element-wise.

  - Paper: https://arxiv.org/abs/1905.02244v5

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).hardswish().numpy())
  ```
  """
  return self * (self+3).relu6() * (1/6)

tanh

tanh() -> Self

Applies the Hyperbolic Tangent (tanh) function element-wise.

• Described: https://en.wikipedia.org/wiki/Hyperbolic_functions#Tanh

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).tanh().numpy())

[-0.9951 -0.964  -0.7616  0.      0.7616  0.964   0.9951]

Source code in tinygrad/mixin/elementwise.py

def tanh(self) -> Self:
  """
  Applies the Hyperbolic Tangent (tanh) function element-wise.

  - Described: https://en.wikipedia.org/wiki/Hyperbolic_functions#Tanh

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).tanh().numpy())
  ```
  """
  return 2.0 * ((2.0 * self).sigmoid()) - 1.0

sinh

sinh() -> Self

Applies the Hyperbolic Sine (sinh) function element-wise.

• Described: https://en.wikipedia.org/wiki/Hyperbolic_functions#Sinh

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).sinh().numpy())

[-10.0179  -3.6269  -1.1752   0.       1.1752   3.6269  10.0179]

Source code in tinygrad/mixin/elementwise.py

def sinh(self) -> Self:
  """
  Applies the Hyperbolic Sine (sinh) function element-wise.

  - Described: https://en.wikipedia.org/wiki/Hyperbolic_functions#Sinh

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).sinh().numpy())
  ```
  """
  return (self.exp() - self.neg().exp()) / 2

cosh

cosh() -> Self

Applies the Hyperbolic Cosine (cosh) function element-wise.

• Described: https://en.wikipedia.org/wiki/Hyperbolic_functions#Cosh

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).cosh().numpy())

[10.0677  3.7622  1.5431  1.      1.5431  3.7622 10.0677]

Source code in tinygrad/mixin/elementwise.py

def cosh(self) -> Self:
  """
  Applies the Hyperbolic Cosine (cosh) function element-wise.

  - Described: https://en.wikipedia.org/wiki/Hyperbolic_functions#Cosh

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).cosh().numpy())
  ```
  """
  return (self.exp() + self.neg().exp()) / 2

atanh

atanh() -> Self

Applies the Inverse Hyperbolic Tangent (atanh) function element-wise.

• Described: https://en.wikipedia.org/wiki/Inverse_hyperbolic_functions#atanh

print(Tensor([-0.9, -0.6, -0.3, 0., 0.3, 0.6, 0.9]).atanh().numpy())

[-1.4722 -0.6931 -0.3095  0.      0.3095  0.6931  1.4722]

Source code in tinygrad/mixin/elementwise.py

def atanh(self) -> Self:
  """
  Applies the Inverse Hyperbolic Tangent (atanh) function element-wise.

  - Described: https://en.wikipedia.org/wiki/Inverse_hyperbolic_functions#atanh

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-0.9, -0.6, -0.3, 0., 0.3, 0.6, 0.9]).atanh().numpy())
  ```
  """
  return ((1 + self)/(1 - self)).log() / 2

asinh

asinh() -> Self

Applies the Inverse Hyperbolic Sine (asinh) function element-wise.

• Described: https://en.wikipedia.org/wiki/Inverse_hyperbolic_functions#asinh

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).asinh().numpy())

[-1.8184 -1.4436 -0.8814  0.      0.8814  1.4436  1.8184]

Source code in tinygrad/mixin/elementwise.py

def asinh(self) -> Self:
  """
  Applies the Inverse Hyperbolic Sine (asinh) function element-wise.

  - Described: https://en.wikipedia.org/wiki/Inverse_hyperbolic_functions#asinh

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).asinh().numpy())
  ```
  """
  return (self + (self.square() + 1).sqrt()).log()

acosh

acosh() -> Self

Applies the Inverse Hyperbolic Cosine (acosh) function element-wise.

• Described: https://en.wikipedia.org/wiki/Inverse_hyperbolic_functions#acosh

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).acosh().numpy())

[   nan    nan    nan    nan 0.     1.317  1.7627]

Source code in tinygrad/mixin/elementwise.py

def acosh(self) -> Self:
  """
  Applies the Inverse Hyperbolic Cosine (acosh) function element-wise.

  - Described: https://en.wikipedia.org/wiki/Inverse_hyperbolic_functions#acosh

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).acosh().numpy())
  ```
  """
  return (self + (self.square() - 1).sqrt()).log()

hardtanh

hardtanh(min_val=-1, max_val=1) -> Self

Applies the Hardtanh function element-wise.

print(Tensor([-1.5, -1.0, -0.5, 0., 0.5, 1.0, 1.5]).hardtanh().numpy())

[-1.  -1.  -0.5  0.   0.5  1.   1. ]

Source code in tinygrad/mixin/elementwise.py

def hardtanh(self, min_val=-1, max_val=1) -> Self:
  """
  Applies the Hardtanh function element-wise.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-1.5, -1.0, -0.5, 0., 0.5, 1.0, 1.5]).hardtanh().numpy())
  ```
  """
  return self.clip(min_val, max_val)

erf

erf() -> Self

Applies error function element-wise.

• Described: https://en.wikipedia.org/wiki/Error_function

print(Tensor([-1.5, -1.0, -0.5, 0., 0.5, 1.0, 1.5]).erf().numpy())

[-0.9661 -0.8427 -0.5205  0.      0.5205  0.8427  0.9661]

Source code in tinygrad/mixin/elementwise.py

def erf(self) -> Self:
  """
  Applies error function element-wise.

  - Described: https://en.wikipedia.org/wiki/Error_function

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-1.5, -1.0, -0.5, 0., 0.5, 1.0, 1.5]).erf().numpy())
  ```
  """
  # https://personal.math.ubc.ca/~cbm/aands/page_299.htm 7.1.26
  t = 1.0 / (1.0 + 0.3275911 * self.abs())
  return self.sign() * (1.0 - t * polyN(t, [1.061405429, -1.453152027, 1.421413741, -0.284496736, 0.254829592]) * (-self.square()).exp())

gelu

gelu(approximate: str = 'tanh') -> Self

Applies the Gaussian Error Linear Unit (GELU) function element-wise.

• Paper: https://arxiv.org/abs/1606.08415v5

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).gelu().numpy())

[-0.0036 -0.0454 -0.1588  0.      0.8412  1.9546  2.9964]

Source code in tinygrad/mixin/elementwise.py

def gelu(self, approximate:str="tanh") -> Self:
  """
  Applies the Gaussian Error Linear Unit (GELU) function element-wise.

  - Paper: https://arxiv.org/abs/1606.08415v5

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).gelu().numpy())
  ```
  """
  if approximate == "tanh":
    return 0.5 * self * (1 + (math.sqrt(2 / math.pi) * (self + 0.044715 * self ** 3)).tanh())
  elif approximate == "none":
    return self * 0.5 * (1.0 + (self / math.sqrt(2)).erf())
  else:
    raise RuntimeError(f"{approximate=} is not supported")

quick_gelu

quick_gelu() -> Self

Applies the Sigmoid GELU approximation element-wise.

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).quick_gelu().numpy())

[-0.0181 -0.0643 -0.1542  0.      0.8458  1.9357  2.9819]

Source code in tinygrad/mixin/elementwise.py

def quick_gelu(self) -> Self:
  """
  Applies the Sigmoid GELU approximation element-wise.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).quick_gelu().numpy())
  ```
  """
  return self * (self * 1.702).sigmoid()

leaky_relu

leaky_relu(neg_slope=0.01) -> Self

Applies the Leaky ReLU function element-wise.

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).leaky_relu().numpy())

[-0.03 -0.02 -0.01  0.    1.    2.    3.  ]

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).leaky_relu(neg_slope=0.42).numpy())

[-1.26 -0.84 -0.42  0.    1.    2.    3.  ]

Source code in tinygrad/mixin/elementwise.py

def leaky_relu(self, neg_slope=0.01) -> Self:
  """
  Applies the Leaky ReLU function element-wise.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).leaky_relu().numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).leaky_relu(neg_slope=0.42).numpy())
  ```
  """
  return (self < 0).where(neg_slope*self, self)

mish

mish() -> Self

Applies the Mish function element-wise.

• Paper: https://arxiv.org/abs/1908.08681v3

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).mish().numpy())

[-0.1456 -0.2525 -0.3034  0.      0.8651  1.944   2.9865]

Source code in tinygrad/mixin/elementwise.py

def mish(self) -> Self:
  """
  Applies the Mish function element-wise.

  - Paper: https://arxiv.org/abs/1908.08681v3

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).mish().numpy())
  ```
  """
  return self * self.softplus().tanh()

softplus

softplus(beta=1.0) -> Self

Applies the Softplus function element-wise.

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).softplus().numpy())

[0.0486 0.1269 0.3133 0.6931 1.3133 2.1269 3.0486]

Source code in tinygrad/mixin/elementwise.py

def softplus(self, beta=1.0) -> Self:
  """
  Applies the Softplus function element-wise.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).softplus().numpy())
  ```
  """
  return (1/beta) * (self*beta).logaddexp(0.0)

softsign

softsign() -> Self

Applies the Softsign function element-wise.

print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).softsign().numpy())

[-0.75   -0.6667 -0.5     0.      0.5     0.6667  0.75  ]

Source code in tinygrad/mixin/elementwise.py

def softsign(self) -> Self:
  """
  Applies the Softsign function element-wise.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-3., -2., -1., 0., 1., 2., 3.]).softsign().numpy())
  ```
  """
  return self / (1 + self.abs())

Elementwise Ops (broadcasted)

add

add(x: Self | ConstType, reverse: bool = False) -> Self

Adds self and x. Equivalent to self + x. Supports broadcasting to a common shape, type promotion, and integer, float, boolean inputs.

Tensor.manual_seed(42)
t = Tensor.randn(4)
print(t.numpy())

[0.6226 0.1706 0.8297 0.3067]

print(t.add(20).numpy())

[20.6226 20.1706 20.8297 20.3067]

print(t.add(Tensor([[2.0], [3.5]])).numpy())

[[2.6226 2.1706 2.8297 2.3067]
 [4.1226 3.6706 4.3297 3.8067]]

Source code in tinygrad/mixin/elementwise.py

def add(self, x: Self | ConstType, reverse: bool = False) -> Self:
  """
  Adds `self` and `x`.
  Equivalent to `self + x`.
  Supports broadcasting to a common shape, type promotion, and integer, float, boolean inputs.
  ```python exec="true" source="above" session="tensor" result="python"
  Tensor.manual_seed(42)
  t = Tensor.randn(4)
  print(t.numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print(t.add(20).numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print(t.add(Tensor([[2.0], [3.5]])).numpy())
  ```
  """
  return self._binop(Ops.ADD, x, reverse)

sub

sub(x: Self | ConstType, reverse: bool = False) -> Self

Subtracts x from self. Equivalent to self - x. Supports broadcasting to a common shape, type promotion, and integer, float, boolean inputs.

Tensor.manual_seed(42)
t = Tensor.randn(4)
print(t.numpy())

[0.6226 0.1706 0.8297 0.3067]

print(t.sub(20).numpy())

[-19.3774 -19.8294 -19.1703 -19.6933]

print(t.sub(Tensor([[2.0], [3.5]])).numpy())

[[-1.3774 -1.8294 -1.1703 -1.6933]
 [-2.8774 -3.3294 -2.6703 -3.1933]]

Source code in tinygrad/mixin/elementwise.py

def sub(self, x: Self | ConstType, reverse: bool = False) -> Self:
  """
  Subtracts `x` from `self`.
  Equivalent to `self - x`.
  Supports broadcasting to a common shape, type promotion, and integer, float, boolean inputs.

  ```python exec="true" source="above" session="tensor" result="python"
  Tensor.manual_seed(42)
  t = Tensor.randn(4)
  print(t.numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print(t.sub(20).numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print(t.sub(Tensor([[2.0], [3.5]])).numpy())
  ```
  """
  a, b = self._broadcasted(x, reverse)
  # alu, not +: _broadcasted already promoted these, and a second promote would cast -b (only a bare weak CONST is kept weak)
  return a.alu(Ops.ADD, -b)

mul

mul(x: Self | ConstType, reverse: bool = False) -> Self

Multiplies self and x. Equivalent to self * x. Supports broadcasting to a common shape, type promotion, and integer, float, boolean inputs.

Tensor.manual_seed(42)
t = Tensor.randn(4)
print(t.numpy())

[0.6226 0.1706 0.8297 0.3067]

print(t.mul(3).numpy())

[1.8678 0.5117 2.4891 0.9202]

print(t.mul(Tensor([[-1.0], [2.0]])).numpy())

[[-0.6226 -0.1706 -0.8297 -0.3067]
 [ 1.2452  0.3412  1.6594  0.6135]]

Source code in tinygrad/mixin/elementwise.py

def mul(self, x: Self | ConstType, reverse: bool = False) -> Self:
  """
  Multiplies `self` and `x`.
  Equivalent to `self * x`.
  Supports broadcasting to a common shape, type promotion, and integer, float, boolean inputs.

  ```python exec="true" source="above" session="tensor" result="python"
  Tensor.manual_seed(42)
  t = Tensor.randn(4)
  print(t.numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print(t.mul(3).numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print(t.mul(Tensor([[-1.0], [2.0]])).numpy())
  ```
  """
  return self._binop(Ops.MUL, x, reverse)

div

div(
    x: Self | ConstType | UOp,
    reverse: bool = False,
    rounding_mode: Literal["trunc", "floor"] | None = None,
) -> Self

Divides self by x. Equivalent to self / x. Supports broadcasting to a common shape, type promotion, and integer, float, boolean inputs. div performs true division by default; pass rounding_mode="trunc" for truncating toward zero or rounding_mode="floor" for floor division.

Tensor.manual_seed(42)
t = Tensor.randn(4)
print(t.numpy())

[0.6226 0.1706 0.8297 0.3067]

print(t.div(3).numpy())

[0.2075 0.0569 0.2766 0.1022]

print(Tensor([1, 4, 10]).div(Tensor([2, 3, 4])).numpy())

[0.5    1.3333 2.5   ]

Source code in tinygrad/mixin/elementwise.py

def div(self, x: 'Self|ConstType|UOp', reverse: bool = False, rounding_mode: Literal["trunc", "floor"] | None = None) -> Self:
  """
  Divides `self` by `x`.
  Equivalent to `self / x`.
  Supports broadcasting to a common shape, type promotion, and integer, float, boolean inputs.
  `div` performs true division by default; pass `rounding_mode="trunc"` for truncating toward zero
  or `rounding_mode="floor"` for floor division.

  ```python exec="true" source="above" session="tensor" result="python"
  Tensor.manual_seed(42)
  t = Tensor.randn(4)
  print(t.numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print(t.div(3).numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([1, 4, 10]).div(Tensor([2, 3, 4])).numpy())
  ```
  """
  a, b = self._broadcasted(x, reverse)
  if dtypes.is_int(a.dtype) and dtypes.is_int(b.dtype):
    if rounding_mode == "trunc": return a.alu(Ops.CDIV, b)
    if rounding_mode == "floor": return a.alu(Ops.FLOORDIV, b)
  if dtypes.is_int(a.dtype) or a.dtype == dtypes.bool: a = a.cast(dtypes.default_float)
  # alu, not *: _broadcasted already promoted these, and a second promote would cast 1/b (only a bare weak CONST is kept weak)
  d = a.alu(Ops.MUL, b.reciprocal())
  if rounding_mode is None: return d
  if rounding_mode == "trunc": return d.trunc()
  if rounding_mode == "floor": return d.floor()
  raise RuntimeError(f"{rounding_mode=} is not supported")

mod

mod(x: Self | ConstType, reverse: bool = False) -> Self

Mod self by x. Equivalent to self % x. Supports broadcasting to a common shape, type promotion, and integer inputs.

print(Tensor([-4, 7, 5, 4, -7, 8]).mod(Tensor([2, -3, 8, -2, 3, 5])).numpy())

[ 0 -2  5  0  2  3]

Source code in tinygrad/mixin/elementwise.py

def mod(self, x: Self | ConstType, reverse: bool = False) -> Self:
  """
  Mod `self` by `x`.
  Equivalent to `self % x`.
  Supports broadcasting to a common shape, type promotion, and integer inputs.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-4, 7, 5, 4, -7, 8]).mod(Tensor([2, -3, 8, -2, 3, 5])).numpy())
  ```
  """
  a, b = self._broadcasted(x, reverse)
  if dtypes.is_int(a.dtype) and dtypes.is_int(b.dtype): return a.alu(Ops.FLOORMOD, b)
  return a - a.div(b, rounding_mode="floor") * b

fmod

fmod(x: Self | ConstType) -> Self

C-style remainder of self divided by x (sign follows the dividend), using truncating division. Differs from mod/%, which uses Python floor remainder.

print(Tensor([-4, 7, 5, 4, -7, 8]).fmod(Tensor([2, -3, 8, -2, 3, 5])).numpy())

[ 0  1  5  0 -1  3]

Source code in tinygrad/mixin/elementwise.py

def fmod(self, x: Self | ConstType) -> Self:
  """
  C-style remainder of `self` divided by `x` (sign follows the dividend), using truncating division.
  Differs from `mod`/`%`, which uses Python floor remainder.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-4, 7, 5, 4, -7, 8]).fmod(Tensor([2, -3, 8, -2, 3, 5])).numpy())
  ```
  """
  a, b = self._broadcasted(x)
  if dtypes.is_int(a.dtype) and dtypes.is_int(b.dtype): return a.alu(Ops.CMOD, b)
  return a - a.div(b, rounding_mode="trunc") * b

bitwise_xor

bitwise_xor(
    x: Self | ConstType, reverse: bool = False
) -> Self

Computes bitwise xor of self and x. Equivalent to self ^ x. Supports broadcasting to a common shape, type promotion, and integer, boolean inputs.

print(Tensor([-1, -2, 3]).bitwise_xor(Tensor([1, 0, 3])).numpy())

[-2 -2  0]

print(Tensor([True, True, False, False]).bitwise_xor(Tensor([True, False, True, False])).numpy())

[False  True  True False]

Source code in tinygrad/mixin/elementwise.py

def bitwise_xor(self, x: Self | ConstType, reverse: bool = False) -> Self:
  """
  Computes bitwise xor of `self` and `x`.
  Equivalent to `self ^ x`.
  Supports broadcasting to a common shape, type promotion, and integer, boolean inputs.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-1, -2, 3]).bitwise_xor(Tensor([1, 0, 3])).numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([True, True, False, False]).bitwise_xor(Tensor([True, False, True, False])).numpy())
  ```
  """
  return self._binop(Ops.XOR, x, reverse)

bitwise_and

bitwise_and(
    x: Self | ConstType, reverse: bool = False
) -> Self

Computes the bitwise AND of self and x. Equivalent to self & x. Supports broadcasting to a common shape, type promotion, and integer, boolean inputs.

print(Tensor([2, 5, 255]).bitwise_and(Tensor([3, 14, 16])).numpy())

[ 2  4 16]

print(Tensor([True, True, False, False]).bitwise_and(Tensor([True, False, True, False])).numpy())

[ True False False False]

Source code in tinygrad/mixin/elementwise.py

def bitwise_and(self, x: Self | ConstType, reverse: bool = False) -> Self:
  """
  Computes the bitwise AND of `self` and `x`.
  Equivalent to `self & x`.
  Supports broadcasting to a common shape, type promotion, and integer, boolean inputs.
  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([2, 5, 255]).bitwise_and(Tensor([3, 14, 16])).numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([True, True, False, False]).bitwise_and(Tensor([True, False, True, False])).numpy())
  ```
  """
  return self._binop(Ops.AND, x, reverse)

bitwise_or

bitwise_or(
    x: Self | ConstType, reverse: bool = False
) -> Self

Computes the bitwise OR of self and x. Equivalent to self | x. Supports broadcasting to a common shape, type promotion, and integer, boolean inputs.

print(Tensor([2, 5, 255]).bitwise_or(Tensor([4, 4, 4])).numpy())

[  6   5 255]

print(Tensor([True, True, False, False]).bitwise_or(Tensor([True, False, True, False])).numpy())

[ True  True  True False]

Source code in tinygrad/mixin/elementwise.py

def bitwise_or(self, x: Self | ConstType, reverse: bool = False) -> Self:
  """
  Computes the bitwise OR of `self` and `x`.
  Equivalent to `self | x`.
  Supports broadcasting to a common shape, type promotion, and integer, boolean inputs.
  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([2, 5, 255]).bitwise_or(Tensor([4, 4, 4])).numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([True, True, False, False]).bitwise_or(Tensor([True, False, True, False])).numpy())
  ```
  """
  return self._binop(Ops.OR, x, reverse)

bitwise_not

bitwise_not() -> Self

Computes the bitwise NOT of self. Equivalent to ~self.

print(Tensor([0, 2, 5, 255], dtype="int8").bitwise_not().numpy())

[-1 -3 -6  0]

print(Tensor([True, False]).bitwise_not().numpy())

[False  True]

Source code in tinygrad/mixin/elementwise.py

def bitwise_not(self) -> Self:
  """
  Computes the bitwise NOT of `self`.
  Equivalent to `~self`.
  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([0, 2, 5, 255], dtype="int8").bitwise_not().numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([True, False]).bitwise_not().numpy())
  ```
  """
  if self.dtype == dtypes.bool: return self.logical_not()
  return (self ^ self.dtype.max) if dtypes.is_unsigned(self.dtype) else (self ^ -1)

lshift

lshift(x: Self | int, reverse: bool = False) -> Self

Computes left arithmetic shift of self by x bits. self must have integer dtype. Equivalent to self << x.

print(Tensor([1, 3, 31], dtype=dtypes.uint8).lshift(2).numpy())

[  4  12 124]

Source code in tinygrad/mixin/elementwise.py

def lshift(self, x: Self | int, reverse: bool = False) -> Self:
  """
  Computes left arithmetic shift of `self` by `x` bits. `self` must have integer dtype.
  Equivalent to `self << x`.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([1, 3, 31], dtype=dtypes.uint8).lshift(2).numpy())
  ```
  """
  return self._binop(Ops.SHL, x, reverse)

rshift

rshift(x: Self | int, reverse: bool = False) -> Self

Computes right arithmetic shift of self by x bits. self must have integer dtype. Equivalent to self >> x.

print(Tensor([4, 13, 125], dtype=dtypes.uint8).rshift(2).numpy())

[ 1  3 31]

Source code in tinygrad/mixin/elementwise.py

def rshift(self, x: Self | int, reverse: bool = False) -> Self:
  """
  Computes right arithmetic shift of `self` by `x` bits. `self` must have integer dtype.
  Equivalent to `self >> x`.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([4, 13, 125], dtype=dtypes.uint8).rshift(2).numpy())
  ```
  """
  return self._binop(Ops.SHR, x, reverse)

pow

pow(x: Self | ConstType, reverse: bool = False) -> Self

Computes power of self with x. Equivalent to self ** x.

print(Tensor([-1, 2, 3]).pow(2.0).numpy())

[1. 4. 9.]

print(Tensor([-1, 2, 3]).pow(Tensor([-1.5, 0.5, 1.5])).numpy())

[   nan 1.4142 5.1962]

print((2.0 ** Tensor([-1, 2, 3])).numpy())

[0.5 4.  8. ]

Source code in tinygrad/mixin/elementwise.py

def pow(self, x: Self | ConstType, reverse: bool = False) -> Self:
  """
  Computes power of `self` with `x`.
  Equivalent to `self ** x`.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-1, 2, 3]).pow(2.0).numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-1, 2, 3]).pow(Tensor([-1.5, 0.5, 1.5])).numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print((2.0 ** Tensor([-1, 2, 3])).numpy())
  ```
  """
  base, exponent = self._broadcasted(x, reverse=reverse)
  # TODO: int pow
  if not dtypes.is_float(least_upper_dtype(base.dtype, exponent.dtype)) and isinstance(x, ConstType) and not (isinstance(x, int) and x >= 0):
    raise RuntimeError("base needs to be float")
  return base.alu(Ops.POW, exponent)

maximum

maximum(x: Self | ConstType) -> Self

Computes element-wise maximum of self and x.

print(Tensor([-1, 2, 3]).maximum(1).numpy())

[1 2 3]

print(Tensor([-1, 2, 3]).maximum(Tensor([-4, -2, 9])).numpy())

[-1  2  9]

Source code in tinygrad/mixin/elementwise.py

def maximum(self, x: Self | ConstType) -> Self:
  """
  Computes element-wise maximum of `self` and `x`.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-1, 2, 3]).maximum(1).numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-1, 2, 3]).maximum(Tensor([-4, -2, 9])).numpy())
  ```
  """
  return self._binop(Ops.MAX, x, False)

minimum

minimum(x: Self | ConstType) -> Self

Computes element-wise minimum of self and x.

print(Tensor([-1, 2, 3]).minimum(1).numpy())

[-1  1  1]

print(Tensor([-1, 2, 3]).minimum(Tensor([-4, -2, 9])).numpy())

[-4 -2  3]

Source code in tinygrad/mixin/elementwise.py

def minimum(self, x: Self | ConstType) -> Self:
  """
  Computes element-wise minimum of `self` and `x`.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-1, 2, 3]).minimum(1).numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor([-1, 2, 3]).minimum(Tensor([-4, -2, 9])).numpy())
  ```
  """
  t, x = self._broadcasted(x)
  # NOTE: the int inverse is done in python, since const has weak dtype without width
  # TODO: clean this up once _broadcasted does not promote dtype
  if dtypes.is_float(dt:=least_upper_dtype(t.dtype, x.dtype)): return -(-t).alu(Ops.MAX, -x)
  return (t ^ (k:=dt.const(dt.min+dt.max))).alu(Ops.MAX, x ^ k) ^ k

where

where(
    x: Self | ConstType | sint, y: Self | ConstType | sint
) -> Self

Returns a tensor of elements selected from either x or y, depending on self. output_i = x_i if self_i else y_i.

cond = Tensor([[True, True, False], [True, False, False]])
print(cond.where(1, 3).numpy())

[[1 1 3]
 [1 3 3]]

Source code in tinygrad/mixin/elementwise.py

def where(self, x: 'Self | ConstType | sint', y: 'Self | ConstType | sint') -> Self:
  """
  Returns a tensor of elements selected from either `x` or `y`, depending on `self`.
  `output_i = x_i if self_i else y_i`.

  ```python exec="true" source="above" session="tensor" result="python"
  cond = Tensor([[True, True, False], [True, False, False]])
  print(cond.where(1, 3).numpy())
  ```
  """
  ref = x if isinstance(x, type(self)) else y if isinstance(y, type(self)) else self
  x, y = ref.ufix(x)._broadcasted(y)
  return self.alu(Ops.WHERE, x, y)

copysign

copysign(other: Self | ConstType) -> Self

Returns a tensor of with the magnitude of self and the sign of other, elementwise.

Source code in tinygrad/mixin/elementwise.py

def copysign(self, other: Self | ConstType) -> Self:
  """
  Returns a tensor of with the magnitude of `self` and the sign of `other`, elementwise.
  """
  # NOTE: torch always return in float, we return based on the broadcasting rule.
  a, b = self._broadcasted(other)
  return ((b < 0) | (b.reciprocal() < 0)).where(-(mag := a.abs()), mag)

logaddexp

logaddexp(other: Self | ConstType) -> Self

Calculates (self.exp()+other.exp()).log(), elementwise.

Source code in tinygrad/mixin/elementwise.py

def logaddexp(self, other: Self | ConstType) -> Self:
  """
  Calculates (self.exp()+other.exp()).log(), elementwise.
  """
  a, b = self._broadcasted(other)
  m = a.maximum(b)
  return ((a-m).exp() + (b-m).exp()).log() + m

Casting Ops

cast

cast(dtype: DTypeLike) -> Self

Casts self to the given dtype.

t = Tensor([-1, 2.5, 3], dtype=dtypes.float)
print(t.dtype, t.numpy())

dtypes.float [-1.   2.5  3. ]

t = t.cast(dtypes.int32)
print(t.dtype, t.numpy())

dtypes.int [-1  2  3]

t = t.cast(dtypes.uint8)
print(t.dtype, t.numpy())

dtypes.uchar [255   2   3]

Source code in tinygrad/mixin/dtype.py

def cast(self, dtype:DTypeLike) -> Self:
  """
  Casts `self` to the given `dtype`.

  ```python exec="true" source="above" session="tensor" result="python"
  t = Tensor([-1, 2.5, 3], dtype=dtypes.float)
  print(t.dtype, t.numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  t = t.cast(dtypes.int32)
  print(t.dtype, t.numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  t = t.cast(dtypes.uint8)
  print(t.dtype, t.numpy())
  ```
  """
  return self if self.dtype == (dt:=to_dtype(dtype)) else self._wrap_uop(self._uop.alu(Ops.CAST, arg=dt))

bitcast

bitcast(dtype: DTypeLike) -> Self

Bitcasts self to the given dtype. If the itemsize differs, the last axis is rescaled.

t = Tensor([-1, 2, 3], dtype=dtypes.int32)
print(t.dtype, t.numpy())

dtypes.int [-1  2  3]

t = t.bitcast(dtypes.uint32)
print(t.dtype, t.numpy())

dtypes.uint [4294967295          2          3]

Source code in tinygrad/mixin/dtype.py

def bitcast(self, dtype:DTypeLike) -> Self:
  """
  Bitcasts `self` to the given `dtype`. If the itemsize differs, the last axis is rescaled.

  ```python exec="true" source="above" session="tensor" result="python"
  t = Tensor([-1, 2, 3], dtype=dtypes.int32)
  print(t.dtype, t.numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  t = t.bitcast(dtypes.uint32)
  print(t.dtype, t.numpy())
  ```
  """
  dt = to_dtype(dtype)
  if self.dtype in dtypes.weaks or dt in dtypes.weaks: raise RuntimeError(f"bitcast requires concrete dtypes, got {self.dtype} -> {dt}")
  return self if self.dtype == dt else self._wrap_uop(self._uop.alu(Ops.BITCAST, arg=dt))

float

float() -> Self

Convenience method to cast self to a float32 Tensor.

t = Tensor([-1, 2, 3], dtype=dtypes.int32)
print(t.dtype, t.numpy())

dtypes.int [-1  2  3]

t = t.float()
print(t.dtype, t.numpy())

dtypes.float [-1.  2.  3.]

Source code in tinygrad/mixin/dtype.py

def float(self) -> Self:
  """
  Convenience method to cast `self` to a `float32` Tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  t = Tensor([-1, 2, 3], dtype=dtypes.int32)
  print(t.dtype, t.numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  t = t.float()
  print(t.dtype, t.numpy())
  ```
  """
  return self.cast(dtypes.float32)

half

half() -> Self

Convenience method to cast self to a float16 Tensor.

t = Tensor([-1, 2, 3], dtype=dtypes.int32)
print(t.dtype, t.numpy())

dtypes.int [-1  2  3]

t = t.half()
print(t.dtype, t.numpy())

dtypes.half [-1.  2.  3.]

Source code in tinygrad/mixin/dtype.py

def half(self) -> Self:
  """
  Convenience method to cast `self` to a `float16` Tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  t = Tensor([-1, 2, 3], dtype=dtypes.int32)
  print(t.dtype, t.numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  t = t.half()
  print(t.dtype, t.numpy())
  ```
  """
  return self.cast(dtypes.float16)

int

int() -> Self

Convenience method to cast self to a int32 Tensor.

t = Tensor([-1.5, -0.5, 0.0, 0.5, 1.5])
print(t.dtype, t.numpy())

dtypes.float [-1.5 -0.5  0.   0.5  1.5]

t = t.int()
print(t.dtype, t.numpy())

dtypes.int [-1  0  0  0  1]

Source code in tinygrad/mixin/dtype.py

def int(self) -> Self:
  """
  Convenience method to cast `self` to a `int32` Tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  t = Tensor([-1.5, -0.5, 0.0, 0.5, 1.5])
  print(t.dtype, t.numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  t = t.int()
  print(t.dtype, t.numpy())
  ```
  """
  return self.cast(dtypes.int32)

bool

bool() -> Self

Convenience method to cast self to a bool Tensor.

t = Tensor([-1, 0, 1])
print(t.dtype, t.numpy())

dtypes.int [-1  0  1]

t = t.bool()
print(t.dtype, t.numpy())

dtypes.bool [ True False  True]

Source code in tinygrad/mixin/dtype.py

def bool(self) -> Self:
  """
  Convenience method to cast `self` to a `bool` Tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  t = Tensor([-1, 0, 1])
  print(t.dtype, t.numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  t = t.bool()
  print(t.dtype, t.numpy())
  ```
  """
  return self.cast(dtypes.bool)

bfloat16

bfloat16() -> Self

Source code in tinygrad/mixin/dtype.py

def bfloat16(self) -> Self: return self.cast(dtypes.bfloat16)

double

double() -> Self

Source code in tinygrad/mixin/dtype.py

def double(self) -> Self: return self.cast(dtypes.double)

long

long() -> Self

Source code in tinygrad/mixin/dtype.py

def long(self) -> Self: return self.cast(dtypes.long)

short

short() -> Self

Source code in tinygrad/mixin/dtype.py

def short(self) -> Self: return self.cast(dtypes.short)