Enum BinaryKind 

#[non_exhaustive]
#[repr(u16)]
pub enum BinaryKind {
    Add = 0,
    Sub = 1,
    Mul = 2,
    Div = 3,
    FloorDivide = 4,
    Mod = 5,
    Remainder = 6,
    Pow = 7,
    Atan2 = 8,
    Hypot = 9,
    Copysign = 10,
    Nextafter = 11,
    Ldexp = 12,
    Minimum = 13,
    Maximum = 14,
    Fmin = 15,
    Fmax = 16,
    Eq = 17,
    Ne = 18,
    Gt = 19,
    Ge = 20,
    Lt = 21,
    Le = 22,
    LogicalAnd = 23,
    LogicalOr = 24,
    LogicalXor = 25,
    BitwiseAnd = 26,
    BitwiseOr = 27,
    BitwiseXor = 28,
    BitwiseLeftShift = 29,
    BitwiseRightShift = 30,
    Lerp = 31,
}

Binary elementwise op discriminant.

Stored as u16 in crate::KernelSku::op when category == OpCategory::BinaryElementwise. Variants correspond to the union of PyTorch (torch.<op> / torch.Tensor.<op>) and JAX (jax.numpy.<op> / jax.lax.<op>) binary elementwise ops.

Today only Self::Add is wired — the Phase 3 trailblazer SKU. The other variants are reserved discriminants for the fanout sessions that ship sub / mul / div / pow / comparisons / bitwise.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Add = 0

y = a + b — elementwise addition. Trailblazer SKU for baracuda-kernels Phase 3.

Sub = 1

y = a - b — elementwise subtraction.

Mul = 2

y = a * b — elementwise multiplication.

Div = 3

y = a / b — elementwise division.

FloorDivide = 4

y = floor(a / b) — elementwise floor-divide.

Mod = 5

y = a mod b — elementwise Python-style modulo (sign matches b).

Remainder = 6

y = remainder(a, b) — elementwise C-style remainder (sign matches a).

Pow = 7

y = a ** b — elementwise power (broadcast scalar exponent OK).

Atan2 = 8

y = atan2(a, b).

Hypot = 9

y = hypot(a, b) = sqrt(a² + b²).

Copysign = 10

y = a with sign-bit copied from b.

Nextafter = 11

y = next representable value from a toward b.

Ldexp = 12

y = a · 2^b (integer b broadcast as scalar in practice).

Minimum = 13

y = min(a, b) — IEEE 754 semantics (NaN-aware).

Maximum = 14

y = max(a, b) — IEEE 754 semantics (NaN-aware).

Fmin = 15

y = fmin(a, b) — PyTorch fmin (NaN-propagating-from-other).

Fmax = 16

y = fmax(a, b) — PyTorch fmax (NaN-propagating-from-other).

Eq = 17

y = (a == b) — returns bool.

Ne = 18

y = (a != b) — returns bool.

Gt = 19

y = (a > b) — returns bool.

Ge = 20

y = (a >= b) — returns bool.

Lt = 21

y = (a < b) — returns bool.

Le = 22

y = (a <= b) — returns bool.

LogicalAnd = 23

y = a && b — bool only.

LogicalOr = 24

y = a || b — bool only.

LogicalXor = 25

y = a ^ b (logical) — bool only.

BitwiseAnd = 26

y = a & b — integer only.

BitwiseOr = 27

y = a | b — integer only.

BitwiseXor = 28

y = a ^ b (bitwise) — integer only.

BitwiseLeftShift = 29

y = a << b — integer only.

BitwiseRightShift = 30

y = a >> b — integer only.

Lerp = 31

y = a + (b - a) * weight (broadcast scalar weight). Per PyTorch’s torch.lerp convention.

Trait Implementations

impl Clone for BinaryKind

fn clone(&self) -> BinaryKind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for BinaryKind

impl Debug for BinaryKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Eq for BinaryKind

impl Hash for BinaryKind

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for BinaryKind

fn eq(&self, other: &BinaryKind) -> 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 StructuralPartialEq for BinaryKind