Enum Primitive 

#[non_exhaustive]
pub enum Primitive {
    Unary(UnaryOp),
    Binary(BinaryOp),
    Select,
    AsType(DType),
    Reshape(Vec<usize>),
    Transpose(Vec<usize>),
    Slice {
        start: Vec<usize>,
        step: Vec<isize>,
        len: Vec<usize>,
    },
    Broadcast(Vec<usize>),
    Reduce {
        op: ReduceOp,
        axes: Vec<usize>,
    },
    ArgReduce {
        op: ArgReduceOp,
        axis: usize,
    },
    Matmul,
}

An operation recorded in the graph, with its parameters.

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.

Unary(UnaryOp)

Element-wise function of one operand.

Binary(BinaryOp)

Element-wise function of two operands of equal shape and dtype.

Select

where(condition, a, b): a boolean condition selects from a or b.

AsType(DType)

Conversion to another element type.

Reshape(Vec<usize>)

The same elements in another shape. A view when the layout permits, else a copy.

Transpose(Vec<usize>)

Axes reordered: output axis i is input axis axes[i]. A view.

Slice

A normalised slice per dimension. A view.

Fields

start: Vec<usize>

First index per dimension.

step: Vec<isize>

Step per dimension (non-zero, may be negative).

len: Vec<usize>

Number of selected indices per dimension (the output shape).

Broadcast(Vec<usize>)

Presented as a larger shape with zero strides. A view.

Reduce

Reduction over sorted, unique axes; reduced dimensions become size 1.

Fields

op: ReduceOp

The reduction.

axes: Vec<usize>

Reduced axes, sorted and unique.

ArgReduce

Index of an extreme value along axis (uint32); the axis becomes size 1.

Fields

op: ArgReduceOp

Maximum or minimum.

axis: usize

The reduced axis.

Matmul

Batched matrix product of [B..., M, K] and [B..., K, N] with equal batch dimensions.

Implementations

impl Primitive

pub fn name(&self) -> &'static str

The operation’s name, as used in error messages.

Trait Implementations

impl Clone for Primitive

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Primitive

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

Formats the value using the given formatter.

impl Eq for Primitive

impl Hash for Primitive

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

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 Primitive

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Primitive