Enum ElementwiseOp 

pub enum ElementwiseOp {
    Add,
    Sub,
    Mul,
    Div,
    Relu,
    Gelu,
    Sigmoid,
    Silu,
    Tanh,
    Neg,
    Abs,
    Sqrt,
    Rsqrt,
    Exp,
    Log,
    Scale,
    AddScalar,
    Ceil,
    Floor,
    HardSigmoid,
    HardSwish,
    Softplus,
    LeakyRelu,
    FusedAddRelu,
    FusedScaleAdd,
}

Elementwise operation type.

Covers binary arithmetic, unary activations, unary math, and fused operations. Each variant determines the kernel signature (number of input/output pointers) and the PTX instruction sequence emitted in the kernel body.

Variants

Add

Element-wise addition: c[i] = a[i] + b[i].

Sub

Element-wise subtraction: c[i] = a[i] - b[i].

Mul

Element-wise multiplication: c[i] = a[i] * b[i].

Div

Element-wise division: c[i] = a[i] / b[i].

Relu

Rectified linear unit: b[i] = max(0, a[i]).

Gelu

Gaussian error linear unit (tanh approximation): b[i] = 0.5 * a[i] * (1 + tanh(sqrt(2/pi) * (a[i] + 0.044715 * a[i]^3))).

Sigmoid

Sigmoid activation: b[i] = 1 / (1 + exp(-a[i])).

Silu

Sigmoid linear unit: b[i] = a[i] * sigmoid(a[i]).

Tanh

Hyperbolic tangent: b[i] = tanh(a[i]).

Neg

Arithmetic negation: b[i] = -a[i].

Abs

Absolute value: b[i] = |a[i]|.

Sqrt

Square root: b[i] = sqrt(a[i]).

Rsqrt

Reciprocal square root: b[i] = 1 / sqrt(a[i]).

Exp

Exponential: b[i] = exp(a[i]).

Log

Natural logarithm: b[i] = ln(a[i]).

Scale

Scalar scaling: b[i] = alpha * a[i].

AddScalar

Add scalar: b[i] = a[i] + scalar.

Ceil

Ceiling (round toward +inf): b[i] = ceil(a[i]).

Floor

Floor (round toward -inf): b[i] = floor(a[i]).

HardSigmoid

Hard sigmoid: b[i] = max(0, min(1, 0.2*a[i] + 0.5)).

HardSwish

Hard swish: b[i] = a[i] * max(0, min(6, a[i]+3)) / 6.

Softplus

Softplus: b[i] = ln(1 + exp(a[i])).

LeakyRelu

Leaky relu: b[i] = a[i] >= 0 ? a[i] : 0.01 * a[i].

FusedAddRelu

Fused add-relu: c[i] = relu(a[i] + b[i]).

FusedScaleAdd

Fused scale-add: c[i] = alpha * a[i] + beta * b[i].

Implementations

impl ElementwiseOp

pub const fn as_str(self) -> &'static str

Returns a short lowercase name suitable for kernel naming.

pub const fn is_binary(self) -> bool

Returns true if this is a binary operation requiring two input arrays.

pub const fn needs_scalar(self) -> bool

Returns true if this operation requires scalar parameter(s).

Trait Implementations

impl Clone for ElementwiseOp

fn clone(&self) -> ElementwiseOp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ElementwiseOp

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

Formats the value using the given formatter.

impl Hash for ElementwiseOp

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 ElementwiseOp

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

impl Eq for ElementwiseOp

impl StructuralPartialEq for ElementwiseOp