Enum SimdBackend 

pub enum SimdBackend {
    Scalar,
    Sse2,
    Avx2,
}

Available SIMD backends, selected at runtime based on CPU features.

Variants

Scalar

Scalar fallback — works on all platforms.

Sse2

x86/x86_64 SSE2 (128-bit, 4 floats at a time).

Avx2

x86/x86_64 AVX2 + FMA (256-bit, 8 floats at a time).

Implementations

impl SimdBackend

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

Returns the name of this backend.

pub fn dot_product(self, a: &[f32], b: &[f32]) -> f32

Compute the dot product of two float slices.

a and b must have the same length. Returns sum of a[i]*b[i].

pub fn dual_dot_product( self, input: &[f32], k1: &[f32], k2: &[f32], ) -> (f32, f32)

Compute two dot products in parallel (for sinc resampler convolution).

Returns (dot(input, k1), dot(input, k2)). All slices must have the same length.

pub fn convolve_sinc( self, input: &[f32], k1: &[f32], k2: &[f32], kernel_interpolation_factor: f64, ) -> f32

Sinc resampler convolution: dual dot product with interpolation.

Computes (1-f)*dot(input,k1) + f*dot(input,k2) where f is the kernel_interpolation_factor. Unlike dual_dot_product() followed by scalar interpolation, this performs interpolation on SIMD vectors before horizontal reduction, matching C++ SincResampler::Convolve_* rounding behavior exactly.

The scalar fallback interpolates in f64 matching C++ Convolve_C.

pub fn multiply_accumulate(self, acc: &mut [f32], a: &[f32], b: &[f32])

Element-wise multiply-accumulate: acc[i] += a[i] * b[i]

acc, a, and b must have the same length.

pub fn sum(self, x: &[f32]) -> f32

Compute the sum of all elements in a slice.

pub fn elementwise_sqrt(self, x: &mut [f32])

Elementwise square root: x[i] = sqrt(x[i])

pub fn elementwise_multiply(self, x: &[f32], y: &[f32], z: &mut [f32])

Elementwise vector multiplication: z[i] = x[i] * y[i]

x, y, and z must have the same length.

pub fn elementwise_accumulate(self, x: &[f32], z: &mut [f32])

Elementwise accumulate: z[i] += x[i]

x and z must have the same length.

pub fn power_spectrum(self, re: &[f32], im: &[f32], out: &mut [f32])

Compute the power spectrum: out[i] = re[i]^2 + im[i]^2

re, im, and out must have the same length.

pub fn elementwise_min(self, a: &[f32], b: &[f32], out: &mut [f32])

Elementwise minimum: out[i] = min(a[i], b[i])

a, b, and out must have the same length.

pub fn elementwise_max(self, a: &[f32], b: &[f32], out: &mut [f32])

Elementwise maximum: out[i] = max(a[i], b[i])

a, b, and out must have the same length.

pub fn complex_multiply_accumulate( self, x_re: &[f32], x_im: &[f32], h_re: &[f32], h_im: &[f32], acc_re: &mut [f32], acc_im: &mut [f32], )

Complex multiply-accumulate (AEC3 conjugate convention): acc_re[i] += x_re[i]*h_re[i] + x_im[i]*h_im[i] acc_im[i] += x_re[i]*h_im[i] - x_im[i]*h_re[i]

All slices must have the same length.

pub fn complex_multiply_accumulate_standard( self, x_re: &[f32], x_im: &[f32], h_re: &[f32], h_im: &[f32], acc_re: &mut [f32], acc_im: &mut [f32], )

Standard complex multiply-accumulate: acc_re[i] += x_re[i]*h_re[i] - x_im[i]*h_im[i] acc_im[i] += x_re[i]*h_im[i] + x_im[i]*h_re[i]

All slices must have the same length.

Trait Implementations

impl Clone for SimdBackend

fn clone(&self) -> SimdBackend

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SimdBackend

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

Formats the value using the given formatter.

impl PartialEq for SimdBackend

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

impl Eq for SimdBackend

impl StructuralPartialEq for SimdBackend