Enum ElementwiseOp 

pub enum ElementwiseOp {
    Relu,
    Gelu,
    Sigmoid,
    Silu,
    Tanh,
    Neg,
    Abs,
    Sqrt,
    Rsqrt,
    Exp,
    Log,
    Ceil,
    Floor,
    HardSigmoid,
    HardSwish,
    Softplus,
    LeakyRelu,
    OneMinus,
    Add,
    Sub,
    Mul,
    Div,
    Pow,
    Min,
    Max,
    CmpEq,
    CmpNe,
    CmpLt,
    CmpGt,
    CmpLe,
    CmpGe,
    OrMax,
    OrProbSum,
    Nand,
    Nor,
    Xor,
    Scale,
    AddScalar,
    FusedAddRelu,
    FusedScaleAdd,
}

Elementwise operation types supported by the BLAS elementwise module.

Each variant corresponds to a PTX kernel generated by oxicuda_ptx::templates::elementwise::ElementwiseTemplate.

Variants

Relu

Rectified linear unit: output[i] = max(0, input[i]).

Gelu

Gaussian error linear unit (tanh approximation).

Sigmoid

Sigmoid activation: output[i] = 1 / (1 + exp(-input[i])).

Silu

Sigmoid linear unit: output[i] = input[i] * sigmoid(input[i]).

Tanh

Hyperbolic tangent activation.

Neg

Arithmetic negation: output[i] = -input[i].

Abs

Absolute value: output[i] = |input[i]|.

Sqrt

Square root: output[i] = sqrt(input[i]).

Rsqrt

Reciprocal square root: output[i] = 1 / sqrt(input[i]).

Exp

Exponential: output[i] = exp(input[i]).

Log

Natural logarithm: output[i] = ln(input[i]).

Ceil

Ceiling: output[i] = ceil(input[i]).

Floor

Floor: output[i] = floor(input[i]).

HardSigmoid

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

HardSwish

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

Softplus

Softplus: output[i] = ln(1 + exp(input[i])).

LeakyRelu

Leaky relu: output[i] = input[i] >= 0 ? input[i] : 0.01 * input[i].

OneMinus

One-minus: output[i] = 1 - input[i].

Add

Element-wise addition: C[i] = A[i] + B[i].

Sub

Element-wise subtraction: C[i] = A[i] - B[i].

Mul

Element-wise multiplication (Hadamard product): C[i] = A[i] * B[i].

Div

Element-wise division: C[i] = A[i] / B[i].

Pow

Element-wise power: C[i] = A[i]^B[i].

Min

Element-wise minimum: C[i] = min(A[i], B[i]).

Max

Element-wise maximum: C[i] = max(A[i], B[i]).

CmpEq

Comparison equal: C[i] = (A[i] == B[i]) ? 1.0 : 0.0.

CmpNe

Comparison not-equal: C[i] = (A[i] != B[i]) ? 1.0 : 0.0.

CmpLt

Comparison less-than: C[i] = (A[i] < B[i]) ? 1.0 : 0.0.

CmpGt

Comparison greater-than: C[i] = (A[i] > B[i]) ? 1.0 : 0.0.

CmpLe

Comparison less-or-equal: C[i] = (A[i] <= B[i]) ? 1.0 : 0.0.

CmpGe

Comparison greater-or-equal: C[i] = (A[i] >= B[i]) ? 1.0 : 0.0.

OrMax

Fuzzy OR via max: C[i] = max(A[i], B[i]).

OrProbSum

Probabilistic OR: C[i] = A[i] + B[i] - A[i]*B[i].

Nand

Fuzzy NAND: C[i] = 1 - A[i]*B[i].

Nor

Fuzzy NOR: C[i] = 1 - (A[i] + B[i] - A[i]*B[i]).

Xor

Fuzzy XOR: C[i] = A[i] + B[i] - 2*A[i]*B[i].

Scale

Scalar scaling: output[i] = alpha * input[i].

AddScalar

Add scalar: output[i] = input[i] + scalar.

FusedAddRelu

Fused add + ReLU: C[i] = max(0, A[i] + B[i]).

FusedScaleAdd

Fused scale-add: C[i] = alpha * A[i] + beta * B[i].

Implementations

impl ElementwiseOp

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

Returns a short lowercase name for diagnostics and logging.

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