Struct SimdOps 

pub struct SimdOps;

SIMD-accelerated operations.

Implementations

impl SimdOps

pub fn saxpy(a: f32, x: &[f32], y: &mut [f32])

SAXPY: y = a * x + y (f32)

Single-precision A*X Plus Y operation, fundamental to linear algebra.

pub fn daxpy(a: f64, x: &[f64], y: &mut [f64])

DAXPY: y = a * x + y (f64)

Double-precision A*X Plus Y operation.

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

Element-wise addition: z = x + y

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

Element-wise subtraction: z = x - y

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

Element-wise multiplication: z = x * y

pub fn dot_f32(x: &[f32], y: &[f32]) -> f32

Dot product: sum(x * y)

pub fn scale_f32(a: f32, x: &mut [f32])

Scale vector: x *= a

impl SimdOps

pub fn sum_f32(x: &[f32]) -> f32

Sum of f32 array using SIMD.

pub fn sum_f64(x: &[f64]) -> f64

Sum of f64 array using SIMD.

pub fn max_f32(x: &[f32]) -> f32

Maximum of f32 array.

pub fn min_f32(x: &[f32]) -> f32

Minimum of f32 array.

pub fn mean_f32(x: &[f32]) -> f32

Mean of f32 array.

impl SimdOps

pub fn laplacian_2d_f32( p: &[f32], laplacian: &mut [f32], width: usize, height: usize, )

2D Laplacian stencil (5-point).

Computes: laplacian[i,j] = p[i-1,j] + p[i+1,j] + p[i,j-1] + p[i,j+1] - 4*p[i,j]

This is the core operation for FDTD wave simulations.

pub fn fdtd_step_2d_f32( p: &[f32], p_prev: &mut [f32], c2: f32, width: usize, height: usize, )

2D FDTD wave equation step.

Computes: p_next[i,j] = 2*p[i,j] - p_prev[i,j] + c2 * laplacian(p)[i,j]

This is a complete wave simulation timestep.

pub fn laplacian_3d_f32( p: &[f32], laplacian: &mut [f32], width: usize, height: usize, depth: usize, )

3D Laplacian stencil (7-point).

Computes the 3D discrete Laplacian for volumetric simulations.

impl SimdOps

pub fn par_saxpy(a: f32, x: &[f32], y: &mut [f32])

Parallel SAXPY using Rayon + SIMD.

Best for large arrays (> 100K elements).

pub fn par_sum_f32(x: &[f32]) -> f32

Parallel sum using Rayon + SIMD.

pub fn par_fdtd_step_2d_f32( p: &[f32], p_prev: &mut [f32], c2: f32, width: usize, height: usize, )

Parallel 2D FDTD step using Rayon + SIMD.

Parallelizes over rows for better cache efficiency.

impl SimdOps

pub fn sum_i32(x: &[i32]) -> i64

Sum of i32 array using SIMD.

pub fn add_i32(x: &[i32], y: &[i32], z: &mut [i32])

Element-wise i32 addition.