Enum SortKind 

#[non_exhaustive]
#[repr(u16)]
pub enum SortKind {
    Sort = 0,
    SortBackward = 1,
    Argsort = 2,
    Msort = 3,
    MsortBackward = 4,
    Topk = 5,
    TopkBackward = 6,
    Kthvalue = 7,
    KthvalueBackward = 8,
    Unique = 9,
    UniqueConsecutive = 10,
    Histogram = 11,
    Histogramdd = 12,
    Bincount = 13,
    Searchsorted = 14,
}

Sorting / order-statistics op discriminant — Category O from the comprehensive plan (Phase 9).

Stored as u16 in crate::KernelSku::op when category == OpCategory::Sorting. Phase 9 wires the block-bitonic trailblazer family (row_len ≤ 1024, k ≤ 64):

• Self::Sort / Self::SortBackward — full sort with saved indices for BW. PyTorch torch.sort.
• Self::Argsort — indices-only variant. PyTorch torch.argsort.
• Self::Msort / Self::MsortBackward — stable sort (tie-break on original index preserves input order). PyTorch torch.msort.
• Self::Topk / Self::TopkBackward — top-k by value (or bottom-k when largest == false). PyTorch torch.topk.
• Self::Kthvalue / Self::KthvalueBackward — composed atop topk; returns the k-th value + its index.
• Self::Unique / Self::UniqueConsecutive — set-valued ops; unique chains sort + consecutive-dedup, unique_consecutive assumes the input is already sorted (or only run-equal cells matter). No BW (set-valued).
• Self::Histogram / Self::Histogramdd / Self::Bincount — atomic-bin accumulation; histogram + bincount FW shipped, histogramdd reserved (rank > 1 trailblazer follow-up).
• Self::Searchsorted — per-query binary search in a 1-D sorted array. PyTorch torch.searchsorted. No BW.

Dtype coverage:

• sort / argsort / msort FW: f32, f64, i32, i64.
• sort / msort BW: f32, f64 (FP grads only).
• topk FW + BW: f32, f64.
• kthvalue: composes topk; same dtype set.
• unique / unique_consecutive: f32, f64, i32.
• histogram: f32, f64 input → i32 counts.
• bincount: i32, i64 input → i32 counts.
• searchsorted: f32, f64, i32, i64.

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.

Sort = 0

sort(x, dim, descending) — returns sorted values + sorted indices. PyTorch torch.sort.

SortBackward = 1

Gradient of Self::Sort — scatter dy back to the original positions via the saved indices.

Argsort = 2

argsort(x, dim, descending) — returns sorted indices only. PyTorch torch.argsort.

Msort = 3

msort(x) — stable sort along the last dimension. Tie-break on original index preserves input order. PyTorch torch.msort.

MsortBackward = 4

Gradient of Self::Msort — same scatter as Self::SortBackward.

Topk = 5

topk(x, k, dim, largest) — top-k (or bottom-k) values + their indices. PyTorch torch.topk. Trailblazer caps k ≤ 64.

TopkBackward = 6

Gradient of Self::Topk — scatter the k-wide dy back to a zero-init row_len-wide dx via saved indices.

Kthvalue = 7

kthvalue(x, k, dim) — the k-th smallest value + its index. Composed at the Rust plan layer atop Self::Topk with the “bottom-k” order.

KthvalueBackward = 8

Gradient of Self::Kthvalue — scatter the scalar dy back to the single source position.

Unique = 9

unique(x, sorted=True) — returns the unique values in x. At the Rust plan layer this chains Self::Sort + the consecutive dedup. Set-valued — no BW.

UniqueConsecutive = 10

unique_consecutive(x) — emits one cell per run-start (input must be sorted, or only consecutive-equal cells should be collapsed). Set-valued — no BW.

Histogram = 11

histogram(x, bins, range) — 1-D uniform-bin histogram. PyTorch torch.histogram. FW only.

Histogramdd = 12

histogramdd(x, bins, range) — N-D histogram. Reserved discriminant; rank > 1 trailblazer follow-up.

Bincount = 13

bincount(x, minlength) — count occurrences of each integer in x. PyTorch torch.bincount. FW only.

Searchsorted = 14

searchsorted(sorted_seq, values, right) — per-query lower/upper bound binary search. PyTorch torch.searchsorted. FW only.

Trait Implementations

impl Clone for SortKind

fn clone(&self) -> SortKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for SortKind

impl Debug for SortKind

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

Formats the value using the given formatter.

impl Eq for SortKind

impl Hash for SortKind

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 SortKind

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