Struct Sse2Backend 

pub struct Sse2Backend;

SSE2 backend (128-bit SIMD for x86_64)

Trait Implementations

impl VectorBackend for Sse2Backend

unsafe fn add(a: &[f32], b: &[f32], result: &mut [f32])

Element-wise addition: a[i] + b[i]

unsafe fn sub(a: &[f32], b: &[f32], result: &mut [f32])

Element-wise subtraction: a[i] - b[i]

unsafe fn mul(a: &[f32], b: &[f32], result: &mut [f32])

Element-wise multiplication: a[i] * b[i]

unsafe fn div(a: &[f32], b: &[f32], result: &mut [f32])

Element-wise division: a[i] / b[i]

unsafe fn dot(a: &[f32], b: &[f32]) -> f32

Dot product: sum(a[i] * b[i])

unsafe fn sum(a: &[f32]) -> f32

Sum reduction: sum(a[i])

unsafe fn max(a: &[f32]) -> f32

Max reduction: max(a[i])

unsafe fn min(a: &[f32]) -> f32

Min reduction: min(a[i])

unsafe fn argmax(a: &[f32]) -> usize

Argmax: index of maximum value

unsafe fn argmin(a: &[f32]) -> usize

Argmin: index of minimum value

unsafe fn sum_kahan(a: &[f32]) -> f32

Kahan summation: numerically stable sum(a[i])

unsafe fn norm_l2(a: &[f32]) -> f32

L2 norm (Euclidean norm): sqrt(sum(a[i]^2))

unsafe fn norm_l1(a: &[f32]) -> f32

L1 norm (Manhattan norm): sum(|a[i]|)

unsafe fn norm_linf(a: &[f32]) -> f32

L-infinity norm (maximum absolute value): max(|a[i]|)

unsafe fn scale(a: &[f32], scalar: f32, result: &mut [f32])

Scalar multiplication: result[i] = a[i] * scalar

unsafe fn abs(a: &[f32], result: &mut [f32])

Absolute value: result[i] = |a[i]|

unsafe fn clamp(a: &[f32], min_val: f32, max_val: f32, result: &mut [f32])

Clamp elements to range [min_val, max_val]: result[i] = max(min_val, min(a[i], max_val))

unsafe fn lerp(a: &[f32], b: &[f32], t: f32, result: &mut [f32])

Linear interpolation: result[i] = a[i] + t * (b[i] - a[i])

unsafe fn fma(a: &[f32], b: &[f32], c: &[f32], result: &mut [f32])

Fused multiply-add: result[i] = a[i] * b[i] + c[i]

unsafe fn relu(a: &[f32], result: &mut [f32])

ReLU activation: result[i] = max(0, a[i])

unsafe fn exp(a: &[f32], result: &mut [f32])

Exponential function: result[i] = exp(a[i])

unsafe fn sigmoid(a: &[f32], result: &mut [f32])

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

unsafe fn gelu(a: &[f32], result: &mut [f32])

GELU activation: result[i] = 0.5 * x * (1 + tanh(sqrt(2/π) * (x + 0.044715 * x³)))

unsafe fn swish(a: &[f32], result: &mut [f32])

Swish activation: result[i] = x * sigmoid(x) = x / (1 + exp(-x))

unsafe fn tanh(a: &[f32], result: &mut [f32])

Hyperbolic tangent activation: result[i] = tanh(a[i]) = (exp(2x) - 1) / (exp(2x) + 1)

unsafe fn sqrt(a: &[f32], result: &mut [f32])

Square root: result[i] = sqrt(a[i])

unsafe fn recip(a: &[f32], result: &mut [f32])

Reciprocal: result[i] = 1 / a[i]

unsafe fn ln(a: &[f32], result: &mut [f32])

Natural logarithm: result[i] = ln(a[i])

unsafe fn log2(a: &[f32], result: &mut [f32])

Base-2 logarithm: result[i] = log2(a[i])

unsafe fn log10(a: &[f32], result: &mut [f32])

Base-10 logarithm: result[i] = log10(a[i])

unsafe fn sin(a: &[f32], result: &mut [f32])

Sine: result[i] = sin(a[i])

unsafe fn cos(a: &[f32], result: &mut [f32])

Cosine: result[i] = cos(a[i])

unsafe fn tan(a: &[f32], result: &mut [f32])

Tangent: result[i] = tan(a[i])

unsafe fn floor(a: &[f32], result: &mut [f32])

Floor: result[i] = floor(a[i])

unsafe fn ceil(a: &[f32], result: &mut [f32])

Ceiling: result[i] = ceil(a[i])

unsafe fn round(a: &[f32], result: &mut [f32])

Round: result[i] = round(a[i])