Enum BinaryCmpKind 

#[non_exhaustive]
#[repr(u16)]
pub enum BinaryCmpKind {
    Eq = 0,
    Ne = 1,
    Gt = 2,
    Ge = 3,
    Lt = 4,
    Le = 5,
}

Binary comparison op discriminant.

Stored as u16 in crate::KernelSku::op when category == OpCategory::BinaryElementwise and the SKU is from the comparison family — distinguished from BinaryKind because the output dtype is fixed to u8 (PyTorch / NumPy convention: bool stored as 1 byte, 0 = false, 1 = true) regardless of the input element type.

Today only Self::Eq on f32 is wired — the Phase 3 comparison trailblazer. The other variants are reserved discriminants for the fanout sessions.

Why a separate enum (rather than reusing BinaryKind): the dispatch shape differs — these ops produce a different dtype than they consume, so they need their own Plan type (BinaryCmpPlan<T, N> with TensorMut<u8> output) instead of BinaryPlan<T, N> with TensorMut<T> output. The reserved Eq / Ne / Gt / Ge / Lt / Le slots in BinaryKind are vestigial — they will never be wired into the same-dtype binary path.

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.

Eq = 0

y = (a == b) — elementwise equality. Trailblazer SKU.

Ne = 1

y = (a != b).

Gt = 2

y = (a > b).

Ge = 3

y = (a >= b).

Lt = 4

y = (a < b).

Le = 5

y = (a <= b).

Trait Implementations

impl Clone for BinaryCmpKind

fn clone(&self) -> BinaryCmpKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for BinaryCmpKind

impl Debug for BinaryCmpKind

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

Formats the value using the given formatter.

impl Eq for BinaryCmpKind

impl Hash for BinaryCmpKind

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 BinaryCmpKind

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